基于javaweb+mysql的ssm+maven药店药品管理系统(java+ssm+html+jquery+tomcat+mysql)

最新推荐文章于 2024-07-21 22:27:18 发布
最新推荐文章于 2024-07-21 22:27:18 发布
阅读量57 收藏
点赞数
文章标签： java mysql maven
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_81060432/article/details/134469535
版权

基于javaweb+mysql的ssm+maven药店药品管理系统(java+ssm+html+jquery+tomcat+mysql)

私信源码获取及调试交流

运行环境

Java≥8、MySQL≥5.7、Tomcat≥8

开发工具

eclipse/idea/myeclipse/sts等均可配置运行

适用

课程设计，大作业，毕业设计，项目练习，学习演示等

功能说明

基于javaweb+mysql的SSM+Maven药店药品管理系统(java+ssm+html+jquery+tomcat+mysql)

项目介绍

该项目是前后台的医药管理系统（写在了一个web项目里），

简单明了，界面高端大气，共6张表

后台管理系统用于药片的管理，

前台系统是用户购买药片，下订单使用。

主要功能介绍：

药品管理系统-后台：

订单管理

添加、编辑、删除

药品管理

添加、编辑、删除 - 药品名、药品类别、单价

药品类别管理

添加、编辑、删除 - 类别名称、描述

用户管理

添加、编辑、删除 - 用户名、电话、描述

药品商城-前台：

前台页面展示药品类别、药品缩略图、药品详情、可购买、加入购物车、形成订单

配置环境

1.运行环境：最好是java jdk 1.8，我们在这个平台上运行的。其他版本理论上也可以。

2.IDE环境：IDEA，Eclipse,Myeclipse都可以。推荐IDEA;

3.tomcat环境：Tomcat 7.x,8.x,9.x版本均可

4.硬件环境：windows 7/8/10 1G内存以上；或者 Mac OS；

5.是否Maven项目: 是；查看源码目录中是否包含pom.xml；

若包含，则为maven项目，否则为非maven项目

6.数据库：MySql 5.7版本；

技术栈

  1. 后端：Spring SpringMVC MyBatis 2. 前端：html+jQuery+javascript

使用步骤

1 使用IDEA/Eclipse导入MedicinesMS项目

2 使用Navicat或者其它工具，导入并执行sql文件 medicine_ms.sql,在项目的数据库配置文件db.properties中修改数据库相关配置，包括数据库名称、数据库用户名、密码等；

3 使用tomcat启动项目，项目名是/MedicinesMS 注：请固定为此项目名，否则会产生异常

4 访问后台系统http://localhost:8080/MedicinesMS/admin_login.html

进入登录页面，用户名 admin,密码123

5 在后台系统上添加药品信息

6 访问前台页面http://localhost:8080/MedicinesMS/login.html,

