基于springboot宠物医院管理系统java源码

宠物医院管理系统是基于java编程语言，mysql管理器，springboot框架的设计，本系统主要分为用户，管理员，医生三个角色，其中用户的主要功能是注册和登陆系统，查看新闻资讯，预约宠物医生，购买药品，在线留言反馈，查看订单；宠物医生主要功能是登陆系统，对预约挂号管理，遗嘱管理；管理员则是对用户，医生，订单，科室，预约挂号，药品，订单，留言板等信息进行管理。本设计功能齐全，页面简洁，

jdk版本：1.8 及以上
ide工具：IDEA
数据库: mysql5.7 （必须5.7）
编程语言: Java
tomcat:   8.0 及以上
java框架：springboot
maven: 3.6.1
前端：layui
详细技术：HTML+CSS+JS+JSP+JAVA+springboot+MYSQL+JQUERY+MAVEN

基于springboot宠物医院管理系统

系统分为用户，医生，管理员三个角色

用户的主要功能有：

1.用户注册和登陆系统

2.用户查看新闻资讯

3.用户查看宠物医学知识

4.用户查看医生信息，能够在线预约医生

5.用户查看药品信息，在线购买药品

6.用户在线留言反馈

7.用户个人中心修改个人资料，修改密码

8.用户查看自己的预约信息，查看预约审核状态

9.用户查看自己购买的药品订单

10.退出登陆

宠物医生的主要功能有：

1.医生输入账户登陆系统

2.个人中心，医生修改密码和个人信息

3.预约挂号管理，对用户的挂号进行审核，回复，医嘱，查询

4.遗嘱管理，查看对用户回复的遗嘱信息

5.退出登陆

管理员的主要功能有：

1.管理员输入账户登陆后台

2.个人中心，管理员修改密码和账户信息

3.医生管理，对医生的信息进行添加，修改，删除，查询

4.用户管理，对注册的用户信息进行添加，修改，删除，查询

5.医学知识管理，对医学知识信息进行添加，修改，删除，查询

6.科室管理，对宠物医院的科室信息进行添加，修改，查询，删除

7.预约挂号管理，对医生预约的挂号信息进行管理

8.遗嘱信息管理，对遗嘱信息进行查询，修改，删除

9.药品信息管理，对宠物药品信息进行添加，修改，查询，删除

10.订单信息管理，对用户购买的药品订单信息进行查看，修改，删除，统计

11.留言板管理，对用户发布的留言信息进行删除，回复，修改，查询

12.系统设置，对新闻资讯和轮播图进行管理

13.退出信息

 
package com.controller;
 
 
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.Map;
 
import javax.servlet.http.HttpServletRequest;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
 
import com.annotation.IgnoreAuth;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.entity.TokenEntity;
import com.entity.UserEntity;
import com.service.TokenService;
import com.service.UserService;
import com.utils.CommonUtil;
import com.utils.MPUtil;
import com.utils.PageUtils;
import com.utils.R;
import com.utils.ValidatorUtils;
 
/**
 * 登录相关
 */
@RequestMapping("users")
@RestController
public class UserController{
	
	@Autowired
	private UserService userService;
	
	@Autowired
	private TokenService tokenService;
 
	/**
	 * 登录
	 */
	@IgnoreAuth
	@PostMapping(value = "/login")
	public R login(String username, String password, String captcha, HttpServletRequest request) {
		UserEntity user = userService.selectOne(new EntityWrapper().eq("username", username));
		if(user==null || !user.getPassword().equals(password)) {
			return R.error("账号或密码不正确");
		}
		String token = tokenService.generateToken(user.getId(),username, "users", user.getRole());
		return R.ok().put("token", token);
	}
	
	/**
	 * 注册
	 */
	@IgnoreAuth
	@PostMapping(value = "/register")
	public R register(@RequestBody UserEntity user){
//    	ValidatorUtils.validateEntity(user);
    	if(userService.selectOne(new EntityWrapper().eq("username", user.getUsername())) !=null) {
    		return R.error("用户已存在");
    	}
        userService.insert(user);
        return R.ok();
    }
 
	/**
	 * 退出
	 */
	@GetMapping(value = "logout")
	public R logout(HttpServletRequest request) {
		request.getSession().invalidate();
		return R.ok("退出成功");
	}
	
	/**
     * 密码重置
     */
    @IgnoreAuth
	@RequestMapping(value = "/resetPass")
    public R resetPass(String username, HttpServletRequest request){
    	UserEntity user = userService.selectOne(new EntityWrapper().eq("username", username));
    	if(user==null) {
    		return R.error("账号不存在");
    	}
    	user.setPassword("123456");
        userService.update(user,null);
        return R.ok("密码已重置为：123456");
    }
	
	/**
     * 列表
     */
    @RequestMapping("/page")
    public R page(@RequestParam Map params,UserEntity user){
        EntityWrapper ew = new EntityWrapper();
    	PageUtils page = userService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allLike(ew, user), params), params));
        return R.ok().put("data", page);
    }
 
	/**
     * 列表
     */
    @RequestMapping("/list")
    public R list( UserEntity user){
       	EntityWrapper ew = new EntityWrapper();
      	ew.allEq(MPUtil.allEQMapPre( user, "user")); 
        return R.ok().put("data", userService.selectListView(ew));
    }
 
    /**
     * 信息
     */
    @RequestMapping("/info/{id}")
    public R info(@PathVariable("id") String id){
        UserEntity user = userService.selectById(id);
        return R.ok().put("data", user);
    }
    
    /**
     * 获取用户的session用户信息
     */
    @RequestMapping("/session")
    public R getCurrUser(HttpServletRequest request){
    	Long id = (Long)request.getSession().getAttribute("userId");
        UserEntity user = userService.selectById(id);
        return R.ok().put("data", user);
    }
 
    /**
     * 保存
     */
    @PostMapping("/save")
    public R save(@RequestBody UserEntity user){
//    	ValidatorUtils.validateEntity(user);
    	if(userService.selectOne(new EntityWrapper().eq("username", user.getUsername())) !=null) {
    		return R.error("用户已存在");
    	}
        userService.insert(user);
        return R.ok();
    }
 
    /**
     * 修改
     */
    @RequestMapping("/update")
    public R update(@RequestBody UserEntity user){
//        ValidatorUtils.validateEntity(user);
    	UserEntity u = userService.selectOne(new EntityWrapper().eq("username", user.getUsername()));
    	if(u!=null && u.getId()!=user.getId() && u.getUsername().equals(user.getUsername())) {
    		return R.error("用户名已存在。");
    	}
        userService.updateById(user);//全部更新
        return R.ok();
    }
 
    /**
     * 删除
     */
    @RequestMapping("/delete")
    public R delete(@RequestBody Long[] ids){
        userService.deleteBatchIds(Arrays.asList(ids));
        return R.ok();
    }
}