基于SSM实现智慧幼儿园信息管理系统

作者主页：编程千纸鹤

作者简介：Java、前端、Pythone开发多年，做过高程，项目经理，架构师

主要内容：Java项目开发、毕业设计开发、面试技术整理、最新技术分享

项目编号：BS-XX-139

一，项目简介

   跨入21世纪，人类社会进入了信息化时代。以信息及时为代表的高新技术极大的促进了社会经济的迅猛发展，并且已经在各个方面改变了我们的工作和生活方式。
   在企业中实施信息管理系统是使企业信息化的重要标志之一。信息管理系统是指基于计算机、通信网络等现代化的工具和手段，服务于信息处理的系统。信息管理系统的实施能使企业实现办公自动化、决策支持等。在幼儿园中实施信息管理系统可以在实现办公自动化的同时，提高幼儿园管理水平、教学质量和为家长服务的质量。但在目前市场上适用于幼儿园的信息管理系统软件数量不多，且质量也参差不齐。本文主要论述幼儿园信息管理系统的设计、开发、实现和维护，并探讨系统的适用性以及功能的高效率。
   针对幼儿园用户的实际情况，确定了软件模式为B/S，开发工具采用C#，数据库产品采用Sql server。文章首先对幼儿园网络信息管理系统的需求作了详尽的分析，给出了详细的需求说明和各模块说明以及用例说明。接着，从系统的界面实现、数据库实现和主要模块实现等方面研究了幼儿园信息管理系统的具体实现技术。系统的使用不仅可以提高幼儿园管理水平，还可以减少办园经费，提高幼儿园的运作效率。

系统的主要功能有：

指南针幼儿园管理系统，共分为三种角色，管理员、家长、教师。

管理员角色具有功能：

系统管理-用户管理、页面管理、角色管理，

校园管理-老师管理、工资管理、物资管理、菜谱管理、班级管理

班级管理-学生管理、公告管理、课程管理

考勤管理-老师考勤、学生考勤、老师考勤统计、学生考勤统计、签到签退

系统有着完备的权限管理功能，可以根据需要为家长和老师分配相关的权限。系统整功能设计完整，结构清晰，适合做毕业设计使用。

二，环境介绍

语言环境：Java: jdk1.8

数据库：Mysql: mysql5.7+Redis

应用服务器：Tomcat: tomcat8.5.31

开发工具：IDEA或eclipse

后端采用Springboot+MyBatis+MySQL+Shrio
前端使用layui+html+thymeleaf

三，系统展示

管理员用户登陆：

用户管理

菜单管理

角色管理：可以为用户指定相应的角色，并为角色分配权限

老师管理功能

工资管理

物资管理

菜谱管理

班级管理

学生管理

公告管理

课程管理

老师考勤

学生考勤

老师考勤统计报表

学生考勤统计报表

签到签退：学生和家长均可以进行在线签到，家长签到就统计到自己的孩中去

老师登陆系统：

主要进行班级管理和考勤管理

家长登陆系统：

四，核心代码展示


package com.bskms.controller;
 
import java.util.List;
 
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.subject.Subject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
 
import com.bskms.bean.Page;
import com.bskms.bean.User;
import com.bskms.model.ResultMap;
import com.bskms.service.PageService;
import com.bskms.service.UserService;
 
/**
 * class name:LoginController 
 * class description: 登录操作 
 * Remark: 
 */
@Controller
public class LoginController {
	@Autowired
	private ResultMap resultMap;
	@Autowired
	private UserService userService;// 用户登录service
	@Autowired
	private PageService pageService;
 
	private final Logger logger = LoggerFactory.getLogger(LoginController.class);
 
	@RequestMapping(value = "/notLogin", method = RequestMethod.GET)
	@ResponseBody
	public ResultMap notLogin() {
		logger.warn("尚未登陆！");
		return resultMap.success().message("您尚未登陆！");
	}
 
	@RequestMapping(value = "/notRole", method = RequestMethod.GET)
	@ResponseBody
	public ResultMap notRole() {
		Subject subject = SecurityUtils.getSubject();
		User user = (User) subject.getPrincipal();
		if (user != null) {
			logger.info("{}---没有权限！", user.getUserName());
		}
		return resultMap.success().message("您没有权限！");
	}
 