使用用户名 admin,密码123登录，购买要求，形成订单。

    @RequestMapping(value = "getLimitOrders")
    public @ResponseBody
    Map<String, Object> getLimitOrders(@RequestParam(value = "offset") int offset,
                                       @RequestParam(value = "limit") int limit) throws Exception {
        List<Orders> ordersList = ordersService.getLimitOrders(offset, limit);
        Map<String, Object> result = new HashMap<String, Object>();
        if (ordersList.size() > 0) {
            result.put("state", "success");
            result.put("result", ordersList);
        } else {
            result.put("state", "fail");
            result.put("reason", null);
        }
        return result;
    }

    /**
     * 获取订单总量
     * @return Map 返回相关状态及信息
     * @throws Exception 异常
     */
    @RequestMapping(value = "getOrdersCount")
    public @ResponseBody
    Map<String, Object> getOrdersCount() throws Exception {
        int count = ordersService.count();
        Map<String, Object> result = new HashMap<String, Object>();
        if (count > 0) {
            result.put("state", "success");
            result.put("result", count);
        } else {
            result.put("state", "fail");
            result.put("reason", 0);
        }
        return result;
    }

    /**
     * 根据订单ID更新订单信息
     * @param orders 新的订单信息
     * @return Map 返回相关状态及信息
     * @throws Exception 异常
     */
    @RequestMapping(value = "updateOrdersById")
    public @ResponseBody
    Map<String, Object> updateOrdersById(@RequestBody Orders orders) throws Exception {

        }
        return result;
    }

    /**
     * 根据管理员ID数组删除一些管理员信息
     * @param adminIds 管理员ID数组
     * @return Map 返回相关状态及信息
     * @throws Exception 异常
     */
    @RequestMapping(value = "deleteSomeAdmin")
    public @ResponseBody
    Map<String, Object> deleteSomeAdmin(@RequestParam(value = "adminIds[]") String[] adminIds) throws Exception {
        int deleteNum = adminService.deleteSomeAdmin(adminIds);
        Map<String, Object> result = new HashMap<String, Object>();
        if (deleteNum > 0) {
            result.put("state", "success");
            result.put("result", deleteNum);
        } else {
            result.put("state", "fail");
            result.put("reason", null);
        }
        return result;
    }

    /**
     * 添加管理员
     * @param admin 用户信息
     * @return Map 返回相关状态及信息
     * @throws Exception 异常
     */
    @RequestMapping(value = "addAdmin")
    public @ResponseBody
    Map<String, Object> addAdmin(@RequestBody Admin admin) throws Exception {
        int addCount = adminService.addAdmin(admin);
        Map<String, Object> result = new HashMap<String, Object>();
        if (addCount > 0) {
            result.put("state", "success");
            result.put("result", addCount);
        } else {
            result.put("state", "fail");
            result.put("reason", 0);

            result.put("state", "success");
            result.put("result", imgPath);
        } else {
            result.put("state", "fail");
            result.put("reason", null);
        }
        return result;
    }

    /**
     * 根据过滤条件过滤查询药品总数
     * @param medicine 药品过滤信息
     * @return Map 返回相关状态及信息
     * @throws Exception 异常
     */
    @RequestMapping(value = "getFilteredMedicineCount")
    public @ResponseBody
    Map<String, Object> getFilteredMedicineCount(@RequestBody Medicine medicine) throws Exception {
        System.out.println("getFilteredMedicineCount --- medicine: " + medicine);
        Map<String, Object> result = new HashMap<String, Object>();
        int count = medicineService.getFilteredCount(medicine);
        if (count > 0) {
            result.put("state", "success");
            result.put("result", count);
        } else {
            result.put("state", "fail");
            result.put("reason", null);
        }
        return result;
    }

}

/**
 * Description: 用户控制器
 * Author: clw

     * @param medicine 药品过滤信息
     * @return int 药品总量
     * @throws Exception 异常
     */
    int getFilteredCount(Medicine medicine) throws Exception;

}

/**
 * Description: 登录拦截器
 * Author: clw
 * Version: 1.0
 */
