基于java+ssm+jsp的航班订票管理系统

项目介绍

互联网发展至今，无论是其理论还是技术都已经成熟，而且它广泛参与在社会中的方方面面。它让信息都可以通过网络传播，搭配信息管理工具可以很好地为人们提供服务。针对航班订票信息管理混乱，出错率高，信息安全性差，劳动强度大，费时费力等问题，采用航班订票管理系统可以有效管理，使信息管理能够更加科学和规范。

航班订票管理系统在idea环境中，使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理员管理飞机，管理用户，管理航班，管理新闻，回复用户留言，查看航班订单。用户查询航班，收藏航班，购买机票，查看航班订单以及新闻信息。

总之，航班订票管理系统集中管理信息，有着保密性强，效率高，存储空间大，成本低等诸多优点。它可以降低信息管理成本，实现信息管理计算机化。

4.2 功能结构设计
在前面分析的管理员功能的基础上，进行接下来的设计工作，最终展示设计的管理员结构图（见下图）。管理员管理飞机，管理用户，管理航班，管理新闻，回复用户留言，查看航班订单。

在前面分析的用户功能的基础上，进行接下来的设计工作，最终展示设计的用户结构图（见下图）。用户查询航班，收藏航班，购买机票，查看航班订单以及新闻信息。

开发环境

编程语言：Java
数据库 ：Mysql
系统架构：B/S
后端框架：SSM
编译工具：idea或者eclipse，jdk1.8，maven
支持定做：java/php/python/android/小程序ue/爬虫/c#/asp.net

系统实现

5.1 管理员功能实现
5.1.1 用户管理
管理员进入指定功能操作区之后可以管理用户。其页面见下图。管理员负责增删改查用户信息。用户信息包括了用户的手机号，用户的头像，用户的身份证号，用户姓名等资料。

图5.1 用户管理页面

5.1.2 航班管理
管理员进入指定功能操作区之后可以管理航班。其页面见下图。航班信息包括航班号，起飞时间，票价，飞机，始发站，目的地等信息，管理员在当前模块可以实现航班信息新增，航班信息的修改，管理员也能批量删除航班信息。

图5.2 航班管理页面

5.1.3 航班订单管理
管理员进入指定功能操作区之后可以管理航班订单信息。其页面见下图。管理员可以根据订单类型查询航班订单，可以根据目的地或者始发站查询航班订单，管理员点击查看按钮可以查看航班订单详情。

图5.3 航班订单管理页面

5.1.4 飞机管理
管理员进入指定功能操作区之后可以管理飞机信息。其页面见下图。管理员在当前页面可以新增飞机信息，修改飞机名称信息，可以删除指定飞机信息。

图5.4 飞机管理页面

5.2 用户功能实现
5.2.1 查询航班
用户进入指定功能操作区之后可以查询航班。其页面见下图。用户查询航班可以根据票价查询，根据航班号查询，可以根据目的地和始发站查询。

图5.5 查询航班页面

5.2.2 航班信息
用户进入指定功能操作区之后可以查看航班信息。其页面见下图。用户在当前页面可以收藏航班，对该航班进行留言，或者购买该航班的机票。

图5.6 航班信息页面

5.2.3 提交订单
用户进入指定功能操作区之后可以对要购买的航班提交订单。其页面见下图。用户核对订票信息，设置订票日期即可提交订单。

图5.7 提交订单页面

5.2.4 新闻信息
用户进入指定功能操作区之后可以查看新闻信息。其页面见下图。用户搜索新闻，点击新闻图片或标题即可查看新闻详细内容。

图5.8 新闻信息页面

核心代码

package com.controller;


import java.text.SimpleDateFormat;
import com.alibaba.fastjson.JSONObject;
import java.util.*;
import org.springframework.beans.BeanUtils;
import javax.servlet.http.HttpServletRequest;
import org.springframework.web.context.ContextLoader;
import javax.servlet.ServletContext;
import com.service.TokenService;
import com.utils.StringUtil;
import java.lang.reflect.InvocationTargetException;

import com.service.DictionaryService;
import org.apache.commons.lang3.StringUtils;
import com.annotation.IgnoreAuth;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;

import com.entity.FeijiEntity;

import com.service.FeijiService;
import com.entity.view.FeijiView;