	/**
	 * Method name: logout 
	 * Description: 退出登录 
	 * @return String
	 */
	@RequestMapping(value = "/logout", method = RequestMethod.GET)
	public String logout() {
		Subject subject = SecurityUtils.getSubject();
		User user = (User) subject.getPrincipal();
		if (null != user) {
			logger.info("{}---退出登录！", user.getUserName());
		}
		subject.logout();
		return "login";
	}
 
	/**
	 * Method name: login 
	 * Description: 登录验证 
	 * Remark: 
	 * 
	 * @param username 用户名
	 * @param password 密码
	 * @return ResultMap
	 */
	@RequestMapping(value = "/login")
	@ResponseBody
	public ResultMap login(String username, String password) {
		return userService.login(username, password);
	}
 
	/**
	 * Method name: login 
	 * Description: 登录页面 
	 * 
	 * @return String login.html
	 */
	@RequestMapping(value = "/index")
	public String login() {
		return "login";
	}
 
	/**
	 * Method name: index 
	 * Description: 登录页面 
	 * 
	 * @return String login.html
	 */
	@RequestMapping(value = "/")
	public String index(Model model) {
		Subject subject = SecurityUtils.getSubject();
		User user = (User) subject.getPrincipal();
 
		if (null != user) {
			model.addAttribute("user", user);
 
			List pageList = pageService.getAllRolePageByUserId(user.getUserId());
 
			model.addAttribute("pageList", pageList);
			return "index";
		} else {
			return "login";
		}
	}
 
	/**
	 * Method name: main 
	 * Description: 进入主页面 
	 * 
	 * @param model
	 * @return String
	 */
	@RequestMapping(value = "/main")
	public String main(Model model) {
		Subject subject = SecurityUtils.getSubject();
		User user = (User) subject.getPrincipal();
		if (null != user) {
			model.addAttribute("user", user);
		} else {
			return "login";
		}
 
		List pageList = pageService.getAllRolePageByUserId(user.getUserId());
 
		model.addAttribute("pageList", pageList);
		return "index";
	}
 
	/**
	 * Method name: checkUserPassword 
	 * Description: 检测旧密码是否正确 
	 * 
	 * @param password 旧密码
	 * @return boolean 是否正确
	 */
	@RequestMapping(value = "/user/checkUserPassword")
	@ResponseBody
	public boolean checkUserPassword(String password) {
		return userService.checkUserPassword(password);
	}
 
	/**
	 * Method name: updatePassword 
	 * Description: 更新密码 
	 * 
	 * @param password 旧密码
	 * @return String 是否成功
	 */
	@RequestMapping(value = "/user/updatePassword")
	@ResponseBody
	public String updatePassword(String password) {
		return userService.updatePassword(password);
	}
}


package com.bskms.controller;
 
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
 
import com.alibaba.fastjson.JSON;
import com.bskms.bean.Children;
import com.bskms.bean.Classes;
import com.bskms.bean.Course;
import com.bskms.bean.Foot;
import com.bskms.bean.Notice;
import com.bskms.bean.Sign;
import com.bskms.bean.User;
import com.bskms.model.XiaoYuan;
import com.bskms.service.JiaZhangService;
import com.bskms.service.NoticeService;
import com.bskms.service.SignService;
import com.bskms.utils.MyUtils;
import com.bskms.utils.PropertyUtil;
 
@Controller
@RequestMapping(value = "/jz")
@ResponseBody
public class JiaZhangController {
	@Autowired
	NoticeService noticeService;
	@Autowired
	JiaZhangService jiaZhangService;
	@Autowired
	SignService signService;
	
	@RequestMapping(value = "/notices")
	public Object notices() {
		List notices = new ArrayList<>();
		notices = noticeService.getAllNotice();
		return JSON.toJSONString(notices);
	}
	
