Java项目:在线物流综合管理平台系统(java+SSM+HTML+JS+JSP+mysql)

源码获取：俺的博客首页 "资源" 里下载！

项目介绍

管理员角色包含以下功能
管理员登录,管理员管理,合作公司管理,车型信息,货物基本信息,汽车详细情况,客户留言,订单管理等功能。

用户角色包含以下功能：
网站首页,查看企业介绍,查看经营范围,服务网络查看,业务流程查看,客户留言,客户下单管理等功能。

环境需要

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.数据库：MySql 5.7版本；

技术栈

1. 后端：Spring+SpringMVC+Mybatis
2. 前端：HTML+CSS+JavaScript+jsp

使用说明

1. 使用Navicat或者其它工具，在mysql中创建对应名称的数据库，并导入项目的sql文件；
2. 使用IDEA/Eclipse/MyEclipse导入项目，Eclipse/MyEclipse导入时，若为maven项目请选择maven;若为maven项目，导入成功后请执行maven clean;maven install命令，然后运行；
3. 将项目中application.yml配置文件中的数据库配置改为自己的配置;
4. 运行项目，输入localhost:8080/ 登录

 

 

 

 

 

 

后台用户管理控制层：

@Controller
@RequestMapping("/admin")
public class AdminController {
    @Autowired
    private UserService userService;
    @Autowired
    private RoleService roleService;

    @RequestMapping("/list")
    @RequiresPermissions("admin:list")
    public String adminList() {
        return "admin/list";
    }

    /**
     * 该方法返回 admin 集合的 JSON 字符串，使用 PageHelper 工具进行分页
     * @param keyWord 搜索关键字
     * @param pageNum 页数，默认为 1
     * @param pageSize 每个页面用户容量，默认为 10/页
     * @return
     */
    @ResponseBody
    @RequestMapping("/getAdmins")
    @RequiresPermissions("admin:list")
    public PageInfo<User> getAdmins(String keyWord,
                                @RequestParam(defaultValue = "1") Integer pageNum,
                                @RequestParam(defaultValue = "10") Integer pageSize) {
        //开始分页，这里启动并设置页码，和每页结果数量后，后续结果会自动为分页后结果
        PageHelper.startPage(pageNum, pageSize);

        UserExample userExample = new UserExample();

        /**
         * StringUtils.isNotBlank 可以判断 ""/" "/null 为 false
         */
        if (StringUtils.isNotBlank(keyWord)) {
            //用户名条件
            UserExample.Criteria criteriaUserName = userExample.createCriteria();
            criteriaUserName.andUsernameLike("%" + keyWord + "%");

            //真实名字条件
            UserExample.Criteria criteriaRealName = userExample.createCriteria();
            criteriaRealName.andRealnameLike("%" + keyWord + "%");

            //将两个条件用 or 组合
            userExample.or(criteriaRealName);
        }

        List<User> users = userService.selectByExample(userExample);
        //获得分页对象
        PageInfo<User> pageInfo = new PageInfo<>(users);

        return pageInfo;
    }

    @ResponseBody
    @RequestMapping("/delete")
    @RequiresPermissions("admin:delete")
    public Map<String, String> delete(Long[] userIds) {
        HashMap<String, String> map = new HashMap<>();
        if (userIds.length == 1) {
            int res = userService.deleteByPrimaryKey(userIds[0]);
            if (res == 1) {
                map.put("status", "true");
                map.put("info", "删除成功！");
                return map;
            }
            map.put("status", "false");
            map.put("info", "删除失败！用户已经不存在");
            return map;
        }
        //批量删除
        int success = 0;
        int total = userIds.length;
        for(Long userId : userIds) {
            success += userService.deleteByPrimaryKey(userId);
        }
        map.put("status", "true");
        map.put("info", "成功删除选中 " + total + " 个用户中的 " + success + " 个用户");
        return map;
    }

    @RequiresPermissions("admin:insert")
    @RequestMapping("/add")
    public String addAdmin(Model m) {
        RoleExample roleExample = new RoleExample();
        List<Role> roles = roleService.selectByExample(roleExample);
        m.addAttribute("roles", roles);
        return "admin/add";
    }

    @ResponseBody
    @RequestMapping("/checkUsername")
    @RequiresPermissions("admin:list")
    public Boolean checkUsername(String username) {
        UserExample userExample = new UserExample();
        UserExample.Criteria criteria = userExample.createCriteria();
        criteria.andUsernameEqualTo(username);
        System.out.println(userService.selectByExample(userExample));
        if (userService.selectByExample(userExample).size() != 0) {
            return false;
        }
        return true;
    }

    @ResponseBody
    @RequestMapping("/insert")
    @RequiresPermissions("admin:insert")
    public Boolean insert(User user){
        String salt = UUID.randomUUID().toString().substring(0, 4);
        String hashedPassword = new SimpleHash("md5", user.getPassword(), salt,3).toString();
        user.setSalt(salt);
        user.setPassword(hashedPassword);
        user.setCreateDate(new Date());
        int res = userService.insert(user);
        if (res == 1) {
            return true;
        }
        return false;
    }