import com.utils.PageUtils;
import com.utils.R;

/**
 * 航班
 * 后端接口
 * @author
 * @email
 * @date 
*/
@RestController
@Controller
@RequestMapping("/feiji")
public class FeijiController {
    private static final Logger logger = LoggerFactory.getLogger(FeijiController.class);

    @Autowired
    private FeijiService feijiService;


    @Autowired
    private TokenService tokenService;
    @Autowired
    private DictionaryService dictionaryService;



    //级联表service


    /**
    * 后端列表
    */
    @RequestMapping("/page")
    public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
        logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
     
        String role = String.valueOf(request.getSession().getAttribute("role"));
        if(StringUtil.isNotEmpty(role) && "用户".equals(role)){
            params.put("yonghuId",request.getSession().getAttribute("userId"));
        }
        params.put("orderBy","id");
        PageUtils page = feijiService.queryPage(params);

        //字典表数据转换
        List<FeijiView> list =(List<FeijiView>)page.getList();
        for(FeijiView c:list){
            //修改对应字典表字段
            dictionaryService.dictionaryConvert(c);
        }
        return R.ok().put("data", page);
    }

    /**
    * 后端详情
    */
    @RequestMapping("/info/{id}")
    public R info(@PathVariable("id") Long id){
        logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
        FeijiEntity feiji = feijiService.selectById(id);
        if(feiji !=null){
            //entity转view
            FeijiView view = new FeijiView();
            BeanUtils.copyProperties( feiji , view );//把实体数据重构到view中

            //修改对应字典表字段
            dictionaryService.dictionaryConvert(view);
            return R.ok().put("data", view);
        }else {
            return R.error(511,"查不到数据");
        }

    }

    /**
    * 后端保存
    */
    @RequestMapping("ve")
    public R save(@RequestBody FeijiEntity feiji, HttpServletRequest request){
        logger.debug("save方法:,,Controller:{},,feiji:{}",this.getClass().getName(),feiji.toString());
        Wrapper<FeijiEntity> queryWrapper = new EntityWrapper<FeijiEntity>()
            .eq("feiji_name", feiji.getFeijiName())
            .eq("feiji_types", feiji.getFeijiTypes())
            .eq("feiji_leixing_types", feiji.getFeijiLeixingTypes())
            .eq("feiji_start_time", feiji.getFeijiStartTime())
            .eq("feiji_start_address", feiji.getFeijiStartAddress())
            .eq("feiji_end_address", feiji.getFeijiEndAddress())
            ;
        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        FeijiEntity feijiEntity = feijiService.selectOne(queryWrapper);
        if(feijiEntity==null){
            feiji.setCreateTime(new Date());
        //  String role = String.valueOf(request.getSession().getAttribute("role"));
        //  if("".equals(role)){
        //      feiji.set
        //  }
            feijiService.insert(feiji);
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }

    /**
    * 后端修改
    */
    @RequestMapping("/update")
    public R update(@RequestBody FeijiEntity feiji, HttpServletRequest request){
        logger.debug("update方法:,,Controller:{},,feiji:{}",this.getClass().getName(),feiji.toString());
        //根据字段查询是否有相同数据
        Wrapper<FeijiEntity> queryWrapper = new EntityWrapper<FeijiEntity>()
            .notIn("id",feiji.getId())
            .andNew()
            .eq("feiji_name", feiji.getFeijiName())
            .eq("feiji_types", feiji.getFeijiTypes())
            .eq("feiji_leixing_types", feiji.getFeijiLeixingTypes())
            .eq("feiji_start_time", feiji.getFeijiStartTime())
            .eq("feiji_start_address", feiji.getFeijiStartAddress())
            .eq("feiji_end_address", feiji.getFeijiEndAddress())
            ;
        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        FeijiEntity feijiEntity = feijiService.selectOne(queryWrapper);
        if("".equals(feiji.getFeijiPhoto()) || "null".equals(feiji.getFeijiPhoto())){
                feiji.setFeijiPhoto(null);
        }
        if(feijiEntity==null){
            //  String role = String.valueOf(request.getSession().getAttribute("role"));
            //  if("".equals(role)){
            //      feiji.set
            //  }
            feijiService.updateById(feiji);//根据id更新
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }



    /**
    * 删除
    */
    @RequestMapping("/delete")
    public R delete(@RequestBody Integer[] ids){
        logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
        feijiService.deleteBatchIds(Arrays.asList(ids));
        return R.ok();
    }



    /**
    * 前端列表
    */
    @RequestMapping("st")
    public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){
        logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
        String role = String.valueOf(request.getSession().getAttribute("role"));
        if(StringUtil.isNotEmpty(role) && "用户".equals(role)){
            params.put("yonghuId",request.getSession().getAttribute("userId"));
        }
        // 没有指定排序字段就默认id倒序
        if(StringUtil.isEmpty(String.valueOf(params.get("orderBy")))){
            params.put("orderBy","id");
        }
        PageUtils page = feijiService.queryPage(params);

        //字典表数据转换
        List<FeijiView> list =(List<FeijiView>)page.getList();
        for(FeijiView c:list){
            //修改对应字典表字段
            dictionaryService.dictionaryConvert(c);
        }
        return R.ok().put("data", page);
    }

    /**
    * 前端详情
    */
    @RequestMapping("/detail/{id}")
    public R detail(@PathVariable("id") Long id){
        logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
        FeijiEntity feiji = feijiService.selectById(id);
            if(feiji !=null){
                //entity转view
        FeijiView view = new FeijiView();
                BeanUtils.copyProperties( feiji , view );//把实体数据重构到view中

                //修改对应字典表字段
                dictionaryService.dictionaryConvert(view);
                return R.ok().put("data", view);
            }else {
                return R.error(511,"查不到数据");
            }
    }


    /**
    * 前端保存
    */
    @RequestMapping("/add")
    public R add(@RequestBody FeijiEntity feiji, HttpServletRequest request){
        logger.debug("add方法:,,Controller:{},,feiji:{}",this.getClass().getName(),feiji.toString());
        Wrapper<FeijiEntity> queryWrapper = new EntityWrapper<FeijiEntity>()
            .eq("feiji_name", feiji.getFeijiName())
            .eq("feiji_types", feiji.getFeijiTypes())
            .eq("feiji_leixing_types", feiji.getFeijiLeixingTypes())
            .eq("feiji_start_time", feiji.getFeijiStartTime())
            .eq("feiji_start_address", feiji.getFeijiStartAddress())
            .eq("feiji_end_address", feiji.getFeijiEndAddress())
            ;
        logger.info("sql语句:"+queryWrapper.getSqlSegment());
    FeijiEntity feijiEntity = feijiService.selectOne(queryWrapper);
        if(feijiEntity==null){
            feiji.setCreateTime(new Date());
        //  String role = String.valueOf(request.getSession().getAttribute("role"));
        //  if("".equals(role)){
        //      feiji.set
        //  }
        feijiService.insert(feiji);
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }




}

论文参考

目 录
第1章 绪论 1
1.1 课题背景 1
1.2 课题意义 1
1.3 研究内容 2
第2章 开发环境与技术 3
2.1 MYSQL数据库 3
2.2 JSP技术 3
2.3 SSM框架 4
第3章 系统分析 5
3.1 可行性分析 5
3.1.1 技术可行性 5
3.1.2 经济可行性 5
3.1.3 操作可行性 5
3.2 系统流程 6
3.2.1 操作流程 6
3.2.2 登录流程 6
3.2.3 删除信息流程 7
3.2.4 添加信息流程 8
3.3 性能需求 8
3.4 功能需求 9
第4章 系统设计 12
4.1 设计原则 12
4.2 功能结构设计 13
4.3 数据库设计 14
4.3.1 数据库概念设计 14
4.3.2 数据库物理设计 17
第5章 系统实现 20
5.1 管理员功能实现 20
5.1.1 用户管理 20
5.1.2 航班管理 20
5.1.3 航班订单管理 21
5.1.4 飞机管理 21
5.2 用户功能实现 22
5.2.1 查询航班 22
5.2.2 航班信息 23
5.2.3 提交订单 23
5.2.4 新闻信息 24
第6章 系统测试 25
6.1 测试的任务  25
6.2 测试的目标  25
6.3 测试方案  26
6.4 功能测试 27
6.4.1 登录功能测试 28
6.4.2 修改密码功能测试 28
6.5 测试结果 29
结 论 30
致 谢 31
参考文献 32