	@RequestMapping(value = "/xy")
	public Object xy(String userId) {
		XiaoYuan xy = new XiaoYuan();
		
		if(userId==null || userId.equals("null")) {
			return JSON.toJSONString(xy);
		}
		
		//获取当天食物
		Foot foot = jiaZhangService.getFoot();
		
		//获取孩子信息
		List childres = jiaZhangService.getChildren(userId);
		
		//获取课程
		Course course = null;
		Sign qd = null; 
		Sign qt =  null;
		User bzr = null;
		Classes cl = null;
		if(childres.size()!=0) {			
			course = jiaZhangService.getCourse(childres.get(0).getClassId());
			//签到记录
			qd =  jiaZhangService.getSign(1, childres.get(0).getId()+"");
			qt =  jiaZhangService.getSign(2, childres.get(0).getId()+"");
			
			//获取班主任信息
			bzr = jiaZhangService.getBZR(childres.get(0).getClassId());
			
			//获取班级
			cl = jiaZhangService.getClasses(childres.get(0).getClassId());
		}
		
		
		//获取家长信息
		User jiazhang = jiaZhangService.getJiaZhang(userId);
		
		
		if(bzr!=null) {
			xy.setBanZhuRen(bzr.getUserName());
			xy.setBanZhuRenHao(bzr.getUserTel());
		}
		if(cl!=null) {			
			xy.setClassName(cl.getName());
		}
		if(childres.size()!=0) {			
			xy.setcName(childres.get(0).getName());
		}
		if(qd!=null) {			
			xy.setQiandao(MyUtils.getDate2String(qd.getSignIn()));
		}
		if(qt!=null) {			
			xy.setQiantui(MyUtils.getDate2String(qt.getSignIn()));
		}
		if(course!=null) {			
			xy.setShangke(course.getName());
			xy.setShangkeLaoShi(course.getTeaName());
		}
		if(foot!=null) {			
			xy.setWan(foot.getDinner());
			xy.setWu(foot.getLunch());
			xy.setZao(foot.getBreakfast());
		}
		
		
		return JSON.toJSONString(xy);
	}
	
	@RequestMapping(value = "/wd")
	public Object wd(String userId) {
		User u = null;
		
		if(userId==null || userId.equals("null")) {
			return JSON.toJSONString(u);
		}
		u =  jiaZhangService.getJiaZhang(userId);
		return JSON.toJSONString(u);
	}
	
	@RequestMapping(value = "/upwd")
	public Object upwd(User user) {
		user.setUserBirthday(MyUtils.getStringDate(user.getCsrq()));
		String result =  jiaZhangService.upWd(user);
		if(result.equals("1")) {
			return "SUCC";
		}else {
			return "ERR";
		}
	}
	
	@RequestMapping(value = "/sub")
	public Object sub(String userId) {
		//获取孩子信息
		List childres = jiaZhangService.getChildren(userId);
		
		if(userId==null || userId.equals("null")) {
			return JSON.toJSONString(new Children());
		}
		
		if(childres.size()>0) {
			return JSON.toJSONString(childres.get(0));
		}
		return new Children();
	}
	
	@RequestMapping(value = "/upsub")
	public Object upsub(Children child) {
		child.setBirthday(MyUtils.getStringDate(child.getCsrq()));
		String result =  jiaZhangService.upChild(child);
		if(result.equals("1")) {
			return "SUCC";
		}else {
			return "ERR";
		}
	}
	
	@RequestMapping(value = "/sigin")
	public Object sigin(String uid, String type) {
		if(uid==null && type==null) {
			return "ERR";
		}
		if(type.equals("1")) {
			//签到
			Sign sign = new Sign();
			sign.setKqrId(uid);
			Date date=new Date();
			SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss a");
			
			String time = formatter.format(date).split(" ")[2];
			String time1 = formatter.format(date).split(" ")[1];
			String s=PropertyUtil.getConfigureProperties("startTime");
			
			if(time.equals("上午") && time1.compareTo(s)>0) {
				sign.setState(1);
			}else {
				sign.setState(3);
			}
			sign.setType(Integer.parseInt(type));
			sign.setKqrType(2);
			sign.setSignIn(new Date());
			signService.addSign(sign);
		}else {
			//签退
			Sign sign = new Sign();
			sign.setKqrId(uid);
			Date date=new Date();
			SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss a");
			String time = formatter.format(date).split(" ")[2];
			String time1 = formatter.format(date).split(" ")[1];
			
			String s=PropertyUtil.getConfigureProperties("endTime");
			
			if(time.equals("下午") && time1.compareTo(s)<0) {
				sign.setState(1);
			}else{
				sign.setState(2);
			}
			sign.setType(Integer.parseInt(type));
			sign.setKqrType(2);
			sign.setSignIn(new Date());
			signService.addSign(sign);
		}
		return "OK";
	}
}