public class LoginInterceptor implements HandlerInterceptor {

    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object o) throws Exception {
        String url = request.getRequestURI();
        if (url.indexOf("login.action") > 0 || url.indexOf("registerUser.action") > 0) {
            return true;
        }
        HttpSession session = request.getSession();
        String username = (String) session.getAttribute("username");
        System.out.println("*** username: " + username);
        if (username != null && !"".equals(username.trim())) {
            return true;
        }
        response.getWriter().print("redirect:login");
        return false;
    }

    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {

    }

                                         @RequestParam(value = "limit") int limit) throws Exception {
        medTypeId = "".equals(medTypeId) ? null : medTypeId;
        List<Medicine> medicines = medicineService.getFilteredLimitMedicine(medTypeId, offset, limit);
        Map<String, Object> result = new HashMap<String, Object>();
        if (medicines.size() > 0) {
            result.put("state", "success");
            result.put("result", medicines);
        } else {
            result.put("state", "fail");
            result.put("reason", null);
        }
        return result;
    }

    /**
     * 获取指定ID的药品信息
     * @param medicineIds String[] 药品ID数组
     * @return Map 返回相关状态及信息
     * @throws Exception 异常
     */
    @RequestMapping(value = "getSomeMedicine")
    public @ResponseBody
    Map<String, Object> getSomeMedicine(@RequestParam(value = "medicineIds[]") String[] medicineIds) throws Exception {
        List<Medicine> medicines = medicineService.getSomeMedicine(medicineIds);
        Map<String, Object> result = new HashMap<String, Object>();
        if (medicines.size() > 0) {
            result.put("state", "success");
            result.put("result", medicines);
        } else {
            result.put("state", "fail");
            result.put("reason", null);
        }
        return result;
    }

    /**
     * 获取药品总量
     * @return Map 返回相关状态及信息
     * @throws Exception 异常
     */
    @RequestMapping(value = "getMedicineCount")
    public @ResponseBody
    Map<String, Object> getMedicineCount() throws Exception {
        int count = medicineService.count();
        Map<String, Object> result = new HashMap<String, Object>();
        if (count > 0) {
            result.put("state", "success");

     * 药品图片上传
     * @param medicinePic 药品图片
     * @return Map 返回相关状态及信息
     * @throws Exception 异常
     */
    @RequestMapping(value = "addMedicinePic")
    public @ResponseBody
    Map<String, Object> addMedicinePic(HttpServletRequest request,
            @RequestParam("medicinePic") MultipartFile medicinePic) throws Exception {
        Map<String, Object> result = new HashMap<String, Object>();
        String imgPath = medicineService.uploadFile(request, medicinePic);
        System.out.println("upload img path: " + imgPath);
        if (imgPath != null) {
            result.put("state", "success");
            result.put("result", imgPath);
        } else {
            result.put("state", "fail");
            result.put("reason", null);
        }
        return result;
    }

    /**
     * 根据过滤条件过滤查询药品总数
     * @param medicine 药品过滤信息
     * @return Map 返回相关状态及信息
     * @throws Exception 异常
     */
    @RequestMapping(value = "getFilteredMedicineCount")
    public @ResponseBody
    Map<String, Object> getFilteredMedicineCount(@RequestBody Medicine medicine) throws Exception {
        System.out.println("getFilteredMedicineCount --- medicine: " + medicine);
        Map<String, Object> result = new HashMap<String, Object>();
        int count = medicineService.getFilteredCount(medicine);
        if (count > 0) {
            result.put("state", "success");
            result.put("result", count);
        } else {
            result.put("state", "fail");
            result.put("reason", null);
        }
        return result;
    }

}


        if (updateCount > 0) {
            result.put("state", "success");
            result.put("result", updateCount);
        } else {
            result.put("state", "fail");
            result.put("reason", 0);
        }
        return result;
    }

    /**
     * 根据药品ID数组删除一些药品信息
     * @param medicineIds 药品ID数组
     * @return Map 返回相关状态及信息
     * @throws Exception 异常
     */
    @RequestMapping(value = "deleteSomeMedicine")
    public @ResponseBody
    Map<String, Object> deleteSomeMedicine(@RequestParam(value = "medicineIds[]") String[] medicineIds) throws Exception {
        int deleteNum = medicineService.deleteSomeMedicine(medicineIds);
        Map<String, Object> result = new HashMap<String, Object>();
        if (deleteNum > 0) {
            result.put("state", "success");
            result.put("result", deleteNum);
        } else {
            result.put("state", "fail");
            result.put("reason", null);
        }
        return result;
    }

    /**
     * 添加药品
     * @param medicine 药品信息
     * @return Map 返回相关状态及信息
     * @throws Exception 异常
     */
    @RequestMapping(value = "addMedicine")
    public @ResponseBody
    Map<String, Object> addMedicine(@RequestBody Medicine medicine) throws Exception {
        int addCount = medicineService.addMedicine(medicine);
        Map<String, Object> result = new HashMap<String, Object>();
        if (addCount > 0) {
            result.put("state", "success");
            result.put("result", addCount);
        } else {
            result.put("state", "fail");
            result.put("reason", 0);
        }
        return result;


    /**
     * 根据过滤条件查看药品总量
     * @param medicine 药品过滤信息
     * @return int 药品总量
     * @throws Exception 异常
     */
    int getFilteredCount(Medicine medicine) throws Exception;

}

