旅游管理系统

语言:Java 数据库:MySQL

技术栈: Springboot+Vue+ElementUI+Mybatis

系统角色 : 管理员、用户

管理员 : 账号管理、地区管理、景点信息管理、地方美食管理、旅游线路管理、订单信息管理、新闻管理、系统管理

用户 : 旅游新闻、景区信息、美食信息、旅游线路、在线留言、旅游线路、订单信息

获取完整项目

https://pan.baidu.com/s/1IhIyql9TSTQhN7BCGILuQQ?pwd=s6nq

项目合集

https://pan.baidu.com/s/1K2f-s3A_MVdfIA9393cYWg?pwd=gut6 提取码: gut6

有问题，或者需要协助调试运行项目的也可以

一、项目文档

二、项目页面展示

三、部分代码

package com.spring.controller;

import com.spring.dao.AdminsMapper;
import com.spring.entity.Admins;
import com.spring.service.AdminsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import tk.mybatis.mapper.entity.Example;
import util.Request;
import util.Info;
import dao.Query;
import java.util.*;
import dao.CommDAO;


/**
 * 管理员 */
@Controller
public class AdminsController extends BaseController
{
    @Autowired
    private AdminsMapper dao;
    @Autowired
    private AdminsService service;

    /**
     *  后台列表页
     *
     */
    @RequestMapping("/admins_list")
    public String list()
    {

        // 检测是否有登录，没登录则跳转到登录页面
        if(!checkLogin()){
            return showError("尚未登录" , "./login.do");
        }

        String order = Request.get("order" , "id"); // 获取前台提交的URL参数 order  如果没有则设置为id
        String sort  = Request.get("sort" , "desc"); // 获取前台提交的URL参数 sort  如果没有则设置为desc
        int    pagesize = Request.getInt("pagesize" , 12); // 获取前台一页多少行数据
        Example example = new Example(Admins.class); //  创建一个扩展搜索类
        Example.Criteria criteria = example.createCriteria();          // 创建一个扩展搜索条件类
        String where = " 1=1 ";   // 创建初始条件为：1=1
        where += getWhere();      // 从方法中获取url 上的参数，并写成 sql条件语句
        criteria.andCondition(where);   // 将条件写进上面的扩展条件类中
        if(sort.equals("desc")){        // 判断前台提交的sort 参数是否等于  desc倒序  是则使用倒序，否则使用正序
            example.orderBy(order).desc();  // 把sql 语句设置成倒序
        }else{
            example.orderBy(order).asc();   // 把 sql 设置成正序
        }
        int page = request.getParameter("page") == null ? 1 : Integer.valueOf(request.getParameter("page"));  // 获取前台提交的URL参数 page  如果没有则设置为1
        page = Math.max(1 , page);  // 取两个数的最大值，防止page 小于1
        List<Admins> list = service.selectPageExample(example , page , pagesize);   // 获取当前页的行数


        
        // 将列表写给界面使用
        assign("totalCount" , request.getAttribute("totalCount"));
        assign("list" , list);
        assign("orderby" , order);  // 把当前排序结果写进前台
        assign("sort" , sort);      // 把当前排序结果写进前台
        return json();   // 将数据写给前端
    }

    public String getWhere()
    {
        _var = new LinkedHashMap(); // 重置数据
        String where = " ";
        // 以下也是一样的操作，判断是否符合条件，符合则写入sql 语句
            if(!Request.get("username").equals("")) {
            where += " AND username LIKE '%"+Request.get("username")+"%' ";
        }
            return where;
    }





        @RequestMapping("/admins_add")
    public String add()
    {
        _var = new LinkedHashMap(); // 重置数据

        
        return json();   // 将数据写给前端
    }