/*
 * All rights Reserved, Copyright (C) Aisino LIMITED 2018
 * FileName: WebConfig.java
 * Version:  $Revision$
 * Modify record:
 * NO. |     Date       |    Name         |      Content
 * 1   | 2019年1月16日        | Aisino)Jack    | original version
 */
package com.bskms.controller;
 
import java.util.ArrayList;
import java.util.List;
 
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.subject.Subject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
 
import com.bskms.bean.User;
import com.bskms.bean.UserRole;
import com.bskms.model.Result;
import com.bskms.model.ResultMap;
import com.bskms.service.UserRoleService;
import com.bskms.service.UserService;
import com.bskms.utils.MyUtils;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
 
/**
 * class name:UserController 
 * class description: 用户角色 
 * Remark: 
 * 
 * @version 1.00 2019年1月16日
 * @author Aisino)weihaohao
 */
@SuppressWarnings({ "unchecked", "rawtypes" })
@Controller
@RequestMapping("/user")
public class UserController {
 
	private final Logger logger = LoggerFactory.getLogger(UserController.class);
 
	private final ResultMap resultMap;
	@Autowired
	private UserService userService;
 
	@Autowired
	private UserRoleService userRoleService;
 
	@Autowired
	public UserController(ResultMap resultMap) {
		this.resultMap = resultMap;
	}
 
	@RequestMapping(value = "/getMessage", method = RequestMethod.GET)
	public ResultMap getMessage() {
		return resultMap.success().message("您拥有用户权限，可以获得该接口的信息！");
	}
 
	@RequestMapping(value = "/editUserPage")
	public String editUserPage(String userId, Model model) {
		model.addAttribute("manageUser", userId);
		if (null != userId) {
			User user = userService.selectByPrimaryKey(userId);
			model.addAttribute("manageUser", user);
		}
		return "user/userEdit";
	}
 
	@ResponseBody
	@RequestMapping("/updateUser")
	public String updateUser(User user) {
		return userService.updateUser(user);
	}
 
	// 任务
 
	/**
	 * Description: 查询所有管理员 
	 * 
	 * @return List
	 */
	@ResponseBody
	@RequestMapping(value = "/getAdmins")
	public List getAdmins() {
		return userService.getAdmins();
	}
 
	/**
	 * Description: 查询所有授权用户
	 * 
	 * @return List
	 */
	@ResponseBody
	@RequestMapping(value = "/getAllUser")
	public List getAllUser() {
		return userService.getAllUser();
	}
}

配置文件说明：


server.port=8081
debug=true 
##打开sql执行语句打印日志
logging.level.com.bskms.mapper=debug
 
###############################MySQL数据库配置###############################
#spring.datasource.name=test
#spring.datasource.url=jdbc:mysql://127.0.0.1:3306/bskms?characterEncoding=UTF-8&serverTimezone=GMT%2b8&useSSL=false
#spring.datasource.username=root
#spring.datasource.password=Jack2018
 
#本地数据库
spring.datasource.url=jdbc:mysql://localhost:3306/sajt_arrms?characterEncoding=UTF-8&serverTimezone=GMT%2b8&useSSL=false
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
 
###########################Mapper配置###############################
logging.level.org.springframework.web=DEBUG
 