/**
 * Description: 登录拦截器
 * Author: clw
 * Version: 1.0
 */
public class LoginInterceptor implements HandlerInterceptor {

    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object o) throws Exception {
        String url = request.getRequestURI();
        if (url.indexOf("login.action") > 0 || url.indexOf("registerUser.action") > 0) {
            return true;
        }
        HttpSession session = request.getSession();
        String username = (String) session.getAttribute("username");
        System.out.println("*** username: " + username);
        if (username != null && !"".equals(username.trim())) {
            return true;
        }
        response.getWriter().print("redirect:login");
        return false;
    }

    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {


        if (userId != null && !"".equals(userId)) {
            user = userService.getUserById(userId);
        }
        Map<String, Object> result = new HashMap<String, Object>();
        if (user != null) {
            result.put("state", "success");
            result.put("result", user);
        } else {
            result.put("state", "fail");
            result.put("reason", null);
        }
        return result;
    }

}

/**
 * Description: 药品控制器
 * Author: clw
 * Version: 1.0
 */
@Controller
@RequestMapping(value = "medicine/medicine", method = {RequestMethod.POST})
public class MedicineController {

    @Autowired
    MedicineService medicineService;

    /**

     * @return Map 返回相关状态及信息
     * @throws Exception 异常
     */
    @RequestMapping(value = "getMedicineTypeCount")
    public @ResponseBody
    Map<String, Object> getMedicineTypeCount() throws Exception {
        int count = medicineTypeService.count();
        Map<String, Object> result = new HashMap<String, Object>();
        if (count > 0) {
            result.put("state", "success");
            result.put("result", count);
        } else {
            result.put("state", "fail");
            result.put("reason", 0);
        }
        return result;
    }

    /**
     * 获取指定数量的药品类型信息
     * @param offset 偏移量
     * @param limit 返回限制条数
     * @return Map 返回相关状态及信息
     * @throws Exception 异常
     */
    @RequestMapping(value = "getLimitMedicineType")
    public @ResponseBody
    Map<String, Object> getLimitMedicineType(@RequestParam(value = "offset") int offset,
                                         @RequestParam(value = "limit") int limit) throws Exception {
        List<MedicineType> medicineTypes = medicineTypeService.getLimitMedicineType(offset, limit);
        Map<String, Object> result = new HashMap<String, Object>();
        if (medicineTypes.size() > 0) {
            result.put("state", "success");
            result.put("result", medicineTypes);
        } else {
            result.put("state", "fail");
            result.put("reason", null);
        }
        return result;
    }

