计算机毕业设计选题推荐-美术馆微信小程序/安卓APP-项目实战

✨作者主页：IT研究室✨
个人简介：曾从事计算机专业培训教学，擅长Java、Python、微信小程序、Golang、安卓Android等项目实战。接项目定制开发、代码讲解、答辩教学、文档编写、降重等。
☑文末获取源码☑
精彩专栏推荐⬇⬇⬇
Java项目
Python项目
安卓项目
微信小程序项目

文章目录

一、前言
二、开发环境
三、系统界面展示
四、代码参考
五、论文参考
六、系统视频
结语

一、前言

在信息化社会的快速发展背景下，小程序和安卓应用已经成为人们日常生活的重要组成部分。美术馆作为文化艺术的重要载体，如何借助这些信息化工具提升管理和服务水平，成为了当前亟待解决的问题。本课题基于美术馆微信小程序与安卓APP的开发，旨在解决美术馆信息化管理的需求，提高美术馆运营效率和服务质量。

当前，部分美术馆已经使用了信息化管理系统，但这些系统存在一些问题。首先，系统的功能相对单一，往往只涵盖了展品管理或预约管理的一部分，无法满足美术馆管理的需求。其次，系统的用户体验不佳，操作复杂，使得使用效率低下。再次，系统的数据整合能力较弱，无法实现数据的利用和共享。这些问题都凸显了开发美术馆微信小程序与安卓APP的必要性。

本课题的研究目的是开发一款集美术馆信息管理、展品管理、美术馆预约管理于一体的微信小程序和安卓APP。通过这款工具，用户可以方便地获取美术馆的信息，查看展品的详细资料，以及进行参观预约。同时，可以通过这款工具进行美术馆信息的维护、展品的添加与编辑、以及预约的管理。具体研究内容包括以下几个方面：

美术馆信息管理：对美术馆的基本信息、展览信息、活动信息等进行维护与更新。
展品管理：对展品的信息进行添加、编辑、查询等操作，包括展品的名称、描述、图片等。
美术馆预约管理：提供用户预约参观的功能，包括预约时间的设定、预约状态的查询等。
数据共享与整合：实现数据的共享与整合，使得各个模块的数据可以相互引用，提高数据的使用效率。
用户体验优化：优化操作流程，提高系统的易用性，使用户可以方便快捷地进行操作。

本课题的研究意义在于推动美术馆信息化管理的发展，提高美术馆的运营效率和服务质量。通过微信小程序和安卓APP的开发，可以让用户更加便捷地获取美术馆的信息和服务，同时也使得管理员可以更加便捷地进行管理工作。此外，通过数据的共享与整合，可以实现数据的利用，为美术馆的管理决策提供数据支持。最后，通过用户体验的优化，可以提高用户的使用效率，提升用户满意度。

二、开发环境

开发语言：Java
数据库：MySQL
系统架构：移动端
后端：SpringBoot
前端：Vue

三、系统界面展示

美术馆微信小程序/安卓APP界面展示：

四、代码参考

美术馆微信小程序/安卓APP项目实战代码参考：

@RestController
@RequestMapping("/sys/notice")
public class SysNoticeController {

    @Autowired
    private HttpServletRequest request;
    @Autowired
    private SysNoticeService sysNoticeService;

    private Page getPage(){
        int current = ServletRequestUtils.getIntParameter(request,"current",1);
        int size = ServletRequestUtils.getIntParameter(request,"size",10);
        return new Page(current,size);
    }

    @GetMapping("list")
    @PreAuthorize("hasAuthority('sys:notice:list')")
    public Result list(String title){
        Page<SysNotice> pageData = sysNoticeService.page(getPage(),new LambdaQueryWrapper<SysNotice>().like(StrUtil.isNotBlank(title),SysNotice::getTitle,title).orderByDesc(SysNotice::getCreated));
        return Result.ok().data("pageData",pageData);
    }

    @PostMapping("save")
    @PreAuthorize("hasAuthority('sys:notice:save')")
    public Result save(@Validated @RequestBody SysNotice sysNotice){
        sysNotice.setCreated(new Date());
        boolean flag = sysNoticeService.save(sysNotice);
        return flag ? Result.ok() : Result.error();
    }

    @GetMapping("info/{id}")
    @PreAuthorize("hasAuthority('sys:notice:list')")
    public Result info(@PathVariable("id") Long id){
        SysNotice notice = sysNoticeService.getById(id);
        return Result.ok().data("info",notice);
    }