#Mybatis配置
mybatis.type-aliases-package=com.bskms
mybatis.mapper-locations=classpath:mapper/*.xml 
###########################Mybatis配置###############################
 
spring.datasource.druid.initial-size=10 
spring.datasource.druid.min-idle=10
spring.datasource.druid.max-active=200
spring.datasource.druid.max-wait=60000  
spring.datasource.druid.time-between-eviction-runs-millis=60000  
spring.datasource.druid.min-evictable-idle-time-millis=300000  
spring.datasource.druid.validation-query=SELECT 1 FROM DUAL  
spring.datasource.druid.test-while-idle=true  
spring.datasource.druid.test-on-borrow=false  
spring.datasource.druid.test-on-return=false  
spring.datasource.druid.pool-prepared-statements=true  
spring.datasource.druid.max-pool-prepared-statement-per-connection-size=20  
spring.datasource.druid.filters=stat,wall,log4j  
 
###########################Redis配置###############################
# REDIS (RedisProperties)
# Redis数据库索引（默认为0）
spring.redis.database=0  
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379  
# Redis服务器连接密码（默认为空）
spring.redis.password=123456
 
# 连接超时时间（毫秒）
spring.redis.timeout=10000


/**
 *
 */
package com.bskms.controller;
 
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
 
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.subject.Subject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
 
import com.bskms.bean.Children;
import com.bskms.bean.ClaTea;
import com.bskms.bean.Classes;
import com.bskms.bean.Course;
import com.bskms.bean.Notice;
import com.bskms.bean.Sign;
import com.bskms.bean.User;
import com.bskms.bean.UserChildren;
import com.bskms.model.TongJi;
import com.bskms.service.ClassService;
import com.bskms.service.CourseService;
import com.bskms.service.NoticeService;
import com.bskms.service.SignService;
import com.bskms.service.StudentService;
import com.bskms.service.UserChildrenService;
import com.bskms.service.UserService;
import com.bskms.utils.PropertyUtil;
 
/**
 * @author samsung
 *
 */
@Controller
@RequestMapping(value = "/ls")
public class TeacherController {
 
	@Autowired
	private StudentService studentService;
	@Autowired
	private ClassService classService;
	@Autowired
	private NoticeService noticeService;
	@Autowired
	private SignService signService;
	@Autowired
	private UserService userService;
	@Autowired
	private UserChildrenService userChildrenService;
	@Autowired
	private CourseService courseService;
 
	@RequestMapping("/stu")
	public String stu(Model model) {
		List classes=classService.selectAllClasses();
		model.addAttribute("cla", classes);
		return "ls/stuPage";
	}
	//学生管理
 
		/**
		 * Method name: teacherPage 
		 * Description: 教师管理页面 
		 *
		 * @return String
		 */
		@RequestMapping(value = "/stuMG")
		public String teaMG(Model model) {
			List classes=classService.selectAllClasses();
			model.addAttribute("cla", classes);
			return "ls/student";
		}
 
		/**
		 * Method name: getAllStudentByLimit 
		 * Description: 根据条件获取所有教师 
		 *
		 * @param userParameter
		 * @return Object
		 */
		@RequestMapping("/getAllStudentByLimit")
		@ResponseBody
		public Object getAllStudentByLimit(Children stuParameter) {
			return studentService.getAllStudentByLimit(stuParameter);
		}
 
		/**
		 * Method name: addStuPage 
		 * Description: 增加教师界面 
		 *
		 * @return String
		 */
		@RequestMapping(value = "/addStuPage")
		public String addStuPage(Integer id, Model model) {
			model.addAttribute("manageStu", id);
			if (null != id) {
				Children student = studentService.selectByPrimaryKey(id);
				//UserChildren userChild = userChildrenService.selectById(id);
				model.addAttribute("manageStu", student);
				//model.addAttribute("manageChild", userChild);
				UserChildren uc = userChildrenService.selectByUCId(student.getId());
				model.addAttribute("uc", uc);
			}
			List classes=classService.selectAllClasses();
			model.addAttribute("cla", classes);
 
			List user=userService.selectAllJiazhang();
			model.addAttribute("user", user);
			return "ls/stuPageAdd";
		}
 