    /**
     * 根据药品类型ID更新药品类型信息
     * @param medicineType 新的药品类型信息
     * @return Map 返回相关状态及信息
     * @throws Exception 异常
     */
    @RequestMapping(value = "updateMedicineTypeById")
    public @ResponseBody
    Map<String, Object> updateMedicineTypeById(@RequestBody MedicineType medicineType) throws Exception {
        int updateCount = medicineTypeService.updateById(medicineType);
        Map<String, Object> result = new HashMap<String, Object>();
        if (updateCount > 0) {


/**
 * Description: 用户控制器
 * Author: clw
 * Version: 1.0
 */
@Controller
@RequestMapping(value = "user/admin", method = {RequestMethod.POST})
public class AdminController {

    @Autowired
    AdminService adminService;

    /**
     * 登录Controller
     * @param request HttpServletRequest 对象
     * @param username 用户名
     * @param password 密码
     * @return Map 返回相关状态
     * @throws Exception 异常
     */
    @RequestMapping(value = "login")
    public @ResponseBody
    Map<String, String> login(HttpServletRequest request, @RequestParam(value = "username", defaultValue = "") String username,
                              @RequestParam(value = "password", defaultValue = "") String password) throws Exception {
        Admin admin = adminService.loginCheck(username, password);
        Map<String, String> resultMap =new HashMap<String, String>();
        if (admin != null) {
            request.getSession().setAttribute("userid", admin.getUid());
            request.getSession().setAttribute("username", admin.getUsername());
            request.getSession().setAttribute("identity", "admin");
            resultMap.put("state", "success");
        } else {
            resultMap.put("state", "fail");
            resultMap.put("reason", ErrorInfoUtil.getErrorInfo("user.login.check.null"));
        }
        return resultMap;
    }

    /**
     * 获取管理员总量
     * @return Map 返回相关状态及信息
     * @throws Exception 异常
     */
    @RequestMapping(value = "getAdminCount")
    public @ResponseBody
    Map<String, Object> getAdminCount() throws Exception {
        int count = adminService.count();

    public @ResponseBody
    Map<String, Object> updateAdminPasswdById(@RequestParam(value = "uid", defaultValue = "") String uid,
                                             @RequestParam(value = "originalPasswd", defaultValue = "") String originalPasswd,
                                             @RequestParam(value = "newPasswd", defaultValue = "") String newPasswd) throws Exception {
        int updateCount = adminService.updatePasswdById(uid, originalPasswd, newPasswd);
        Map<String, Object> result = new HashMap<String, Object>();
        if (updateCount > 0) {
            result.put("state", "success");
            result.put("result", updateCount);
        } else {
            result.put("state", "fail");
            result.put("reason", 0);
        }
        return result;
    }

}

/**
 * Description:
 * Author: clw
 * Version: 1.0
 */
@Controller
@RequestMapping(value = "medicine/medicine_type", method = {RequestMethod.POST})
public class MedicineTypeController {

    @Autowired
    MedicineTypeService medicineTypeService;

    /**
     * 获取指定ID的药品类型信息
     * @param typeIds String[] 药品类型ID数组
     * @return Map 返回相关状态及信息
     * @throws Exception 异常
     */
    @RequestMapping(value = "getSomeMedicineType")
    public @ResponseBody
    Map<String, Object> getSomeMedicineType(@RequestParam(value = "typeIds[]") String[] typeIds) throws Exception {

        medicine.setState(1);
        return medicineMapper.countBySelective(medicine);
    }

}

/**
 * Description: 药品业务接口
 * Author: clw
 * Version: 1.0
 */
public interface MedicineService {

    /**
     * 获取指定数量的药品
     * @param medTypeId 药品类型ID
     * @param offset 偏移量
     * @param limit 返回限制条数
     * @return List<Medicine> 药品集合
     * @throws Exception 异常
     */
    List<Medicine> getFilteredLimitMedicine(String medTypeId, int offset, int limit) throws Exception;

    /**
     * 获取指定ID量的药品
     * @param medicineIds String[] 类型ID的列表
     * @return List<Medicine> 药品集合
     * @throws Exception 异常
     */
    List<Medicine> getSomeMedicine(String[] medicineIds) throws Exception;

    /**
     * 获取药品总量
     * @return int 药品的数量

        }
        return result;
    }

}

/**
 * Description: 药品控制器
 * Author: clw
 * Version: 1.0
 */
@Controller
@RequestMapping(value = "medicine/medicine", method = {RequestMethod.POST})
public class MedicineController {

    @Autowired
    MedicineService medicineService;

    /**
     * 获取指定数量的药品信息
     * @param offset 偏移量
     * @param limit 返回限制条数
     * @return Map 返回相关状态及信息
     * @throws Exception 异常
     */
    @RequestMapping(value = "getFilteredLimitMedicine")
    public @ResponseBody
    Map<String, Object> getFilteredLimitMedicine(@RequestParam(value = "medTypeId", defaultValue = "") String medTypeId,
                                                 @RequestParam(value = "offset") int offset,
                                         @RequestParam(value = "limit") int limit) throws Exception {
        medTypeId = "".equals(medTypeId) ? null : medTypeId;
        List<Medicine> medicines = medicineService.getFilteredLimitMedicine(medTypeId, offset, limit);
        Map<String, Object> result = new HashMap<String, Object>();
        if (medicines.size() > 0) {

    /**
     * 添加管理员
     * @param admin 用户信息
     * @return Map 返回相关状态及信息
     * @throws Exception 异常
     */
    @RequestMapping(value = "addAdmin")
    public @ResponseBody
    Map<String, Object> addAdmin(@RequestBody Admin admin) throws Exception {
        int addCount = adminService.addAdmin(admin);
        Map<String, Object> result = new HashMap<String, Object>();
        if (addCount > 0) {
            result.put("state", "success");
            result.put("result", addCount);
        } else {
            result.put("state", "fail");
            result.put("reason", 0);
        }
        return result;
    }

    /**
     * 根据管理员ID更新用户密码
     * @param uid 管理员ID
     * @param originalPasswd 原密码
     * @param newPasswd 新密码
     * @return Map 返回相关状态及信息
     * @throws Exception 异常
     */
    @RequestMapping(value = "updateAdminPasswdById")
    public @ResponseBody
    Map<String, Object> updateAdminPasswdById(@RequestParam(value = "uid", defaultValue = "") String uid,
                                             @RequestParam(value = "originalPasswd", defaultValue = "") String originalPasswd,
                                             @RequestParam(value = "newPasswd", defaultValue = "") String newPasswd) throws Exception {
        int updateCount = adminService.updatePasswdById(uid, originalPasswd, newPasswd);
        Map<String, Object> result = new HashMap<String, Object>();
        if (updateCount > 0) {
            result.put("state", "success");
            result.put("result", updateCount);
        } else {
            result.put("state", "fail");
            result.put("reason", 0);
        }
        return result;
    }

}

            result.put("state", "success");
            result.put("result", addCount);
        } else {
            result.put("state", "fail");
            result.put("reason", 0);
        }
        return result;
    }

    /**
     * 根据用户ID更新用户密码
     * @param uid 用户ID
     * @param originalPasswd 原密码
     * @param newPasswd 新密码
     * @return Map 返回相关状态及信息
     * @throws Exception 异常
     */
    @RequestMapping(value = "updateUserPasswdById")
    public @ResponseBody
    Map<String, Object> updateUserPasswdById(@RequestParam(value = "uid", defaultValue = "") String uid,
                                             @RequestParam(value = "originalPasswd", defaultValue = "") String originalPasswd,
                                             @RequestParam(value = "newPasswd", defaultValue = "") String newPasswd) throws Exception {
        int updateCount = userService.updatePasswdById(uid, originalPasswd, newPasswd);
        Map<String, Object> result = new HashMap<String, Object>();
        if (updateCount > 0) {
            result.put("state", "success");
            result.put("result", updateCount);
        } else {
            result.put("state", "fail");
            result.put("reason", 0);
        }
        return result;
    }

    /**
     * 获取当前登录用户
     * @return Map 返回相关状态及信息
     * @throws Exception 异常
     */
    @RequestMapping(value = "getCurrentUser")
    public @ResponseBody
    Map<String, Object> getCurrentUser(HttpServletRequest request) throws Exception {
        String userId = (String) request.getSession().getAttribute("userid");
        User user = null;
        if (userId != null && !"".equals(userId)) {
            user = userService.getUserById(userId);
        }
        Map<String, Object> result = new HashMap<String, Object>();
        if (user != null) {
            result.put("state", "success");
            result.put("result", user);

        } else {
            result.put("state", "fail");
            result.put("reason", 0);
        }
        return result;
    }

    /**
     * 根据药品类型ID数组删除一些药品类型信息
     * @param medicineTypeIds 药品类型ID数组
     * @return Map 返回相关状态及信息
     * @throws Exception 异常
     */
    @RequestMapping(value = "deleteSomeMedicineType")
    public @ResponseBody
    Map<String, Object> deleteSomeMedicineType(@RequestParam(value = "medicineTypeIds[]") String[] medicineTypeIds) throws Exception {
        int deleteNum = medicineTypeService.deleteSomeMedicineType(medicineTypeIds);
        Map<String, Object> result = new HashMap<String, Object>();
        if (deleteNum > 0) {
            result.put("state", "success");
            result.put("result", deleteNum);
        } else {
            result.put("state", "fail");
            result.put("reason", null);
        }
        return result;
    }

    /**
     * 添加药品类型
     * @param medicineType 药品信息
     * @return Map 返回相关状态及信息
     * @throws Exception 异常
     */
    @RequestMapping(value = "addMedicineType")
    public @ResponseBody
    Map<String, Object> addMedicineType(@RequestBody MedicineType medicineType) throws Exception {
        System.out.println(medicineType);
        int addCount = medicineTypeService.addMedicineType(medicineType);
        Map<String, Object> result = new HashMap<String, Object>();

请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述

Java源码jdk
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java项目:轻语音乐网平台(java+Springboot+ssm+mysql+maven+jsp)
02-11
一、项目简述 ...进行收藏 我的音乐模块：收藏的歌曲会被添加到我的音乐列表中， 在我的音乐列表中也可以对...项目技术： JSP +SpringBoot + MyBatis + html+ css + JavaScript + JQuery + Ajax + Bootstrap+ maven 等等。
Java项目:在线考试平台(java+Springboot+ssm+mysql+maven)
12-02
发布考试，考试列表，课程管理，题库管 理，成绩管理，成绩情况 /权限管理：学院管理，班级管理，用户管理，角色管 理，资源管理 4网站管理：基础信息，友链管理，评论管理，标签管理 /系统管理：在线用户 /上传管理...
java计算机毕业设计（附源码）药店管理系统（ssm+mysql+maven+LW文档）
十甘程序设计
03-31 397
药店管理系统的建立，可以有效地解决传统药店管理中存在的问题。首先，通过电子化、信息化的管理方式，可以实现药品信息的快速查询、准确记录和有效跟踪，大大提高了工作效率，降低了错误率。其次，药店管理系统可以实现库存的实时监控和智能预警，帮助药店合理控制库存，避免药品的过期和滞销，降低了运营成本。总的来说，药店管理系统对于提升药店的经营管理水平，保障药品的安全供应，满足人们的健康需求具有重要的意义。随着经济的发展和人民生活水平的提高，人们对健康的需求日益增长，对药品的品种、质量和服务的要求也越来越高。
SSM+mysql药店商品管理平台-计算机毕业设计源码56458
vx2_Biye_Design的博客
07-11 1588
（一）基础功能 （1）系统用户模块：用户信息（用户列表、修改用户密码、修改用户权限、修改用户） （2）药品模块： ①　销售模块：销售登记、销售退货、销售查询、销售退货查询 ②　入库模块：入库登记、入库退货、入库查询、入库退货查询 ③　调货模块：包含调货登记和调货查询两部分。 ④　库存模块：库存盘点、库存查询、仓库管理 （3）销售财务模块： ①　结账模块：主要包括销售结帐、入库结账 ②　财务模块：日结、月结、供应商往来账、客户往来账 （4）会员管理：会员列表 （5）供应商模块：供应商信息
小型药店药品管理系统 毕业设计源码41068
FYKJ_2010的博客
12-19 997
药店药品管理系统在系统的手机上可以运行，主要实现了管理员后端；管理员、首页、轮播图、公告信息、资源管理（新闻列表、新闻分类列表）系统用户（管理员、会员用户、药品出纳员、仓库管理者）模块管理（药品信息、订单管理、药品入库、药房管理）等主要功能模块的操作和管理。
计算机毕业设计 jsp药品进销存管理系统mysql-mybatis 毕设
weixin_41792788的博客
02-25 978
在一个优秀的系统中，除了后台程序的完备，从用户的角度来讲，界面的美观远比程序的完备更加具有说服力。由于信息管理中，难免有一些人为错误的出现，为了最大限度的减少人为错误，提高工作效率，而设计一套完整的药品进销存管理系统，实现对药品信息的录入、更改的规范化、系统化以及对相应药品的供应商的信息进行严格的录入，避免在药品进出库问题上产生不必要的纠纷等。在进行了可行性研究报告和需求分析以后，为了具体的实现本系统最初想要实现的功能，我们需要进行总体设计，对系统的各部分进行详细的分析与设计，最终完成一个完整的系统。
[附源码]JAVA+ssm基于HTML的企业进销存管理系统（程序+Lw)
苏南学长
03-21 435
项目运行环境配置：Jdk1.8 + Tomcat7.0 + Mysql + HBuilderX（Webstorm也行）+ Eclispe（IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持）。项目技术：SSM + mybatis + Maven + Vue 等等组成，B/S模式 + Maven管理等等。环境需要1.运行环境：最好是java jdk 1.8，我们在这个平台上运行的。其他版本理论上也可以。
基于javaweb+mysql的ssm+maven药店信息管理系统(java+ssm+jsp+layui+maven+mysql)
m0_56289293的博客
08-27 68
JSP +Spring + SpringMVC + MyBatis + html+ css + JavaScript + JQuery + Ajax + layui+ maven等等。基于javaweb+mysql的ssm+maven药店信息管理系统(java+ssm+jsp+layui+maven+mysql)基于javaweb+mysql的SSM+Maven药店信息管理系统(java+ssm+jsp+layui+maven+mysql)课程设计，大作业，毕业设计，项目练习，学习演示等。
基于javaweb+mysql的ssm+maven物业管理系统(java+ssm+html+jquery+maven+mysql)
毕业javaweb，一直在线，欢迎私信
12-09 374
基于javaweb+mysql的ssm+maven物业管理系统(java+ssm+html+jquery+maven+mysql)基于javaweb的SSM+Maven物业管理系统(java+ssm+html+jquery+maven+mysql)物业管理系统，包含登录信息统计、物业人员管理，住户管理，房屋管理、车位管理等功能；eclipse/idea/myeclipse/sts等均可配置运行。课程设计，大作业，毕业设计，项目练习，学习演示等。开发工具：IDEA/Eclipse。
基于javaweb+mysql的ssm+maven情缘图书馆管理系统(java+ssm+tomcat+maven+mysql)
m0_71481516的博客
08-27 79
基于javaweb+mysql的ssm+maven情缘图书馆管理系统(java+ssm+tomcat+maven+mysql)eclipse/idea/myeclipse/sts等均可配置运行。课程设计，大作业，毕业设计，项目练习，学习演示等。图书借阅管理：借阅图书、借阅信息、归还、续借；读者管理：办证、读者信息、读者类别、证件操作；图书编目管理：图书编目、编目维护；图书信息管理：图书录入、图书信息；系统管理：权限信息、用户权限；
基于javaweb+mysql的学生信息管理系统(java+SSM+jsp+mysql+maven)
m0_71480786的博客
05-28 711
一、项目简述 功能包括： 用户的登录注册，学生信息管理，教师信息管理，班级信 息管理，采用mvcx项目架构，覆盖增删改查，包括学生， 教币班级的信息导出上传导入等等功能。 二、项目运行 环境配置： Jdk1.8 + Tomcat8.5 + mysql + Eclispe (IntelliJ IDEA,Eclispe,MyEclispe,Sts 都支持) 项目技术： JSP +Spring + SpringMVC + MyBatis + html+ css + JavaScript + JQuery + Aj
Java项目:车险理赔管理系统(java+SSM+JSP+echarts+jQuery+Mysql)
07-09
车险理赔管理系统源码，分为三个用户，一个管理员，一个工作人员，一个普通人员 管理员功能：登录、发放赔偿金、赔偿金发放列表、申请理赔列表、申请理赔通过、我的资料、用户列表 工作人员功能：勘察员-待调查事故...
Java项目:图书管理系统(java+SSM+jsp+mysql+maven)
02-18
 功能包括(管理员和学生角色)： 管理员和学生登录，图书管理，图书添加删除修改，图书 借阅，图书归还，图书查看，学生管理，借还管理，读者 管理，密码管理，信息修改等等功能。 二、项目运行 环境配置： Jdk1.8 ...
基于javaweb+SSM+maven实现校园订餐系统源码
06-30
基于javaweb+SSM+maven实现校园订餐系统源码
Java-Lambda
最新发布
lizhiwei21的博客
07-21 178
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Java内存模型
weixin_44267758的博客
07-19 681
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 497
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1178
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1156
JVM-垃圾回收与内存分配

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值