    @PostMapping("update")
    @PreAuthorize("hasAuthority('sys:notice:update')")
    public Result update(@Validated @RequestBody SysNotice sysNotice){
        sysNotice.setUpdated(new Date());
        boolean flag = sysNoticeService.updateById(sysNotice);
        return flag ? Result.ok() : Result.error();
    }

    @PostMapping("delete")
    @PreAuthorize("hasAuthority('sys:notice:delete')")
    @Transactional
    public Result delete(@RequestBody Long[] noticeIds){
        boolean flag = sysNoticeService.removeByIds(Arrays.asList(noticeIds));
        return flag ? Result.ok() : Result.error();
    }
}

@RestController
@RequestMapping("/appointment")
public class UserAppointmentController {

    @Autowired
    private HttpServletRequest request;
    @Autowired
    private UserAppointmentService userAppointmentService;
    @Autowired
    private PlaceVdstateService placeVdstateService;
    @Autowired
    private SysPlaceService sysPlaceService;

    private Page getPage(){
        int current = ServletRequestUtils.getIntParameter(request,"current",1);
        int size = ServletRequestUtils.getIntParameter(request,"size",10);
        return new Page(current,size);
    }

    @PostMapping("order")
    public Result order(@RequestBody UserAppointment userAppointment){
        PlaceVdstate placeVdstate = placeVdstateService.getById(userAppointment.getPlaceStateId());
        char[] cs = placeVdstate.getVdstatest().toCharArray();
        if (cs[userAppointment.getOrderstart() - 8] == '2' || cs[userAppointment.getOrderstart() - 8] == '1'){
            return Result.error().message("预约失败");
        }
        cs[userAppointment.getOrderstart() - 8] = (char)(userAppointment.getRadio() + '0');
        placeVdstate.setVdstatest(new String(cs));
        boolean flag = placeVdstateService.updateById(placeVdstate);
        if (!flag){
            return Result.error().message("预约失败");
        }
        if (userAppointment.getRadio() == 2){
            UserAppointment appointment = userAppointmentService.getOne(new LambdaQueryWrapper<UserAppointment>().eq(UserAppointment::getUserid, userAppointment.getUserid())
                    .eq(UserAppointment::getOrderdate, userAppointment.getOrderdate()).eq(UserAppointment::getPlaceid, userAppointment.getPlaceid())
                    .eq(UserAppointment::getOrderstart, userAppointment.getOrderstart()).eq(UserAppointment::getOrderend, userAppointment.getOrderend()));
            userAppointment.setCreated(new Date());
            if (appointment == null){
                flag = userAppointmentService.save(userAppointment);
            }else{
                appointment.setStatus(0);
                flag = userAppointmentService.updateById(appointment);
            }
        }
        return flag ? Result.ok() : Result.error().message("预约失败");
    }

    @RequestMapping("getAppointmentOrderByUser/{userId}")
    public Result getAppointmentOrderByUser(@PathVariable("userId") Long userId){
        Page<UserAppointment> pageData = userAppointmentService.page(getPage(),new LambdaQueryWrapper<UserAppointment>().eq(UserAppointment::getUserid, userId).orderByDesc(UserAppointment::getCreated));
        for (int i = 0; i < pageData.getRecords().size(); i++) {
            UserAppointment appointment = pageData.getRecords().get(i);
            appointment.setPlaceName(sysPlaceService.getById(appointment.getPlaceid()).getPlace());
        }
        return Result.ok().data("pageData",pageData);
    }

    @PostMapping("cancel/{appointmentId}")
    public Result cancel(@PathVariable("appointmentId") Long appointmentId){
        UserAppointment appointment = userAppointmentService.getById(appointmentId);
        appointment.setStatus(1);
        PlaceVdstate vdstate = placeVdstateService.getOne(new LambdaQueryWrapper<PlaceVdstate>().eq(PlaceVdstate::getPlaceid, appointment.getPlaceid()).eq(PlaceVdstate::getVdstatedate, appointment.getOrderdate()));
        char[] cs = vdstate.getVdstatest().toCharArray();
        cs[appointment.getOrderstart() - 8] = '0';
        vdstate.setVdstatest(new String(cs));
        boolean flag = userAppointmentService.updateById(appointment) && placeVdstateService.updateById(vdstate);
        return flag ? Result.ok() : Result.error().message("取消预约失败");
    }
}