		/**
		 * Method name: addStu 
		 * Description: 教师添加 
		 *
		 * @param user
		 * @return String
		 */
		@ResponseBody
		@RequestMapping("/addStu")
		public String addStu(Children student) {
			try {
 
				studentService.addStudent(student);
				addUserChildren(student);
				return "SUCCESS";
			} catch (Exception e) {
				return "ERR";
			}
		}
        public void addUserChildren(Children student) {
        	UserChildren userChildern = new UserChildren();
        	userChildern.setChildrenId(student.getId());
        	userChildern.setUserId(student.getUserId());
        	userChildern.setIsFaMa(student.getIsFaMa());
        	userChildern.setIsJinji(student.getIsJinji());
        	userChildrenService.addUserChildren(userChildern);
 
        }
		/**
		 * Method name: updateStudent 
		 * Description: 更新教师 
		 *
		 * @param user
		 * @return String
		 */
		@ResponseBody
		@RequestMapping("/updateStudent")
		public String updateStudent(Children studnet) {
			UserChildren uc = new UserChildren();
			uc.setId(studnet.getUcId());
			uc.setChildrenId(studnet.getId());
			uc.setIsFaMa(studnet.getIsFaMa());
			uc.setIsJinji(studnet.getIsJinji());
			uc.setUserId(studnet.getUserId());
			userChildrenService.updateUC(uc);
			return studentService.updateStu(studnet);
		}
 
		/**
		 * Method name: delClaTea 
		 * Description: 批量删除教师
		 *
		 * @param ids
		 * @return String
		 */
		@RequestMapping(value = "delStudent")
		@ResponseBody
		@Transactional
		public String delStudent(String[] ids) {
			try {
				for (String id : ids) {
					studentService.delStudentById(Integer.parseInt(id));
				}
				return "SUCCESS";
			} catch (Exception e) {
 
				TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
				return "ERROR";
			}
		}
 
		//公告管理
 
			/**
			 * Method name: gg 
			 * Description: 教师管理页面 
			 *
			 * @return String
			 */
			@RequestMapping(value = "/gg")
			public String gg() {
				return "ls/notice";
			}
 
			/**
			 * Method name: getAllNoticeByLimit 
			 * Description: 根据条件获取所有教师 
			 *
			 * @param userParameter
			 * @return Object
			 */
			@RequestMapping("/getAllNoticeByLimit")
			@ResponseBody
			public Object getAllNoticeByLimit(Notice noticeParameter) {
				return noticeService.getAllNoticeByLimit(noticeParameter);
			}
 
			/**
			 * Method name: addStuPage 
			 * Description: 增加教师界面 
			 *
			 * @return String
			 */
			@RequestMapping(value = "/addNoticePage")
			public String addNoticePage(Integer id, Model model) {
				model.addAttribute("manageNotice", id);
				if (null != id) {
					Notice notice = noticeService.selectByPrimaryKey(id);
					model.addAttribute("manageNotice", notice);
				}
 
				return "ls/noticeAdd";
			}
 
			/**
			 * Method name: addStu 
			 * Description: 教师添加 
			 *
			 * @param user
			 * @return String
			 */
			@ResponseBody
			@RequestMapping("/addNotice")
			public String addNotice(Notice notice) {
				try {
					notice.setCreatTime(new Date());
					noticeService.addNotice(notice);
					return "SUCCESS";
				} catch (Exception e) {
					return "ERR";
				}
			}
 
			/**
			 * Method name: updateStudent 
			 * Description: 更新教师 
			 *
			 * @param user
			 * @return String
			 */
			@ResponseBody
			@RequestMapping("/updateNotice")
			public String updateNotice(Notice notice) {
				return noticeService.updateStu(notice);
			}
 
			/**
			 * Method name: delClaTea 
			 * Description: 批量删除教师
			 *
			 * @param ids
			 * @return String
			 */
			@RequestMapping(value = "delNotice")
			@ResponseBody
			@Transactional
			public String delNotice(String[] ids) {
				try {
					for (String id : ids) {
						noticeService.delNoticeById(Integer.parseInt(id));
					}
					return "SUCCESS";
				} catch (Exception e) {
 
					TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
					return "ERROR";
				}
			}
 
			//考勤管理
 
			/**
			 * Method name: lskq 
			 * Description: 教师管理页面 
			 *
			 * @return String
			 */
			@RequestMapping(value = "/lskq")
			public String lskq() {
				return "ls/sign";
			}
 