    @RequestMapping("/edit")
    @RequiresPermissions("admin:update")
    public String edit(Model m, Long userId) {
        m.addAttribute("user", userService.selectByPrimaryKey(userId));
        m.addAttribute("roles", roleService.selectByExample(new RoleExample()));
        return "admin/edit";
    }

    @ResponseBody
    @RequestMapping("/update")
    @RequiresPermissions("admin:update")
    public Boolean update(User user) {
        if (StringUtils.isBlank(user.getPassword())) {
            user.setPassword(null);
        } else {
            String salt = UUID.randomUUID().toString().substring(0, 4);
            String hashedPassword = new SimpleHash("md5", user.getPassword(), salt, 3).toString();
            user.setPassword(hashedPassword);
            user.setSalt(salt);
        }
        int res = userService.updateByPrimaryKeySelective(user);
        if (res == 1) {
            return true;
        }
        return false;
    }
}

客户管理控制层：

@Controller
@RequestMapping("/customer")
public class CustomerController {
    @Autowired
    private CustomerViewService customerViewService;
    @Autowired
    private CustomerService customerService;
    @Autowired
    private BasicDataService basicDataService;
    @Autowired
    private UserService userService;

    @RequestMapping("/list")
    @RequiresPermissions("customer:list")
    public String list() {
        return "customer/list";
    }

    @ResponseBody
    @RequestMapping("/getCustomers")
    @RequiresPermissions("customer:list")
    public PageInfo<CustomerView> getCustomers(String keyWord,
                                                 @RequestParam(defaultValue = "1") Integer pageNum,
                                                 @RequestParam(defaultValue = "10") Integer pageSize) {
        //开始分页，这里启动并设置页码，和每页结果数量后，后续结果会自动为分页后结果
        PageHelper.startPage(pageNum, pageSize);

        CustomerViewExample customerViewExample = new CustomerViewExample();
        CustomerViewExample.Criteria criteria = customerViewExample.createCriteria();
        /**
         * StringUtils.isNotBlank 可以判断 ""/" "/null 为 false
         */
        if (StringUtils.isNotBlank(keyWord)) {
            //权限名条件
            criteria.andCustomerNameLike("%" + keyWord + "%");
        }

        //判断当前登录用户是否为业务员，业务员只能查看自己的客户
        Subject subject = SecurityUtils.getSubject();
        User user = (User) subject.getPrincipal();
        if (user.getRoleId() == ConstantDataField.SALESMAN_ROLE_ID) {
            //客户的业务员id等于登录用户的id
            criteria.andUserIdEqualTo(user.getUserId());
        }

        List<CustomerView> customers = customerViewService.selectByExample(customerViewExample);
        //获得分页对象
        PageInfo<CustomerView> pageInfo = new PageInfo<>(customers);

        return pageInfo;
    }

    @ResponseBody
    @RequestMapping("/delete")
    @RequiresPermissions("customer:delete")
    public Map<String, String> delete(Long[] customerIds) {
        HashMap<String, String> map = new HashMap<>();
        if (customerIds.length == 1) {
            int res = customerService.deleteByPrimaryKey(customerIds[0]);
            if (res == 1) {
                map.put("status", "true");
                map.put("info", "删除成功！");
                return map;
            }
            map.put("status", "false");
            map.put("info", "删除失败！客户已经不存在");
            return map;
        }
        //批量删除
        int success = 0;
        int total = customerIds.length;
        for(Long customerId : customerIds) {
            success += customerService.deleteByPrimaryKey(customerId);
        }
        map.put("status", "true");
        map.put("info", "成功删除选中 " + total + " 个客户中的 " + success + " 个客户");
        return map;
    }


    @RequestMapping("/add")
    @RequiresPermissions("customer:insert")
    public String add(Model m) {
        //查出地区列表
        BasicDataExample basicDataExample = new BasicDataExample();
        basicDataExample.createCriteria().andParentIdEqualTo(ConstantDataField.AREA_BASICDATA_ID);
        List<BasicData> basicDatas= basicDataService.selectByExample(basicDataExample);
        m.addAttribute("areas",basicDatas);

        //获取当前登录用户
        Subject subject = SecurityUtils.getSubject();
        User user = (User) subject.getPrincipal();

        //如果是业务员进行操作，只能选择自己作为业务员
        List<User> users = new ArrayList<>();
        if (user.getRoleId() == ConstantDataField.SALESMAN_ROLE_ID) {
            users.add(user);
        } else {
            UserExample userExample = new UserExample();
            userExample.createCriteria().andRoleIdEqualTo(ConstantDataField.SALESMAN_ROLE_ID);
            users = userService.selectByExample(userExample);
        }
        m.addAttribute("users", users);

        return "customer/add";
    }

    @ResponseBody
    @RequestMapping("/insert")
    @RequiresPermissions("customer:insert")
    public Boolean insert(Customer customer){
        int res = customerService.insert(customer);
        if (res == 1) {
            return true;
        }
        return false;
    }