@RestController
@RequestMapping("/sys/user")
public class SysUserController {

    @Autowired
    private HttpServletRequest request;
    @Autowired
    private SysUserService sysUserService;
    @Autowired
    private SysRoleService sysRoleService;
    @Autowired
    private BCryptPasswordEncoder passwordEncoder;
    @Autowired
    private SysUserRoleService sysUserRoleService;

    private Page getPage(){
        int current = ServletRequestUtils.getIntParameter(request,"current",1);
        int size = ServletRequestUtils.getIntParameter(request,"size",10);
        return new Page(current,size);
    }

    @GetMapping("list")
    @PreAuthorize("hasAuthority('sys:user:list')")
    public Result list(String username){
        Page<SysUser> pageData = sysUserService.page(getPage(),new LambdaQueryWrapper<SysUser>().like(StrUtil.isNotBlank(username),SysUser::getUsername,username));
        pageData.getRecords().forEach(u -> {
            u.setSysRoles(sysRoleService.listRolesByUserId(u.getId()));
        });
        return Result.ok().data("pageData",pageData);
    }

    @GetMapping("info/{id}")
    @PreAuthorize("hasAuthority('sys:user:list')")
    public Result info(@PathVariable("id") Long id){
        SysUser user = sysUserService.getById(id);
        Assert.notNull(user,"找不到该管理员");
        List<SysRole> roleList = sysRoleService.listRolesByUserId(id);
        user.setSysRoles(roleList);
        return Result.ok().data("info",user);
    }

    @PostMapping("save")
    @PreAuthorize("hasAuthority('sys:user:save')")
    public Result save(@Validated @RequestBody SysUser sysUser){
        sysUser.setCreated(new Date());
        String password = passwordEncoder.encode(Const.DEFAULT_PASSWORD);
        sysUser.setPassword(password);
        sysUser.setAvatar(Const.DEFAULT_AVATAR);
        boolean flag = sysUserService.save(sysUser);
        return flag ? Result.ok() : Result.error();
    }

    @PostMapping("update")
    @PreAuthorize("hasAuthority('sys:user:update')")
    public Result update(@Validated @RequestBody SysUser sysUser){
        sysUser.setUpdated(new Date());
        boolean flag = sysUserService.updateById(sysUser);
        return flag ? Result.ok() : Result.error();
    }

    @Transactional
    @PostMapping("delete")
    @PreAuthorize("hasAuthority('sys:user:delete')")
    public Result delete(@RequestBody Long[] ids){
        sysUserService.removeByIds(Arrays.asList(ids));
        sysUserRoleService.remove(new LambdaQueryWrapper<SysUserRole>().in(SysUserRole::getUserId,ids));
        return Result.ok();
    }

    @Transactional
    @PostMapping("role/{userId}")
    @PreAuthorize("hasAuthority('sys:user:role')")
    public Result rolePerm(@PathVariable("userId") Long userId,@RequestBody Long[] roleIds){
        List<SysUserRole> userRoles = new ArrayList<>();
        Arrays.stream(roleIds).forEach(r -> {
            SysUserRole sysUserRole = new SysUserRole();
            sysUserRole.setRoleId(r);
            sysUserRole.setUserId(userId);
            userRoles.add(sysUserRole);
        });
        sysUserRoleService.remove(new LambdaQueryWrapper<SysUserRole>().eq(SysUserRole::getUserId,userId));
        sysUserRoleService.saveBatch(userRoles);
        sysUserService.clearUserAuthorityInfo(userId);
        return Result.ok();
    }

    @PostMapping("repass")
    @PreAuthorize("hasAuthority('sys:user:repass')")
    public Result repass(@RequestBody Long userId){
        SysUser user = sysUserService.getById(userId);
        user.setPassword(passwordEncoder.encode(Const.DEFAULT_PASSWORD));
        user.setUpdated(new Date());
        sysUserService.updateById(user);
        return Result.ok();
    }

    @PostMapping("updatePass")
    public Result updatePass(@Validated @RequestBody PassVo passVo, Principal principal){
        SysUser user = sysUserService.getByUsername(principal.getName());
        boolean matches = passwordEncoder.matches(passVo.getCurrentPass(), user.getPassword());
        if (!matches){
            return Result.error().message("旧密码不正确");
        }
        user.setPassword(passwordEncoder.encode(passVo.getCurrentPass()));
        user.setUpdated(new Date());
        sysUserService.updateById(user);
        return Result.ok();
    }
}