			/**
			 * Method name: getAllSignByLimit 
			 * Description: 根据条件获取所有教师 
			 *
			 * @param userParameter
			 * @return Object
			 */
			@RequestMapping("/getAllSignByLimit")
			@ResponseBody
			public Object getAllSignByLimit(Sign signParameter) {
				return signService.getAllSignByLimit(signParameter);
			}
 
 
			//打卡
			@RequestMapping(value = "/qianDaoTui")
			public String qianDaoTui() {
				return "ls/daKa";
			}
			/**
			 * Method name: addStu 
			 * Description: 教师添加 
			 *
			 * @param user
			 * @return String
			 */
			@ResponseBody
			@RequestMapping("/addSign")
			public String addSign(Sign sign) {
			    Subject subject = SecurityUtils.getSubject();
				User user = (User) subject.getPrincipal();
				try {
					Date date=new Date();
					SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss a");
 
					String time = formatter.format(date).split(" ")[2];
					String time1 = formatter.format(date).split(" ")[1];
					String s=PropertyUtil.getConfigureProperties("startTime");
 
					if(time.equals("上午") && time1.compareTo(s)>0) {
						sign.setState(1);
					}else {
						sign.setState(3);
					}
					//如果是家长：则查出其孩子编号作为签到人
					if(user.getUserState()==2){
						UserChildren userChildren = userChildrenService.selectByUserId(user.getUserId());
						sign.setKqrId(userChildren.getId().toString());
					}else{
						sign.setKqrId(user.getUserId());
					}
					sign.setType(1);
					sign.setSignIn(date);
					sign.setKqrType(user.getUserState());
					signService.addSign(sign);
					return "SUCCESS";
				} catch (Exception e) {
					return "ERR";
				}
			}
 
			/**
			 * Method name: addStu 
			 * Description: 教师添加 
			 *
			 * @param user
			 * @return String
			 */
			@ResponseBody
			@RequestMapping("/addQianTui")
			public String addQianTui(Sign sign) {
			    Subject subject = SecurityUtils.getSubject();
				User user = (User) subject.getPrincipal();
				try {
					Date date=new Date();
					SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss a");
					String time = formatter.format(date).split(" ")[2];
					String time1 = formatter.format(date).split(" ")[1];
 
					String s=PropertyUtil.getConfigureProperties("endTime");
 
					if(time.equals("下午") && time1.compareTo(s)<0) {
						sign.setState(1);
					}else{
						sign.setState(2);
					}
					sign.setType(2);
					sign.setSignIn(date);
					sign.setKqrId(user.getUserId());
					sign.setKqrType(user.getUserState());
					signService.addSign(sign);
					return "SUCCESS";
				} catch (Exception e) {
					return "ERR";
				}
			}
           //学生考勤
			@RequestMapping(value = "/xskq")
			public String xskq() {
				return "ls/childSign";
			}
 
			/**
			 * Method name: getAllSignByLimit 
			 * Description: 根据条件获取所有教师 
			 * @param userParameter
			 * @return Object
			 */
			@RequestMapping("/getAllChildSignByLimit")
			@ResponseBody
			public Object getAllChildSignByLimit(Sign signParameter) {
				return signService.getAllChildSignByLimit(signParameter);
			}
 
			//所有老师签到的总次数统计
			@RequestMapping(value = "/kqtj")
			public String kqtj(Model model) {
				List ts = signService.getAllTeacherCount();
				List names = new ArrayList<>();
				List zc =  new ArrayList<>();
				List tq =  new ArrayList<>();
				List cd =  new ArrayList<>();
 
				for (TongJi tongJi : ts) {
					names.add(tongJi.getUserName());
					zc.add(tongJi.getZhengChang());
					tq.add(tongJi.getTiQian());
					cd.add(tongJi.getChiDao());
				}
 
				model.addAttribute("names", names);
				model.addAttribute("zc", zc);
				model.addAttribute("tq", tq);
				model.addAttribute("cd", cd);
 
				return "ls/tongJi";
			}
 