    @RequestMapping("/edit")
    @RequiresPermissions("customer:update")
    public String edit(Model m, Long customerId) {
        //查出地区列表
        BasicDataExample basicDataExample = new BasicDataExample();
        basicDataExample.createCriteria().andParentIdEqualTo(ConstantDataField.AREA_BASICDATA_ID);
        List<BasicData> basicDatas= basicDataService.selectByExample(basicDataExample);
        m.addAttribute("areas",basicDatas);

        //查出业务员
        UserExample userExample = new UserExample();
        userExample.createCriteria().andRoleIdEqualTo(ConstantDataField.SALESMAN_ROLE_ID);
        List<User> users = userService.selectByExample(userExample);
        m.addAttribute("users", users);

        //查出当前客户
        Customer customer = customerService.selectByPrimaryKey(customerId);
        m.addAttribute("customer", customer);
        return "customer/edit";
    }

    @ResponseBody
    @RequestMapping("/update")
    @RequiresPermissions("customer:update")
    public Boolean update(Customer customer) {
        int res = customerService.updateByPrimaryKeySelective(customer);
        if (res == 1) {
            return true;
        }
        return false;
    }
}

角色管理控制层：

@Controller
@RequestMapping("role")
public class RoleController {
    @Autowired
    private RoleService roleService;

    @Autowired
    private PermissionService permissionService;

    @RequestMapping("/list")
    @RequiresPermissions("role:list")
    public String roleList() {
        return "role/list";
    }

    @ResponseBody
    @RequestMapping("/getRoles")
    @RequiresPermissions("role:list")
    public PageInfo<Role> getAdmins(String keyWord,
                                    @RequestParam(defaultValue = "1") Integer pageNum,
                                    @RequestParam(defaultValue = "10") Integer pageSize) {
        //开始分页，这里启动并设置页码，和每页结果数量后，后续结果会自动为分页后结果
        PageHelper.startPage(pageNum, pageSize);

        RoleExample roleExample = new RoleExample();
        /**
         * StringUtils.isNotBlank 可以判断 ""/" "/null 为 false
         */
        if (StringUtils.isNotBlank(keyWord)) {
            //角色条件
            RoleExample.Criteria criteriaUserName = roleExample.createCriteria();
            criteriaUserName.andRolenameLike("%" + keyWord + "%");
        }

        List<Role> roles = roleService.selectByExample(roleExample);
        //获得分页对象
        PageInfo<Role> pageInfo = new PageInfo<>(roles);

        return pageInfo;
    }

    @ResponseBody
    @RequestMapping("/delete")
    @RequiresPermissions("role:delete")
    public Map<String, String> delete(Long[] roleIds) {
        HashMap<String, String> map = new HashMap<>();
        if (roleIds.length == 1) {
            int res = roleService.deleteByPrimaryKey(roleIds[0]);
            if (res == 1) {
                map.put("status", "true");
                map.put("info", "删除成功！");
                return map;
            }
            map.put("status", "false");
            map.put("info", "删除失败！角色已经不存在");
            return map;
        }
        //批量删除
        int success = 0;
        int total = roleIds.length;
        for(Long roleId : roleIds) {
            success += roleService.deleteByPrimaryKey(roleId);
        }
        map.put("status", "true");
        map.put("info", "成功删除选中 " + total + " 个角色中的 " + success + " 个角色");
        return map;
    }

    @RequestMapping("/add")
    @RequiresPermissions("role:insert")
    public String addRole() {
        return "role/add";
    }

    @ResponseBody
    @RequestMapping("/getTree")
    public List<Permission> getTree(){
        ArrayList<Permission> permissions = (ArrayList<Permission>) permissionService.selectByExample(new PermissionExample());
        return permissions;
    }

    @ResponseBody
    @RequestMapping("/insert")
    @RequiresPermissions("role:insert")
    public Boolean insert(Role role){
        int res = roleService.insert(role);
        if (res == 1)
            return true;
        return false;
    }

    @ResponseBody
    @RequestMapping("/checkRole")
    @RequiresPermissions("role:list")
    public Boolean checkRole(String name, String curName) {
        if (curName != null && name.equals(curName)) {
            return true;
        }
        RoleExample roleExample = new RoleExample();
        RoleExample.Criteria criteria = roleExample.createCriteria();
        criteria.andRolenameEqualTo(name);
        if (roleService.selectByExample(roleExample).size() != 0) {
            return false;
        }
        return true;
    }

    @RequestMapping("/edit")
    @RequiresPermissions("role:update")
    public String edit(Model m, Long roleId) {
        m.addAttribute("role", roleService.selectByPrimaryKey(roleId));
        return "role/edit";
    }

    @ResponseBody
    @RequestMapping("/update")
    @RequiresPermissions("role:update")
    public Boolean update(Role role) {
        int res = roleService.updateByPrimaryKeySelective(role);
        if (res == 1) {
            return true;
        }
        return false;
    }
}

源码获取：俺的博客首页 "资源" 里下载！