    @RequestMapping("/admins_updt")
    public String updt()
    {
        _var = new LinkedHashMap(); // 重置数据
        int id = Request.getInt("id");
        // 获取行数据，并赋值给前台jsp页面
        Admins mmm = service.find(id);
        assign("mmm" , mmm);
        assign("updtself" , 0);

        
        return json();   // 将数据写给前端
    }
    @RequestMapping("/admins_updtself")
    public String updtself()
    {
        _var = new LinkedHashMap(); // 重置数据
        // 更新个人资料
        int id = (int)request.getSession().getAttribute("id");
        Admins mmm = service.find(id);
        assign("mmm" , mmm);
        assign("updtself" , 1);
            return json();   // 将数据写给前端
    }
    /**
     * 添加内容
     * @return
     */
    @RequestMapping("/adminsinsert")
    public String insert()
    {
        _var = new LinkedHashMap(); // 重置数据
        String tmp="";
        Admins post = new Admins();  // 创建实体类
        // 设置前台提交上来的数据到实体类中
        post.setUsername(Request.get("username"));

        post.setPwd(Request.get("pwd"));

        post.setAddtime(Info.getDateStr());
    

        

                service.insert(post); // 插入数据
        int charuid = post.getId().intValue();
        

        if(isAjax()){
            return jsonResult(post);

        }
        return showSuccess("保存成功" , Request.get("referer").equals("") ? request.getHeader("referer") : Request.get("referer"));
    }

    /**
    * 更新内容
    * @return
    */
    @RequestMapping("/adminsupdate")
    public String update()
    {
        _var = new LinkedHashMap(); // 重置数据
        // 创建实体类
        Admins post = new Admins();
        // 将前台表单数据填充到实体类
        if(!Request.get("username").equals(""))
        post.setUsername(Request.get("username"));
                if(!Request.get("pwd").equals(""))
        post.setPwd(Request.get("pwd"));
                if(!Request.get("addtime").equals(""))
        post.setAddtime(Request.get("addtime"));
        
        post.setId(Request.getInt("id"));
                service.update(post); // 更新数据
        int charuid = post.getId().intValue();
        
        if(isAjax()){
            return jsonResult(post);
        }
                if(Request.getInt("updtself") == 1){
            return showSuccess("保存成功" , "admins_updtself.do");
        }
        
        return showSuccess("保存成功" , Request.get("referer")); // 弹出保存成功，并跳转到前台提交的 referer 页面
    }
        /**
    *  删除
    */
    @RequestMapping("/admins_delete")
    public String delete()
    {
        _var = new LinkedHashMap(); // 重置数据
        if(!checkLogin()){
            return showError("尚未登录");
        }
        int id = Request.getInt("id");  // 根据id 删除某行数据
        HashMap map = Query.make("admins").find(id);

                service.delete(id);// 根据id 删除某行数据
                return showSuccess("删除成功",request.getHeader("referer"));//弹出删除成功，并跳回上一页
    }
}

package com.spring.controller;



import com.alibaba.fastjson.JSON;
import com.spring.util.JsonResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Enumeration;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * 控制器基类
 */
abstract public class BaseController {
    @Autowired
    protected HttpServletRequest request; // 注入
    @Autowired
    protected HttpServletResponse response; // 注入
    @Autowired
    protected HttpSession session; // 注入

    protected ModelAndView mView;

    protected Map<Object,Object> _var;

    /**
     * 控制器
     */
    public BaseController()
    {
        //request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        //response = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
        mView = new ModelAndView();
        _var = new LinkedHashMap();
    }



    /**
     * 往模板中写入数据
     * @param name
     * @param value
     */
    protected void assign(String name , Object value)
    {
        request.setAttribute(name , value);
        _var.put(name , value);
    }

    /**
     * 弹出框
     * @param message
     * @param code
     * @param jumpUrl
     * @param jumpTime
     * @return
     */
    protected String showMessage( String message , int code , Object data , String jumpUrl , int jumpTime)
    {
        if(isAjax())
        {
            JsonResult jsonResult = new JsonResult(code , message , data);
            return renderString(response , JSON.toJSONString(jsonResult));
        }

        assign("message" , message == null ? data : message);
        assign("code" , code);
        assign("jumpUrl" , jumpUrl);
        assign("jumpTime" , jumpTime);

        return "message";
    }

    /**
     * 将写入json写到前端
     * @return
     */
    public String json()
    {
        return jsonResult(_var);
    }

    public String jsonReturn(String message , int code , Object data)
    {
        JsonResult result = new JsonResult(code , message , data);
        return renderString(response , JSON.toJSONString(result));
    }

    public String jsonResult(Object data)
    {
        return jsonReturn(null , 0 , data);
    }

    public String jsonError(String msg)
    {
        return jsonReturn(msg , 1 , null);
    }