			//所有学生签到的总次数统计
			@RequestMapping(value = "/tongJiXueSheng")
			public String tongJiXueSheng(Model model) {
				List ts = signService.getAllChildCount();
				List names = new ArrayList<>();
				List zc =  new ArrayList<>();
				List tq =  new ArrayList<>();
				List cd =  new ArrayList<>();
 
				for (TongJi tongJi : ts) {
					names.add(tongJi.getUserName());
					zc.add(tongJi.getZhengChang());
					tq.add(tongJi.getTiQian());
					cd.add(tongJi.getChiDao());
				}
 
				model.addAttribute("names", names);
				model.addAttribute("zc", zc);
				model.addAttribute("tq", tq);
				model.addAttribute("cd", cd);
 
				return "ls/tongJiXueSheng";
			}
 
			@RequestMapping(value = "/course")
			public String course(Model model) {
				return "ls/course";
			}
 
			//课程
			@RequestMapping(value = "/courseAdd")
			public String courseAdd(Model model) {
				List users = userService.selectAllTea();
				model.addAttribute("users", users);
 
				List clas = classService.selectAllClasses();
				model.addAttribute("cla", clas);
				return "ls/courseAdd";
			}
 
			@RequestMapping("/getAllCourseByLimit")
			@ResponseBody
			public Object getAllCourseByLimit(Course course) {
				return courseService.getAllCourseByLimit(course);
			}
			@ResponseBody
			@RequestMapping("/addCourse")
			public String addCourse(Course course) {
				course.setCreateTime(new Date());
			    try {
			    	courseService.addCourse(course);
			    	return "SUCCESS";
				} catch (Exception e) {
					return "ERR";
				}
			}
 
			@ResponseBody
			@RequestMapping("/delCourse")
			public String delCourse(Integer id) {
			    try {
			    	courseService.delCourse(id);
			    	return "SUCCESS";
				} catch (Exception e) {
					return "ERR";
				}
			}
}

五，项目总结

对于复杂的信息管理，计算机能够充分发挥它的优越性。计算机进行信息管理与信息管理系统的开发密切相关，系统的开发是系统管理的前提。本系统就是为了管理好幼儿园信息而设计的，能使用于不同的中小型幼儿园，能方便、科学的实现对园中事物的管理。

幼儿园的任务为解除家庭在培养儿童时所受时间、空间、环境的制约，让幼儿身体、智力和心情得以健康发展。可以说幼儿园是小朋友的快乐天地，可以帮助孩子健康快乐地度过童年时光，不仅学到知识，而且可以从小接触集体生活。幼儿园教育作为整个教育体系基础的基础，是对儿童进行预备教育(性格完整健康、行为习惯良好、初步的自然与社会常识)。早期人工管理的幼儿园出现了不少缺点，比如管理中，办公的效率不高；园中的管理人员在管理园中事物时容易按照经验，缺少了数据统计，故管理不科学。越来越多的幼儿数量的增多，加重了管理员对幼儿档案的管理难度；使管理变得比较烦琐、复杂，产生的文档比较多，并且由于手工的操作，使这些文档无法有效的核对和管理，在汇总以及分析方面更加困难。现在大多数幼儿园都装配有计算机，但是尚未用于信息管理，没有发挥它的效力，资源闲置比较突出，配备的计算机属于闲散资源，这就是管理信息系统开发的基本环境。

基于这些问题，我们认为有必要建立一套幼儿园管理系统，使幼儿园的管理工作规范化、系统化、程序化，避免幼儿园管理的随意性、烦琐性，提高信息处理的速度和准确性，能够及时、准确、有效的查询和修改幼儿与教师的情况。

相关阅读:
排序算法两万字总结(C语言实现)
Python是信奥的基础吗，学习信奥要不要先学python
【构建ML驱动的应用程序】第 8 章：部署模型时的注意事项
 室外定位：高精度北斗RTK定位技术
 阿里云一面：并发场景下的底层细节 - 伪共享问题
 安卓打开第三方应用失败
 前端的简单介绍
 4. 【containerd】pull image 如何配置密码
 HoloLens 2上使用Azure空间定位点
 【字符串处理函数】sprintf与snprintf
原文地址：https://blog.csdn.net/BS009/article/details/126765939