• SpringBoot+Vue项目疫苗预约管理系统

    文末获取源码

    开发语言：Java

    框架：springboot

    JDK版本：JDK1.8

    服务器：tomcat7

    数据库：mysql 5.7/8.0

    数据库工具：Navicat11

    开发软件：eclipse/myeclipse/idea

    Maven包：Maven3.3.9

    浏览器：谷歌浏览器

    前言介绍 

    本系统主要包括管理员和用户两个角色组成，主要包括以下功能：

    （1）前台：首页、疫苗信息、健康科普、疫苗资讯、个人中心、后台管理、咨询服务 。

    （2）管理员：首页、个人中心、用户管理、疫苗信息管理、疫苗种类管理、接种预约管理、提醒信息管理、健康科普管理、接种记录管理、系统管理等。

    （3）用户：首页、个人中心、接种预约管理、提醒信息管理、接种记录管理等功能。

    系统整体功能 

    系统功能模块

    疫苗预约管理系统系统，在系统首页可以查看首页，疫苗信息，健康科普，疫苗资讯，个人中心，后台管理，咨询服务等内容，并进行详细操作；如图

    用户注册

    在用户注册页面通过填写用户名，密码，确认密码 ，姓名，手机，身份证等信息进行注册操作，如图

    疫苗信息

    在疫苗信息页面可以查看疫苗名称，疫苗编号，疫苗种类，适合人群，年龄段，价格，数量，接种次数，厂家，接种地点，预约等内容，并进行添加到接种预约，收藏等操作，如图

    健康科普

    个人中心

    在个人中心页面通过填写用户名，密码，姓名，性别，手机，身份证等信息进行更新信息，还可以根据需要对我的收藏进行相对应操作，如图

    管理员功能模块 

    管理员进行登录，进入系统前在登录页面根据要求填写用户名和密码，选择角色等信息，点击登录进行登录操作，如图

    管理员登录系统后，可以对首页，个人中心，用户管理，疫苗信息管理，疫苗种类管理，接种预约管理，提醒信息管理，健康科普管理，接种记录管理，系统管理等功能进行相应的操作管理，如图

    用户管理

    在用户管理页面可以对用户名，姓名，性别，头像，手机，身份证等内容进行查看，修改和删除等操作，如图 

    疫苗信息管理

    在疫苗信息管理页面可以索引，疫苗编号，疫苗名称，疫苗种类，图片，适合人群，年龄段，价格，数量，接种次数，厂家等内容进行查看、修改、删除等操作，如图 

    疫苗种类管理

    在疫苗种类管理页面可以对疫苗种类进行新增，修改和删除等操作，如图 

    接种预约管理

    在接种预约管理页面可以索引，疫苗编号，疫苗名称，疫苗种类，预约类型，人数，预约时间，用户名，姓名，身份证，手机，审核回复，审核状态等内容进行审核，详细，提醒，接种，修改和删除等操作，如图 

    提醒信息管理

    在提醒信息管理页面可以对索引，标题，用户名，姓名，通知时间等内容进行查看，修改和删除等操作；如图 

    健康科普管理

    在健康科普管理页面可以对索引，标题，图片，视频讲解 ，发布时间等内容进行查看，修改，删除等操作；如图 

    接种记录管理

    在接种记录管理页面可以对疫苗编号，疫苗名称，用户名 ，姓名，接种时间，完成次数，剩余次数，是否不适，时间间隔等内容进行查看、修改，删除等操作，如图 

    系统管理

    在疫苗资讯页面可以对标题，简介，图片等内容进行查看、修改，删除等操作，如图 

    用户功能模块 

    用户登录进入疫苗预约管理系统系统可以对首页，个人中心，接种预约管理，提醒信息管理，接种记录管理等功能进行相应操作，如图

    个人中心

    在个人中心页面通过填写用户名，姓名，性别，头像，手机，身份证等内容进行个人信息修改操作，如图 

    接种预约管理

    在接种预约管理页面可以对疫苗编号,疫苗名称,疫苗种类,预约类型,人数,预约时间,用户名,姓名,身份证, 手机,审核回复，审核状态等内容进行查看，删除等操作，如图 

    部分核心代码 

    1. /**
    2.  * 接种预约
    3.  * 后端接口
    4.  * @author 
    5.  * @email 
    6.  * @date 2022-02-24 11:13:03
    7.  */
    8. @RestController
    9. @RequestMapping("/jiezhongyuyue")
    10. public class JiezhongyuyueController {
    11.     @Autowired
    12.     private JiezhongyuyueService jiezhongyuyueService;
    13.  
    14.  
    15.     
    16.  
    17.  
    18.     /**
    19.      * 后端列表
    20.      */
    21.     @RequestMapping("/page")
    22.     public R page(@RequestParam Map<String, Object> params,JiezhongyuyueEntity jiezhongyuyue,
    23. 		HttpServletRequest request){
    24. 		String tableName = request.getSession().getAttribute("tableName").toString();
    25. 		if(tableName.equals("yonghu")) {
    26. 			jiezhongyuyue.setYonghuming((String)request.getSession().getAttribute("username"));
    27. 		}
    28.         EntityWrapper<JiezhongyuyueEntity> ew = new EntityWrapper<JiezhongyuyueEntity>();
    29. 		PageUtils page = jiezhongyuyueService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, jiezhongyuyue), params), params));
    30.  
    31.         return R.ok().put("data", page);
    32.     }
    33.     
    34.     /**
    35.      * 前端列表
    36.      */
    37. 	@IgnoreAuth
    38.     @RequestMapping("/list")
    39.     public R list(@RequestParam Map<String, Object> params,JiezhongyuyueEntity jiezhongyuyue, 
    40. 		HttpServletRequest request){
    41.         EntityWrapper<JiezhongyuyueEntity> ew = new EntityWrapper<JiezhongyuyueEntity>();
    42. 		PageUtils page = jiezhongyuyueService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, jiezhongyuyue), params), params));
    43.         return R.ok().put("data", page);
    44.     }
    45.  
    46. 	/**
    47.      * 列表
    48.      */
    49.     @RequestMapping("/lists")
    50.     public R list( JiezhongyuyueEntity jiezhongyuyue){
    51.        	EntityWrapper<JiezhongyuyueEntity> ew = new EntityWrapper<JiezhongyuyueEntity>();
    52.       	ew.allEq(MPUtil.allEQMapPre( jiezhongyuyue, "jiezhongyuyue")); 
    53.         return R.ok().put("data", jiezhongyuyueService.selectListView(ew));
    54.     }
    55.  
    56. 	 /**
    57.      * 查询
    58.      */
    59.     @RequestMapping("/query")
    60.     public R query(JiezhongyuyueEntity jiezhongyuyue){
    61.         EntityWrapper< JiezhongyuyueEntity> ew = new EntityWrapper< JiezhongyuyueEntity>();
    62.  		ew.allEq(MPUtil.allEQMapPre( jiezhongyuyue, "jiezhongyuyue")); 
    63. 		JiezhongyuyueView jiezhongyuyueView =  jiezhongyuyueService.selectView(ew);
    64. 		return R.ok("查询接种预约成功").put("data", jiezhongyuyueView);
    65.     }
    66. 	
    67.     /**
    68.      * 后端详情
    69.      */
    70.     @RequestMapping("/info/{id}")
    71.     public R info(@PathVariable("id") Long id){
    72.         JiezhongyuyueEntity jiezhongyuyue = jiezhongyuyueService.selectById(id);
    73.         return R.ok().put("data", jiezhongyuyue);
    74.     }
    75.  
    76.     /**
    77.      * 前端详情
    78.      */
    79. 	@IgnoreAuth
    80.     @RequestMapping("/detail/{id}")
    81.     public R detail(@PathVariable("id") Long id){
    82.         JiezhongyuyueEntity jiezhongyuyue = jiezhongyuyueService.selectById(id);
    83.         return R.ok().put("data", jiezhongyuyue);
    84.     }
    85.     
    86.  
    87.  
    88.  
    89.     /**
    90.      * 后端保存
    91.      */
    92.     @RequestMapping("/save")
    93.     public R save(@RequestBody JiezhongyuyueEntity jiezhongyuyue, HttpServletRequest request){
    94.     	jiezhongyuyue.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
    95.     	//ValidatorUtils.validateEntity(jiezhongyuyue);
    96.         jiezhongyuyueService.insert(jiezhongyuyue);
    97.         return R.ok();
    98.     }
    99.     
    100.     /**
    101.      * 前端保存
    102.      */
    103.     @RequestMapping("/add")
    104.     public R add(@RequestBody JiezhongyuyueEntity jiezhongyuyue, HttpServletRequest request){
    105.     	jiezhongyuyue.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
    106.     	//ValidatorUtils.validateEntity(jiezhongyuyue);
    107.         jiezhongyuyueService.insert(jiezhongyuyue);
    108.         return R.ok();
    109.     }
    110.  
    111.     /**
    112.      * 修改
    113.      */
    114.     @RequestMapping("/update")
    115.     public R update(@RequestBody JiezhongyuyueEntity jiezhongyuyue, HttpServletRequest request){
    116.         //ValidatorUtils.validateEntity(jiezhongyuyue);
    117.         jiezhongyuyueService.updateById(jiezhongyuyue);//全部更新
    118.         return R.ok();
    119.     }
    120.     
    121.  
    122.     /**
    123.      * 删除
    124.      */
    125.     @RequestMapping("/delete")
    126.     public R delete(@RequestBody Long[] ids){
    127.         jiezhongyuyueService.deleteBatchIds(Arrays.asList(ids));
    128.         return R.ok();
    129.     }
    130.     
    131.     /**
    132.      * 提醒接口
    133.      */
    134. 	@RequestMapping("/remind/{columnName}/{type}")
    135. 	public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, 
    136. 						 @PathVariable("type") String type,@RequestParam Map<String, Object> map) {
    137. 		map.put("column", columnName);
    138. 		map.put("type", type);
    139. 		
    140. 		if(type.equals("2")) {
    141. 			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    142. 			Calendar c = Calendar.getInstance();
    143. 			Date remindStartDate = null;
    144. 			Date remindEndDate = null;
    145. 			if(map.get("remindstart")!=null) {
    146. 				Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
    147. 				c.setTime(new Date()); 
    148. 				c.add(Calendar.DAY_OF_MONTH,remindStart);
    149. 				remindStartDate = c.getTime();
    150. 				map.put("remindstart", sdf.format(remindStartDate));
    151. 			}
    152. 			if(map.get("remindend")!=null) {
    153. 				Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
    154. 				c.setTime(new Date());
    155. 				c.add(Calendar.DAY_OF_MONTH,remindEnd);
    156. 				remindEndDate = c.getTime();
    157. 				map.put("remindend", sdf.format(remindEndDate));
    158. 			}
    159. 		}
    160. 		
    161. 		Wrapper<JiezhongyuyueEntity> wrapper = new EntityWrapper<JiezhongyuyueEntity>();
    162. 		if(map.get("remindstart")!=null) {
    163. 			wrapper.ge(columnName, map.get("remindstart"));
    164. 		}
    165. 		if(map.get("remindend")!=null) {
    166. 			wrapper.le(columnName, map.get("remindend"));
    167. 		}
    168.  
    169. 		String tableName = request.getSession().getAttribute("tableName").toString();
    170. 		if(tableName.equals("yonghu")) {
    171. 			wrapper.eq("yonghuming", (String)request.getSession().getAttribute("username"));
    172. 		}
    173.  
    174. 		int count = jiezhongyuyueService.selectCount(wrapper);
    175. 		return R.ok().put("count", count);
    176. 	}
    177. 	
    178.  
    179.  
    180.  
    181.  
    182.  
    183.  
    184.     /**
    185.      * （按值统计）
    186.      */
    187.     @RequestMapping("/value/{xColumnName}/{yColumnName}")
    188.     public R value(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName,HttpServletRequest request) {
    189.         Map<String, Object> params = new HashMap<String, Object>();
    190.         params.put("xColumn", xColumnName);
    191.         params.put("yColumn", yColumnName);
    192.         EntityWrapper<JiezhongyuyueEntity> ew = new EntityWrapper<JiezhongyuyueEntity>();
    193. 		String tableName = request.getSession().getAttribute("tableName").toString();
    194. 		if(tableName.equals("yonghu")) {
    195.             ew.eq("yonghuming", (String)request.getSession().getAttribute("username"));
    196. 		}
    197.         List<Map<String, Object>> result = jiezhongyuyueService.selectValue(params, ew);
    198.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    199.         for(Map<String, Object> m : result) {
    200.             for(String k : m.keySet()) {
    201.                 if(m.get(k) instanceof Date) {
    202.                     m.put(k, sdf.format((Date)m.get(k)));
    203.                 }
    204.             }
    205.         }
    206.         return R.ok().put("data", result);
    207.     }
    208.  
    209.     /**
    210.      * （按值统计）时间统计类型
    211.      */
    212.     @RequestMapping("/value/{xColumnName}/{yColumnName}/{timeStatType}")
    213.     public R valueDay(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType,HttpServletRequest request) {
    214.         Map<String, Object> params = new HashMap<String, Object>();
    215.         params.put("xColumn", xColumnName);
    216.         params.put("yColumn", yColumnName);
    217.         params.put("timeStatType", timeStatType);
    218.         EntityWrapper<JiezhongyuyueEntity> ew = new EntityWrapper<JiezhongyuyueEntity>();
    219.         String tableName = request.getSession().getAttribute("tableName").toString();
    220.         if(tableName.equals("yonghu")) {
    221.             ew.eq("yonghuming", (String)request.getSession().getAttribute("username"));
    222.         }
    223.         List<Map<String, Object>> result = jiezhongyuyueService.selectTimeStatValue(params, ew);
    224.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    225.         for(Map<String, Object> m : result) {
    226.             for(String k : m.keySet()) {
    227.                 if(m.get(k) instanceof Date) {
    228.                     m.put(k, sdf.format((Date)m.get(k)));
    229.                 }
    230.             }
    231.         }
    232.         return R.ok().put("data", result);
    233.     }
    234.  
    235.     /**
    236.      * 分组统计
    237.      */
    238.     @RequestMapping("/group/{columnName}")
    239.     public R group(@PathVariable("columnName") String columnName,HttpServletRequest request) {
    240.         Map<String, Object> params = new HashMap<String, Object>();
    241.         params.put("column", columnName);
    242.         EntityWrapper<JiezhongyuyueEntity> ew = new EntityWrapper<JiezhongyuyueEntity>();
    243.         String tableName = request.getSession().getAttribute("tableName").toString();
    244.         if(tableName.equals("yonghu")) {
    245.             ew.eq("yonghuming", (String)request.getSession().getAttribute("username"));
    246.         }
    247.         List<Map<String, Object>> result = jiezhongyuyueService.selectGroup(params, ew);
    248.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    249.         for(Map<String, Object> m : result) {
    250.             for(String k : m.keySet()) {
    251.                 if(m.get(k) instanceof Date) {
    252.                     m.put(k, sdf.format((Date)m.get(k)));
    253.                 }
    254.             }
    255.         }
    256.         return R.ok().put("data", result);
    257.     }
    258.  
    259. }
    1. **
    2.  * 登录相关
    3.  */
    4. @RequestMapping("users")
    5. @RestController
    6. public class UserController{
    7. 	
    8. 	@Autowired
    9. 	private UserService userService;
    10. 	
    11. 	@Autowired
    12. 	private TokenService tokenService;
    13.  
    14. 	/**
    15. 	 * 登录
    16. 	 */
    17. 	@IgnoreAuth
    18. 	@PostMapping(value = "/login")
    19. 	public R login(String username, String password, String captcha, HttpServletRequest request) {
    20. 		UserEntity user = userService.selectOne(new EntityWrapper().eq("username", username));
    21. 		if(user==null || !user.getPassword().equals(password)) {
    22. 			return R.error("账号或密码不正确");
    23. 		}
    24. 		String token = tokenService.generateToken(user.getId(),username, "users", user.getRole());
    25. 		return R.ok().put("token", token);
    26. 	}
    27. 	
    28. 	/**
    29. 	 * 注册
    30. 	 */
    31. 	@IgnoreAuth
    32. 	@PostMapping(value = "/register")
    33. 	public R register(@RequestBody UserEntity user){
    34. //    	ValidatorUtils.validateEntity(user);
    35.     	if(userService.selectOne(new EntityWrapper().eq("username", user.getUsername())) !=null) {
    36.     		return R.error("用户已存在");
    37.     	}
    38.         userService.insert(user);
    39.         return R.ok();
    40.     }
    41.  
    42. 	/**
    43. 	 * 退出
    44. 	 */
    45. 	@GetMapping(value = "logout")
    46. 	public R logout(HttpServletRequest request) {
    47. 		request.getSession().invalidate();
    48. 		return R.ok("退出成功");
    49. 	}
    50. 	
    51. 	/**
    52.      * 密码重置
    53.      */
    54.     @IgnoreAuth
    55. 	@RequestMapping(value = "/resetPass")
    56.     public R resetPass(String username, HttpServletRequest request){
    57.     	UserEntity user = userService.selectOne(new EntityWrapper().eq("username", username));
    58.     	if(user==null) {
    59.     		return R.error("账号不存在");
    60.     	}
    61.     	user.setPassword("123456");
    62.         userService.update(user,null);
    63.         return R.ok("密码已重置为：123456");
    64.     }
    65. 	
    66. 	/**
    67.      * 列表
    68.      */
    69.     @RequestMapping("/page")
    70.     public R page(@RequestParam Map params,UserEntity user){
    71.         EntityWrapper ew = new EntityWrapper();
    72.     	PageUtils page = userService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allLike(ew, user), params), params));
    73.         return R.ok().put("data", page);
    74.     }
    75.  
    76. 	/**
    77.      * 列表
    78.      */
    79.     @RequestMapping("/list")
    80.     public R list( UserEntity user){
    81.        	EntityWrapper ew = new EntityWrapper();
    82.       	ew.allEq(MPUtil.allEQMapPre( user, "user")); 
    83.         return R.ok().put("data", userService.selectListView(ew));
    84.     }
    85.  
    86.     /**
    87.      * 信息
    88.      */
    89.     @RequestMapping("/info/{id}")
    90.     public R info(@PathVariable("id") String id){
    91.         UserEntity user = userService.selectById(id);
    92.         return R.ok().put("data", user);
    93.     }
    94.     
    95.     /**
    96.      * 获取用户的session用户信息
    97.      */
    98.     @RequestMapping("/session")
    99.     public R getCurrUser(HttpServletRequest request){
    100.     	Long id = (Long)request.getSession().getAttribute("userId");
    101.         UserEntity user = userService.selectById(id);
    102.         return R.ok().put("data", user);
    103.     }
    104.  
    105.     /**
    106.      * 保存
    107.      */
    108.     @PostMapping("/save")
    109.     public R save(@RequestBody UserEntity user){
    110. //    	ValidatorUtils.validateEntity(user);
    111.     	if(userService.selectOne(new EntityWrapper().eq("username", user.getUsername())) !=null) {
    112.     		return R.error("用户已存在");
    113.     	}
    114.         userService.insert(user);
    115.         return R.ok();
    116.     }
    117.  
    118.     /**
    119.      * 修改
    120.      */
    121.     @RequestMapping("/update")
    122.     public R update(@RequestBody UserEntity user){
    123. //        ValidatorUtils.validateEntity(user);
    124.     	UserEntity u = userService.selectOne(new EntityWrapper().eq("username", user.getUsername()));
    125.     	if(u!=null && u.getId()!=user.getId() && u.getUsername().equals(user.getUsername())) {
    126.     		return R.error("用户名已存在。");
    127.     	}
    128.         userService.updateById(user);//全部更新
    129.         return R.ok();
    130.     }
    131.  
    132.     /**
    133.      * 删除
    134.      */
    135.     @RequestMapping("/delete")
    136.     public R delete(@RequestBody Long[] ids){
    137.         userService.deleteBatchIds(Arrays.asList(ids));
    138.         return R.ok();
    139.     }
    140. }

  • 相关阅读:
    vue3.2 之 i18n的使用
    基于java的大学教室管理系统——计算机毕业设计
    Oracle/PLSQL: Corr Function
    透明度模糊Android实现
    青少年软件编程C++二级真题（202109）
    数据结构与算法之LeetCode-1413. 逐步求和得到正数的最小值（贪心与排序）
    几句话理解Kubetnetes中的Service资源的几种类型
    Java 9 的模块（Module）系统
    【STL】STL入门（9）
    4.Nginx优化，谁用谁说好
  • 原文地址：https://blog.csdn.net/m0_49113107/article/details/126084289