新手上路：旅游网案例(中)

归类servlet

需求：需要把servlet整合成和service和dao一样用方法来方便管理

/**
 * @Description: user表里面的所有功能
 * @Author: Mr.Night
 */
@WebServlet("/user/*")//把uesr表里面的功能(servlet)变成方法
public class UserServlet extends BaseServlet {

    //③调用service层
    private UserService service = new UserServiceImpl();

    /**
     * @Description: 注册
     * @Author: Mr.Night
     */
    public void regist(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //验证码校验
        String check = request.getParameter("check");
        //从sesion中获取验证码
        HttpSession session = request.getSession();
        String checkcode_server = (String) session.getAttribute("CHECKCODE_SERVER");
        //保证验证码只能使用一次
        session.removeAttribute("CHECKCODE_SERVER");
        //把用户输入的验证码和生成的验证码进行比较
        if (checkcode_server == null || !checkcode_server.equalsIgnoreCase(check)) {
            //如果比较结果不同则给出验证码有误的提示信息并结束方法
            //调用ResultInfo对象对返 回数据的结果进行封装
            ResultInfo info = new ResultInfo();
            //注册失败
            info.setFlag(false);
            //提示信息
            info.setErrorMsg("验证码有误！");
            //将ResultInfo对象序列化为json
            ObjectMapper mapper = new ObjectMapper();
            String json = mapper.writeValueAsString(info);
            //将json数据重写回客户端
            //设置content-type
            response.setContentType("application/json;charset=utf-8");
            response.getWriter().write(json);
            return;
        }

        //①利用request方法获取数据
        Map<String, String[]> map = request.getParameterMap();

        //②封装User对象
        //调用user对象
        User user = new User();
        try {
            //调用BeanUtils的静态方法把map封装到user对象
            BeanUtils.populate(user, map);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        //调用service的方法完成注册
        boolean flag = service.regist(user);

        //④响应结果
        //调用ResultInfo对象对返回数据的结果进行封装
        ResultInfo info = new ResultInfo();
        if (flag) {
            //注册成功
            info.setFlag(true);
        } else {
            //注册失败
            info.setFlag(false);
            //封装提示信息
            info.setErrorMsg("该用户名已存在!");
        }
        //将ResultInfo对象序列化为json
        ObjectMapper mapper = new ObjectMapper();
        String json = mapper.writeValueAsString(info);
        //将json数据重写回客户端
        //设置content-type
        response.setContentType("application/json;charset=utf-8");
        response.getWriter().write(json);
    }

    /**
     * @Description: 验证码
     * @Author: Mr.Night
     */
    public void checkCode(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //服务器通知浏览器不要缓存
        response.setHeader("pragma", "no-cache");
        response.setHeader("cache-control", "no-cache");
        response.setHeader("expires", "0");

        //在内存中创建一个长80，宽30的图片，默认黑色背景
        //参数一：长
        //参数二：宽
        //参数三：颜色
        int width = 80;
        int height = 30;
        BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

        //获取画笔
        Graphics g = image.getGraphics();
        //设置画笔颜色为灰色
        g.setColor(Color.GRAY);
        //填充图片
        g.fillRect(0, 0, width, height);

        //产生4个随机验证码，12Ey
        String checkCode = getCheckCode();
        //将验证码放入HttpSession中
        request.getSession().setAttribute("CHECKCODE_SERVER", checkCode);

        //设置画笔颜色为黄色
        g.setColor(Color.YELLOW);
        //设置字体的小大
        g.setFont(new Font("黑体", Font.BOLD, 24));
        //向图片上写入验证码
        g.drawString(checkCode, 15, 25);

        //将内存中的图片输出到浏览器
        //参数一：图片对象
        //参数二：图片的格式，如PNG,JPG,GIF
        //参数三：图片输出到哪里去
        ImageIO.write(image, "PNG", response.getOutputStream());
    }

    /**
     * 产生4位随机字符串
     */
    private String getCheckCode() {
        String base = "0123456789ABCDEFGabcdefg";
        int size = base.length();
        Random r = new Random();
        StringBuffer sb = new StringBuffer();
        for (int i = 1; i <= 4; i++) {
            //产生0到size-1的随机值
            int index = r.nextInt(size);
            //在base字符串中获取下标为index的字符
            char c = base.charAt(index);
            //将c放入到StringBuffer中去
            sb.append(c);
        }
        return sb.toString();
    }

    /**
    * @Description: 邮件激活
    * @Author: Mr.Night
    */
    public void active(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取激活码
        String code = request.getParameter("code");
        //判断激活码是否存在
        if (code != null) {
            //激活码存在
            //声明提示信息
            String msg = null;
            //激活用户是否成功，用boolean接收
            boolean flag = service.active(code);
            if (flag) {
                //激活成功，显示提示信息并可以跳转到登录页面
                msg = "激活成功，请<a href='login.html'>登录</a>";
            } else {
                //激活失败，显示提示信息
                msg = "激活失败，请联系管理员！";
            }
            //设置content-type防止乱码
            response.setContentType("text/html;charset=utf-8");
            //将数据写回客户端页面
            response.getWriter().write(msg);
        }
    }
    
    /**
    * @Description: 登录
    * @Author: Mr.Night
    */
    public void login(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取用户名和密码
        Map<String, String[]> map = request.getParameterMap();
        //封装user对象
        User user = new User();
        try {
            //调用BeanUtils的静态方法把map封装进user对象
            BeanUtils.populate(user, map);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        //使用service方法进行查询
        User u = service.login(user);
        //调用ResultInfo工具类对返回数据结果进行封装
        ResultInfo info = new ResultInfo();

        //判断对象是否为null
        if (u == null) {
            //用户名或密码错误，调用info方法
            //登录失败
            info.setFlag(false);
            //提示信息
            info.setErrorMsg("用户名或密码错误");
        }

        //判断用户是否激活
        if (u != null && "N".equals(u.getStatus())) {
            //用户尚未激活
            //登录失败
            info.setFlag(false);
            //提示信息
            info.setErrorMsg("您尚未激活，请先激活！");
        }

        //判断用户是否登录成功
        if (u != null && "Y".equals(u.getStatus())) {
            //满足if，则登录成功
            info.setFlag(true);
        }

        //响应数据
        ObjectMapper mapper = new ObjectMapper();
        //通过session得到user对象的属性
        request.getSession().setAttribute("user",u);
        //设置Content-type
        response.setContentType("application/json;charset=utf-8");
        //将数据写会客户端
        mapper.writeValue(response.getOutputStream(), info);
    }

    /**
    * @Description: 主页显示用户姓名
    * @Author: Mr.Night
    */
    public void findOne(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //从session获取登录用户
        Object user = request.getSession().getAttribute("user");
        //将数据直接写回客户端
        ObjectMapper mapper = new ObjectMapper();
        //设置Content-Type防止乱码
        response.setContentType("application/json;charset=utf-8");
        //调用mapper方法将数据返回
        mapper.writeValue(response.getOutputStream(), user);
    }

    /**
    * @Description: 退出
    * @Author: Mr.Night
    */
    public void exit(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //销毁session数据
        request.getSession().invalidate();
        //重定向跳转到登录页面
        response.sendRedirect(request.getContextPath() + "/login.html");
    }
}

网页form表单分类

dao

public interface CategoryDao {
    /**
    * @Description: 查询种类列表
    * @Author: Mr.Night
    */
    List<Category> findAll();
}

public class CategoryDaoImpl implements CategoryDao {
    //声明数据库连接池
    private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());


    public List<Category> findAll() {
        //声明sql
        String sql = "select * from tab_category";
        //执行并返回sql
        return template.query(sql, new BeanPropertyRowMapper<>(Category.class));
    }
}

service

public interface CategoryService {
    List<Category> findAll();
}

public class CategoryServiceImpl implements CategoryService {
    private CategoryDao categoryDao = new CategoryDaoImpl();