    public Object getRequestAttributeMap()
    {
        //Map<Object,Object> map = new LinkedHashMap();
        Enumeration<String> names = request.getAttributeNames();

        while (names.hasMoreElements())
        {
            String key = names.nextElement();
            if(!_var.containsKey(key)){
                // 没有，则写入
                _var.put(key , request.getAttribute(key));
            }
        }
        return _var;
    }

    public String getJson()
    {
        Map<Object,Object> map = new LinkedHashMap();
        Enumeration<String> names = request.getAttributeNames();

        while (names.hasMoreElements())
        {
            String key = names.nextElement();
            Object value = request.getAttribute(key);
            map.put(key , value);
        }
        return renderString(response , JSON.toJSONString(map));
    }


    /**
     * 将字符串渲染到客户端
     *
     * @param response 渲染对象
     * @param string 待渲染的字符串
     * @return null
     */
    public String renderString(HttpServletResponse response, String string)
    {
        try
        {
            request.getSession();
            OutputStream stream = response.getOutputStream();
            response.setContentType("application/json");
            response.setCharacterEncoding("utf-8");
            stream.write(string.getBytes());
            stream.flush();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        return "success";
    }

    protected boolean isAjax()
    {
        String accept = request.getHeader("accept");
        if (accept != null && accept.indexOf("application/json") != -1)
        {
            return true;
        }

        String xRequestedWith = request.getHeader("X-Requested-With");
        if (xRequestedWith != null && xRequestedWith.indexOf("XMLHttpRequest") != -1)
        {
            return true;
        }

        String ajax = request.getParameter("format");
        if ("json".equalsIgnoreCase(ajax))
        {
            return true;
        }
        return false;
    }

    /**
     * 检测是否登录
     * @return
     */
    protected boolean checkLogin()
    {
        if(request.getSession().getAttribute("username") == null || "".equals(request.getSession().getAttribute("username")))
        {
            return false;
        }
        return true;
    }

    /**
     * 弹出错误信息
     * @param message
     * @return
     */
    protected String showError(String message)
    {
        return showMessage(message , 1 ,null, "javascript:history(-1);" , 2250);
    }

    /**
     *  弹出错误信息
     * @param message
     * @param code
     * @return
     */
    protected String showError(String message , int code)
    {
        return showMessage(message , code , null,"javascript:history(-1);" , 2250);
    }

    /**
     * 弹出错误信息
     * @param message
     * @param url
     * @return
     */
    protected String showError(String message , String url)
    {
        return showMessage(message , 1 ,null, url , 2250);
    }

    /**
     * 弹出成功信息
     * @param data
     * @return
     */
    protected String showSuccess(Object data )
    {
        return showMessage(null , 0 ,data, request.getHeader("referer") , 2250);
    }




    /**
     * 弹出成功信息
     * @param data
     * @param url
     * @return
     */
    protected String showSuccess(String data , String url)
    {
        return showMessage(null , 0 ,data, url , 2250);
    }


}

package com.spring.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import util.DESUtil;

import javax.imageio.ImageIO;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpSession;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.util.Base64;
import java.util.Random;

/**
 * 验证码控制器
 */
@Controller
public class CaptchaController extends BaseController {
    /**
     * 输出验证码图片,并记录session “random” 里等待登录时写入
     */
    @RequestMapping("/captcha")
    public String Index()
    {
        // 把验证码字符串写入session 中，保存待下次验证时使用
        String sRand = createRandomString(4);

        try {
            // 输出渲染好的内容到前端浏览器
            if(isAjax()){
                String result = null;
                do {
                    try{
                        result = DESUtil.encrypt("CaptchControllerPassword",sRand);
                    }catch (Exception e){
                        result = null;
                    }
                    if(result!= null){
                        if(!sRand.equals(DESUtil.decrypt("CaptchControllerPassword" , result))){
                            result = null; // 解不出来所以出错
                        }
                    }
                }while (result == null);

                assign("url" , "/randtocaptch?captchToken="+  urlencode(result));
                assign("token" , result);
                return json();
            }else{
                //byte[] img = xxx;
                response.setContentType("image/jpeg"); // 定义输出类型为 图片
                response.setHeader("Pragma","No-cache");   // 设置为无缓存
                response.setHeader("Cache-Control","no-cache");  // 设置为无缓存
                response.setDateHeader("Expires", 0);  // 设置缓存时间为0秒后过期
                request.getSession().setAttribute("random",sRand);
                ServletOutputStream stream = response.getOutputStream();
                createCaptch(sRand,stream);
                stream.flush();
                stream.close();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return "success";
    }


    /**
     * url 编码，中文要进行编码输出
     * @param str
     * @return
     */
    public static String urlencode(Object str)
    {
        try{
            return java.net.URLEncoder.encode(String.valueOf(str), "UTF-8");
        }catch (Exception e){
            e.printStackTrace();
        }
        return str.toString();
    }

    /**
     * 使用上面的加密字符串生成验证码
     * @return
     */
    @RequestMapping("/randtocaptch")
    public String getCaptch() throws IOException {
        String captchToken = request.getParameter("captchToken");
        String sRand = DESUtil.decrypt("CaptchControllerPassword" , captchToken);
        HttpSession session = request.getSession();
        {
            //byte[] img = xxx;
            response.setContentType("image/jpeg"); // 定义输出类型为 图片
            response.setHeader("Pragma","No-cache");   // 设置为无缓存
            response.setHeader("Cache-Control","no-cache");  // 设置为无缓存
            response.setDateHeader("Expires", 0);  // 设置缓存时间为0秒后过期
            ServletOutputStream stream = response.getOutputStream();
            createCaptch(sRand,stream);
            stream.flush();
            stream.close();
        }
        return "success";
    }


    private String createRandomString(int len)
    {
        // 生成随机数类
        Random random = new Random();
        String result = "";
        for (int i=0;i<len;i++){
            String rand = String.valueOf(random.nextInt(10));
            result += rand;
        }
        return result;
    }

    private void createCaptch(String randomstr , OutputStream stream)
    {
        int width=60, height=20;   // 定义图片宽为 60  高度为 20

        // 创建图片缓冲区
        BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

        // 获取渲染画板
        Graphics g = image.getGraphics();

        // 生成随机数类
        Random random = new Random();

        // 设置颜色
        g.setColor(getRandColor(200,250));

        // 绘制矩形
        g.fillRect(0, 0, width, height);

        // 设置字体信息
        g.setFont(new Font("Times New Roman",Font.PLAIN,18));

        // 设置颜色信息
        g.setColor(getRandColor(160,200));

        // 写入干扰线
        for (int i=0;i<155;i++)
        {
            int x = random.nextInt(width);
            int y = random.nextInt(height);
            int xl = random.nextInt(12);
            int yl = random.nextInt(12);
            g.drawLine(x,y,x+xl,y+yl);
        }

        // 写入验证码字符串
        for (int i=0;i<randomstr.length();i++){
            String rand = randomstr.substring(i,i+1); //String.valueOf(random.nextInt(10));

            g.setColor(new Color(20+random.nextInt(110),20+random.nextInt(110),20+random.nextInt(110)));
            g.drawString(rand,13*i+6,16);
        }
        g.dispose();  // 释放画板

        try {
            // 输出渲染好的内容到前端浏览器

            ImageIO.write(image, "JPEG", stream);
            stream.flush();
            stream.close();

        }catch (Exception e){
            e.printStackTrace();
        }


    }




    /**
     * 获取随机颜色
     * @param fc
     * @param bc
     * @return
     */
    protected Color getRandColor(int fc, int bc)
    {
        Random random = new Random();
        if(fc>255) fc=255;
        if(bc>255) bc=255;
        int r=fc+random.nextInt(bc-fc);
        int g=fc+random.nextInt(bc-fc);
        int b=fc+random.nextInt(bc-fc);
        return new Color(r,g,b);
    }
}

package com.spring.controller;

import dao.CommDAO;
import net.jntoo.db.Query;
import com.alibaba.fastjson.*;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import util.Request;

import java.util.List;
import java.util.Map;

/**
 * 公共路由
 */
@Controller
public class CommonController extends BaseController{

    /**
     * 使用ajax 检测某表中某个字段是否已存在，已存在则无法提交
     * @return
     */
    @RequestMapping(value = "/checkno")
    @ResponseBody
    public String checkon()
    {
        String table = request.getParameter("table");
        String col   = request.getParameter("col");
        String checktype = request.getParameter("checktype");
        String value = request.getParameter(col);
        if(checktype.equals("insert")){
            if(Query.make(table).where(col , value).count() > 0){
                return "false";
            }else{
                return "true";
            }
        }else if(checktype.equals("update")){
            String id = request.getParameter("id") == null ? "" : request.getParameter("id");
            if(Query.make(table).where(col , value).where("id" , "neq" , id).count() > 0){
                return "false";
            }else{
                return "true";
            }
        }
        return "false";
    }

    /**
     * 审核数据，将是否审核改为已审核状态，点击一下 是 则变否， 点击一下 否 变为是
     * @return
     */
    @RequestMapping("/sh")
    @ResponseBody
    public String sh()
    {
        String yuan=request.getParameter("yuan");
        String id=request.getParameter("id");
        String tablename=request.getParameter("tablename");
        String sql="";
        if(yuan.equals("是"))
        {
            sql="update "+tablename+" set issh='否' where id="+id;
        }
        else
        {
            sql="update "+tablename+" set issh='是' where id="+id;
        }
        new CommDAO().commOper(sql);
        if(isAjax())
        {
            jsonResult("ok");
            return "";
        }
        return "<script>location.href='"+request.getHeader("Referer")+"';</script>";
    }

    /**
     * 获取表的某行数据
     * @return
     */
    @RequestMapping("/tableAjax")
    @ResponseBody
    public String tableFind()
    {
        String table = request.getParameter("table");
        String id = request.getParameter("id");
        Map map = Query.make(table).where("id" , id).find();
        //JSONObject json = JSONObject.parse(map);
        return JSON.toJSONString(map);//.toString();
    }

    /**
     *   获取某表得某行数据
     *
     */
    @RequestMapping("/selectView")
    public String selectView()
    {
        String key = request.getParameter("key");
        String table = request.getParameter("table");
        String value = request.getParameter("value");
        Map data = Query.make(table).where(key,value).find();
        return jsonResult(data);
    }

    /**
     *   获取某表得所有数据
     *
     */
    @RequestMapping("/selectAll")
    public String selectAll()
    {
        String table = request.getParameter("table");
        Query query = Query.make(table);
        if(request.getParameter("where") != null){
            JSONObject where = JSON.parseObject(Request.get("where"));
            for(Map.Entry entry:where.entrySet())
            {
                String key = (String)entry.getKey();
                Object value = entry.getValue();
                if(value instanceof JSONObject)
                {
                    JSONObject w = (JSONObject) value;
                    query.where(key , w.getString("exp") , w.getString("value"));
                }else if(value instanceof JSONArray){
                    JSONArray  w = (JSONArray) value;
                    query.where(key , (String) w.get(0) , w.get(1));
                }else{
                    query.where(key , value);
                }
            }
        }
        if(request.getParameter("limit")!=null)
        {
            query.limit(Request.get("limit"));
        }
        if(request.getParameter("order")!=null)
        {
            query.order(Request.get("order"));
        }
        if(request.getParameter("field")!=null)
        {
            query.field(Request.get("field"));
        }
        List list = query.select();
        return jsonResult(list);
    }

    /**
     * 搜索下拉某表的数据
     * @return
     */
    @RequestMapping("/selectUpdateSearch")
    @ResponseBody
    public String selectUpdateSearch()
    {
        String table = Request.get("table");
        Query query = Query.make(table);
        String limit = "50";
        JSONObject where = JSON.parseObject(Request.get("where"));
        for(Map.Entry entry:where.entrySet())
        {
            String key = (String)entry.getKey();
            Object value = entry.getValue();
            if("limit".equals(key)){
                limit = String.valueOf(value);
            }else{
                if(value instanceof JSONObject)
                {
                    JSONObject w = (JSONObject) value;
                    query.where(key , w.getString("exp") , w.getString("value"));
                }else if(value instanceof JSONArray){
                    JSONArray  w = (JSONArray) value;
                    query.where(key , (String) w.get(0) , w.get(1));
                }else{
                    query.where(key , value);
                }
            }
        }
        List list = query.order("id desc").limit(limit).select();
        return JSON.toJSONString(list);
    }

}

package com.spring.controller;

import com.spring.dao.JingdianxinxiMapper;
import com.spring.entity.Jingdianxinxi;
import com.spring.service.JingdianxinxiService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import tk.mybatis.mapper.entity.Example;
import util.Request;
import util.Info;
import dao.Query;
import java.util.*;
import dao.CommDAO;


/**
 * 景点信息 */
@Controller
public class JingdianxinxiController extends BaseController
{
    @Autowired
    private JingdianxinxiMapper dao;
    @Autowired
    private JingdianxinxiService service;

    /**
     *  后台列表页
     *
     */
    @RequestMapping("/jingdianxinxi_list")
    public String list()
    {

        // 检测是否有登录，没登录则跳转到登录页面
        if(!checkLogin()){
            return showError("尚未登录" , "./login.do");
        }

        String order = Request.get("order" , "id"); // 获取前台提交的URL参数 order  如果没有则设置为id
        String sort  = Request.get("sort" , "desc"); // 获取前台提交的URL参数 sort  如果没有则设置为desc
        int    pagesize = Request.getInt("pagesize" , 12); // 获取前台一页多少行数据
        Example example = new Example(Jingdianxinxi.class); //  创建一个扩展搜索类
        Example.Criteria criteria = example.createCriteria();          // 创建一个扩展搜索条件类
        String where = " 1=1 ";   // 创建初始条件为：1=1
        where += getWhere();      // 从方法中获取url 上的参数，并写成 sql条件语句
        criteria.andCondition(where);   // 将条件写进上面的扩展条件类中
        if(sort.equals("desc")){        // 判断前台提交的sort 参数是否等于  desc倒序  是则使用倒序，否则使用正序
            example.orderBy(order).desc();  // 把sql 语句设置成倒序
        }else{
            example.orderBy(order).asc();   // 把 sql 设置成正序
        }
        int page = request.getParameter("page") == null ? 1 : Integer.valueOf(request.getParameter("page"));  // 获取前台提交的URL参数 page  如果没有则设置为1
        page = Math.max(1 , page);  // 取两个数的最大值，防止page 小于1
        List<Jingdianxinxi> list = service.selectPageExample(example , page , pagesize);   // 获取当前页的行数


                    assign("diquList" , new CommDAO().select("SELECT * FROM diqu ORDER BY id desc"));
        // 将列表写给界面使用
        assign("totalCount" , request.getAttribute("totalCount"));
        assign("list" , list);
        assign("orderby" , order);  // 把当前排序结果写进前台
        assign("sort" , sort);      // 把当前排序结果写进前台
        return json();   // 将数据写给前端
    }

    public String getWhere()
    {
        _var = new LinkedHashMap(); // 重置数据
        String where = " ";
        // 以下也是一样的操作，判断是否符合条件，符合则写入sql 语句
            if(!Request.get("jingdianbianhao").equals("")) {
            where += " AND jingdianbianhao LIKE '%"+Request.get("jingdianbianhao")+"%' ";
        }
                if(!Request.get("jingdianmingcheng").equals("")) {
            where += " AND jingdianmingcheng LIKE '%"+Request.get("jingdianmingcheng")+"%' ";
        }
                if(!Request.get("suoshudiqu").equals("")) {
            where += " AND suoshudiqu ='"+Request.get("suoshudiqu")+"' ";
        }
            return where;
    }


    /**
    *  前台列表页
    *
    */
    @RequestMapping("/jingdianxinxilist")
    public String index()
    {
            String order = Request.get("order" , "id");
        String sort  = Request.get("sort" , "desc");

        Example example = new Example(Jingdianxinxi.class);
        Example.Criteria criteria = example.createCriteria();
        String where = " 1=1 ";
                where += getWhere();
        criteria.andCondition(where);
        if(sort.equals("desc")){
            example.orderBy(order).desc();
        }else{
            example.orderBy(order).asc();
        }
        int page = request.getParameter("page") == null ? 1 : Integer.valueOf(request.getParameter("page"));
        page = Math.max(1 , page);
                    List<Jingdianxinxi> list = service.selectPageExample(example , page , 12);
            
                assign("mapdiqu4" , new CommDAO().select("SELECT id,diqumingcheng FROM diqu"));        assign("totalCount" , request.getAttribute("totalCount"));
        assign("list" , list);
        assign("where" , where);
        assign("orderby" , order);
        assign("sort" , sort);
        return json();
    }



        @RequestMapping("/jingdianxinxi_add")
    public String add()
    {
        _var = new LinkedHashMap(); // 重置数据

                    assign("diquList" , new CommDAO().select("SELECT * FROM diqu ORDER BY id desc"));
            assign("difangmeishiList" , new CommDAO().select("SELECT * FROM difangmeishi ORDER BY id desc"));
        return json();   // 将数据写给前端
    }

    @RequestMapping("/jingdianxinxi_updt")
    public String updt()
    {
        _var = new LinkedHashMap(); // 重置数据
        int id = Request.getInt("id");
        // 获取行数据，并赋值给前台jsp页面
        Jingdianxinxi mmm = service.find(id);
        assign("mmm" , mmm);
        assign("updtself" , 0);

                    assign("diquList" , new CommDAO().select("SELECT * FROM diqu ORDER BY id desc"));
            assign("difangmeishiList" , new CommDAO().select("SELECT * FROM difangmeishi ORDER BY id desc"));
        return json();   // 将数据写给前端
    }
    /**
     * 添加内容
     * @return
     */
    @RequestMapping("/jingdianxinxiinsert")
    public String insert()
    {
        _var = new LinkedHashMap(); // 重置数据
        String tmp="";
        Jingdianxinxi post = new Jingdianxinxi();  // 创建实体类
        // 设置前台提交上来的数据到实体类中
        post.setJingdianbianhao(Request.get("jingdianbianhao"));

        post.setJingdianmingcheng(Request.get("jingdianmingcheng"));

        post.setSuoshudiqu(Request.get("suoshudiqu"));

        post.setTupian(Request.get("tupian"));

        post.setKaifangshijian(Request.get("kaifangshijian"));

        post.setFujinmeishi(Request.get("fujinmeishi"));

        post.setDizhi(Request.get("dizhi"));

        post.setPiaojia(Request.getDouble("piaojia"));

        post.setLiulanliang(Request.getInt("liulanliang"));

        post.setMiaoshu(util.DownloadRemoteImage.run(Request.get("miaoshu")));

        post.setAddtime(Info.getDateStr());
    

        

                service.insert(post); // 插入数据
        int charuid = post.getId().intValue();
        

        if(isAjax()){
            return jsonResult(post);

        }
        return showSuccess("保存成功" , Request.get("referer").equals("") ? request.getHeader("referer") : Request.get("referer"));
    }

    /**
    * 更新内容
    * @return
    */
    @RequestMapping("/jingdianxinxiupdate")
    public String update()
    {
        _var = new LinkedHashMap(); // 重置数据
        // 创建实体类
        Jingdianxinxi post = new Jingdianxinxi();
        // 将前台表单数据填充到实体类
        if(!Request.get("jingdianbianhao").equals(""))
        post.setJingdianbianhao(Request.get("jingdianbianhao"));
                if(!Request.get("jingdianmingcheng").equals(""))
        post.setJingdianmingcheng(Request.get("jingdianmingcheng"));
                if(!Request.get("suoshudiqu").equals(""))
        post.setSuoshudiqu(Request.get("suoshudiqu"));
                if(!Request.get("tupian").equals(""))
        post.setTupian(Request.get("tupian"));
                if(!Request.get("kaifangshijian").equals(""))
        post.setKaifangshijian(Request.get("kaifangshijian"));
                if(!Request.get("fujinmeishi").equals(""))
        post.setFujinmeishi(Request.get("fujinmeishi"));
                if(!Request.get("dizhi").equals(""))
        post.setDizhi(Request.get("dizhi"));
                if(!Request.get("piaojia").equals(""))
        post.setPiaojia(Request.getDouble("piaojia"));
            if(!Request.get("liulanliang").equals(""))
        post.setLiulanliang(Request.getInt("liulanliang"));
            if(!Request.get("miaoshu").equals(""))
        post.setMiaoshu(util.DownloadRemoteImage.run(Request.get("miaoshu")));
            if(!Request.get("addtime").equals(""))
        post.setAddtime(Request.get("addtime"));
        
        post.setId(Request.getInt("id"));
                service.update(post); // 更新数据
        int charuid = post.getId().intValue();
        
        if(isAjax()){
            return jsonResult(post);
        }
        
        return showSuccess("保存成功" , Request.get("referer")); // 弹出保存成功，并跳转到前台提交的 referer 页面
    }
    /**
     *  后台详情
     */
    @RequestMapping("/jingdianxinxi_detail")
    public String detail()
    {
        _var = new LinkedHashMap(); // 重置数据
        int id = Request.getInt("id");
        Jingdianxinxi map = service.find(id);  // 根据前台url 参数中的id获取行数据
        assign("map" , map);  // 把数据写到前台
            return json();   // 将数据写给前端
    }
    /**
     *  前台详情
     */
    @RequestMapping("/jingdianxinxidetail")
    public String detailweb()
    {
        _var = new LinkedHashMap(); // 重置数据
        int id = Request.getInt("id");
        Jingdianxinxi map = service.find(id);
        Query.execute("UPDATE jingdianxinxi SET liulanliang=liulanliang+1 WHERE id="+request.getParameter("id")+"");


                
                if(!checkLogin()){
            assign("isCollect" , false);
        }else{
            assign("isCollect" , Query.make("shoucangjilu").where("username",session.getAttribute("username")).where("biao" , "jingdianxinxi").where("xwid",id).count()>0);
        }

        
        assign("map" , map);
        return json();   // 将数据写给前端
    }
        /**
    *  删除
    */
    @RequestMapping("/jingdianxinxi_delete")
    public String delete()
    {
        _var = new LinkedHashMap(); // 重置数据
        if(!checkLogin()){
            return showError("尚未登录");
        }
        int id = Request.getInt("id");  // 根据id 删除某行数据
        HashMap map = Query.make("jingdianxinxi").find(id);

                service.delete(id);// 根据id 删除某行数据
                return showSuccess("删除成功",request.getHeader("referer"));//弹出删除成功，并跳回上一页
    }
}

package com.spring.controller;

import com.spring.entity.Shoucangjilu;
import com.spring.service.ShoucangjiluService;
import dao.Query;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import tk.mybatis.mapper.entity.Example;
import util.Info;
import util.Request;

import javax.annotation.Resource;
import java.util.List;

/**
 * 收藏控制器
 */
@Controller
public class ShoucangjiluController extends BaseController {

    @Resource
    protected ShoucangjiluService service;

    /**
     * 加入收藏
     * @return
     */
    @RequestMapping("/collect")
    public String collect()
    {
        if(!checkLogin()){
            return showError("您尚未登录请登录后在操作");
        }
        int id=Request.getInt("id");
        String biao=request.getParameter("biao");
        String ziduan=request.getParameter("ziduan");
        Shoucangjilu scjl = new Shoucangjilu();
        scjl.setXwid(id);
        scjl.setBiao(biao);
        scjl.setBiaoti(Query.make(biao).where("id" , id).value(ziduan));
        scjl.setUrl(request.getHeader("referer"));
        scjl.setZiduan(ziduan);
        scjl.setAddtime(Info.getDateStr());
        scjl.setUsername(request.getSession().getAttribute("username").toString());
        service.insert(scjl);
        return showSuccess("收藏成功" , request.getHeader("referer"));
    }

    /**
     * 查看收藏列表
     * @return
     */
    @RequestMapping("/shoucangjilu_list")
    public String index()
    {
        int page = Math.max(Integer.valueOf(Request.get("page" , "1")) , 1);
        Example example = new Example(Shoucangjilu.class);
        Example.Criteria criteria = example.createCriteria();

        criteria.andEqualTo("username" , request.getSession().getAttribute("username"));
        List<Shoucangjilu> list = service.selectPageExample(example , page , 15);
        if(isAjax()){
            return json();
        }
        return "shoucangjilu_list";
    }

    /**
     * 查看我的收藏
     * @return
     */
    @RequestMapping("/shoucangjilu_list2")
    public String index2()
    {
        int page = Math.max(Integer.valueOf(Request.get("page" , "1")) , 1);
        Example example = new Example(Shoucangjilu.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andEqualTo("username" , request.getSession().getAttribute("username"));
        List<Shoucangjilu> list = service.selectPageExample(example , page , 15);
        assign("list" , list);
        if(isAjax()){
            return json();
        }
        return "shoucangjilu_list";
    }

    /**
     * 删除收藏
     * @return
     */
    @RequestMapping("/shoucangjilu_delete")
    public String delete()
    {
        String id = Request.get("id");
        service.delete(id);
        return showSuccess("删除成功");
    }

}