    public List<Category> findAll() {
        //直接返回dao层的查询种类列表的方法
        return categoryDao.findAll();
    }
}

servlet

@WebServlet("/category/*")
public class CategoryServlet extends BaseServlet {
    //调用service层
    private CategoryService service = new CategoryServiceImpl();

    /**
     * @Description: 查询种类列表
     * @Author: Mr.Night
     */
    public void findAll(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //调用service查询
        List<Category> cs = service.findAll();
        //调用序列化方法
        writeValue(cs, response);
    }
}

代码(BaseServlet.java)：

    /**
    * @Description: 将传入的对象序列化json,并写回客户端
    * @Author: Mr.Night
    */
    public void writeValue(Object obj,HttpServletResponse response) throws IOException {
        //序列化json
        ObjectMapper mapper = new ObjectMapper();
        //设置content-Type,防止乱码
        response.setContentType("application/json;charset=utf-8");
        //写回客户端
        mapper.writeValue(response.getOutputStream(), obj);
    }

    /**
    * @Description: 将传入的对象序列化json,返回
    * @Author: Mr.Night
    */
    public String writeValueAsString(Object obj) throws JsonProcessingException {
        //序列化json
        ObjectMapper mapper = new ObjectMapper();
        //返回字符串
        return mapper.writeValueAsString(obj);
    }

js

<!--js-->
   //将信息写到网页上
            $("#span_username").html(msg);
            $("#exit").html("退出");
        })
        //查询分类数据
        $.get("category/findAll", {}, function (data) {
            //数据库获取动态展示
            var lis = '<li class="nav-active"><a href="index.html">首页</a></li>';
            //遍历分类集合
            for (var i = 0; i < data.length; i++) {
                var li = '<li><a href="route_list.html">' + data[i].cname + '</a></li>';
                //拼接
                lis += li;
            }
            //拼接
            lis += '<li><a href="favoriterank.html">收藏排行榜</a></li>';
            //显示到页面
            $("#category").html(lis);
<!--html-->
<!-- 头部 end -->
<!-- 首页导航 -->
<div class="navitem">
    <ul id="category" class="nav">

利用redis来缓存数据

service

 public List<Category> findAll() {
        //缓存优化
        //获取jedis客户端
        Jedis jedis = JedisUtil.getJedis();
        //使用sortedset排序查询
        Set<String> categorys = jedis.zrange("category", 0, -1);
        //声明list
        List<Category> cs = null;
        //判断排序查询的集合是否为空
        if (categorys == null || categorys.size() == 0) {
            //集合为空，就需要先从数据库里面查询，再将数据存入redis
            //调用dao的方法从数据库查询并封装到Category的list集合
            cs = categoryDao.findAll();
            //将list集合数据存储到redis中的category（key）中
            for (int i = 0; i < cs.size(); i++) {
                //循环存储
                jedis.zadd("catgory", cs.get(i).getCid(), cs.get(i).getCname());
            }
        } else {
            //集合不为空，因为return是list集合，就将set集合的数据存入到list
            //初始化list
            cs = new ArrayList<>();
            //遍历set集合
            for (String name : categorys) {
                //初始化分类表
                Category category = new Category();
                //先将set的数据封装到category对象
                category.setCname(name);
                //再将category存入集合
                cs.add(category);
            }
        }
        //关闭连接，解决频繁刷新数据丢失的问题
        jedis.close();
        //返回list集合
        return cs;
    }