JavaWeb第二十二天(二)

web

filter/CharacterFilter

package com.xm.web.filter;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

//访问服务器内所有资源都要经过这个过滤器
@WebFilter("/*")
public class CharacterFilter implements Filter {
    public void destroy() {
    }

    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        //将父接口转为子接口
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        //获取请求方法
        String method = request.getMethod();
        //解决post请求中文数据乱码问题
        if (method.equalsIgnoreCase("post")) {
            request.setCharacterEncoding("utf-8");
        }
        //处理响应数据乱码
        response.setContentType("text/html;charset=utf-8");
        chain.doFilter(request, response);
    }

    public void init(FilterConfig config) throws ServletException {

    }

}

servlet/BaseServlet

package com.xm.web.servlet;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class BaseServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //完成方法的分发
        //获取请求路径
        String uri = req.getRequestURI();//如/travel/user/add
        //获取方法名称
        String methodName = uri.substring(uri.lastIndexOf("/") + 1);//找到最后一个/，然后加1
        //获取方法对象
        //当前的this代表UserServlet，因为是访问UserServlet时调用的当前的service方法
        try {
            //获取方法对象时忽略方法的访问权限修饰符 最好还是将方法的修饰符改为public 防止一些私有方法被访问
            //Method method = this.getClass().getDeclaredMethod(methodName, HttpServletRequest.class, HttpServletResponse.class);
            Method method = this.getClass().getMethod(methodName, HttpServletRequest.class, HttpServletResponse.class);
            //暴力反射
            //method.setAccessible(true);
            //执行方法
            method.invoke(this, req, resp);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    /**
     * 将传入的对象序列化为json，并返回给客户端
     * @param obj
     */
    public void writeValue(Object obj, HttpServletResponse response) throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        response.setContentType("application/json;charset=utf-8");
        mapper.writeValue(response.getWriter(), obj);
    }

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

servlet/CategoryServlet

package com.xm.web.servlet;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.xm.domain.Category;
import com.xm.service.CategoryService;
import com.xm.service.impl.CategoryServiceImpl;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;

@WebServlet("/category/*")
public class CategoryServlet extends BaseServlet {
    private CategoryService service = new CategoryServiceImpl();
    public void findAll(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //调用service的方法，查询所有分类类别
        List<Category> categories = service.findAll();
        //将返回的集合序列化为json 调用BaseServlet中的方法
        writeValue(categories, response);
    }
}

servlet/CheckCodeServlet

package com.xm.web.servlet;

import javax.imageio.ImageIO;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.Random;

/**
 * 验证码
 */
@WebServlet("/checkCode")
public class CheckCodeServlet extends HttpServlet {
	public void doGet(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();
	}
	public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		this.doGet(request,response);
	}
}

servlet/RouteServelt

package com.xm.web.servlet;

import com.xm.domain.Favorite;
import com.xm.domain.PageBean;
import com.xm.domain.Route;
import com.xm.domain.User;
import com.xm.service.FavoriteService;
import com.xm.service.RouteService;
import com.xm.service.impl.FavoriteServiceImpl;
import com.xm.service.impl.RouteServiceImpl;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Map;

@WebServlet("/route/*")
public class RouteServlet extends BaseServlet {
    private RouteService routeService = new RouteServiceImpl();
    private FavoriteService favoriteService = new FavoriteServiceImpl();
    /**
     * 分页查询
     * @param request
     * @param response
     * @throws ServletException
     * @throws IOException
     */
    public void pageQuery(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取参数
        String cidStr = request.getParameter("cid");
        String currentPageStr = request.getParameter("currentPage");
        String pageSizeStr = request.getParameter("pageSize");
        String rname = request.getParameter("rname");
        //解决乱码问题
        if (rname != null && rname.length() > 0 && !"null".equals(rname)) {
            rname = new String(rname.getBytes("iso-8859-1"), "utf-8");
        }
        //处理参数
        int cid = 0;
        if (cidStr != null && cidStr.length() > 0 && !"null".equals(cidStr)) {
            cid = Integer.parseInt(cidStr);
        }
        int currentPage = 0;
        if (currentPageStr != null && currentPageStr.length() > 0 && !"null".equals(currentPageStr)) {
            currentPage = Integer.parseInt(currentPageStr);
        } else {
            //默认为1
            currentPage = 1;
        }
        int pageSize = 0;
        if (pageSizeStr != null && pageSizeStr.length() > 0 && !"null".equals(pageSizeStr)) {
            pageSize = Integer.parseInt(pageSizeStr);
        } else {
            //默认为5
            pageSize = 5;
        }
        //调用service查询PageBean对象
        PageBean<Route> routePageBean = routeService.pageQuery(cid, currentPage, pageSize, rname);
        //将PageBean对象序列化为json，并返回给客户端
        writeValue(routePageBean, response);
    }
    public void detailQuery(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String ridStr = request.getParameter("rid");
        int rid = 0;
        if (ridStr != null && ridStr.length() > 0 && !"null".equals(ridStr)) {
            rid = Integer.parseInt(ridStr);
        }
        //调用service
        Route routeDetail = routeService.detailQuery(rid);
        writeValue(routeDetail, response);
    }
    public void isFavorite(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String rid = request.getParameter("rid");
        User loginUser = (User) request.getSession().getAttribute("loginUser");
        int uid;
        if (loginUser == null) {
           return;
        } else {
            uid = loginUser.getUid();
        }
        //调用service
        boolean isFavorite = favoriteService.isFavorite(uid, rid);
        writeValue(isFavorite, response);
    }
    public void addFavorite(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String rid = request.getParameter("rid");
        User loginUser = (User) request.getSession().getAttribute("loginUser");
        int uid;
        if (loginUser == null) {
            uid = 0;
        } else {
            uid = loginUser.getUid();
        }
        //调用service
        favoriteService.add(uid, rid);
    }
}

servlet/UserServlet

package com.xm.web.servlet;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.xm.domain.ResultInfo;
import com.xm.domain.User;
import com.xm.service.UserService;
import com.xm.service.impl.UserServiceImpl;
import org.apache.commons.beanutils.BeanUtils;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.Map;

@WebServlet("/user/*")
public class UserServlet extends BaseServlet {
    private UserService service = new UserServiceImpl();
    /**
     * 用户注册
     * @param request
     * @param response
     * @throws ServletException
     * @throws IOException
     */
    public void register(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //验证码校验
        String checkCode = request.getParameter("check");
        String checkcode_server = (String) request.getSession().getAttribute("CHECKCODE_SERVER");
        //防止验证码被重复使用
        request.getSession().removeAttribute("CHECKCODE_SERVER");
        ResultInfo info = new ResultInfo();
        if (checkcode_server == null || !checkcode_server.equalsIgnoreCase(checkCode)) {
            //验证码错误
            info.setFlag(false);
            info.setErrorMsg("验证码错误！");
            writeValue(info, response);
            return;
        }
        //获取数据
        Map map = request.getParameterMap();
        //封装对象
        User user = new User();
        try {
            BeanUtils.populate(user, map);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        //调用service层的注册方法
        boolean registerFlag = service.userRegister(user);
        if (registerFlag) {
            info.setFlag(true);
        } else {
            info.setFlag(false);
            info.setErrorMsg("注册失败！");
        }
        writeValue(info, response);
    }

    /**
     * 用户激活
     * @param request
     * @param response
     * @throws ServletException
     * @throws IOException
     */
    public void active(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取用户的激活码
        String code = request.getParameter("code");
        //判断激活码是否为空
        if (code != null && code.length() != 0) {
            //激活码不为空，调用service的激活方法
            boolean activeFlag = service.userActive(code);
            String activeMsg = null;
            if (activeFlag) {
                //激活成功
                activeMsg = "激活成功，请<a href='login.html'>【登录】</a>";
            } else {
                //激活失败
                activeMsg = "激活失败，请联系管理员";
            }
            response.setContentType("text/html;charset=utf-8");
            response.getWriter().write(activeMsg);
        }
    }
    /**
     * 用户登录
     * @param request
     * @param response
     * @throws ServletException
     * @throws IOException
     */
    public void login(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("application/json;charset=utf-8");
        ResultInfo info = new ResultInfo();
        ObjectMapper mapper = new ObjectMapper();
        //判断验证码是否正确
        String checkCode = request.getParameter("check");
        String checkcode_server = (String) request.getSession().getAttribute("CHECKCODE_SERVER");
        //获取生成的验证码后清空，防止验证码复用
        request.getSession().removeAttribute("CHECKCODE_SERVER");
        if (checkcode_server == null || !checkcode_server.equalsIgnoreCase(checkCode)) {
            //验证码为空或不正确
            System.out.println("验证码错误");
            info.setFlag(false);
            info.setErrorMsg("验证码错误");
            writeValue(info, response);
            return;
        }
        System.out.println("验证码正确");
        //验证码正确
        //获取用户名和密码的Map集合
        Map map = request.getParameterMap();
        //将用户名 密码 验证码封装为User对象
        User user = new User();
        try {
            BeanUtils.populate(user, map);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        //调用service 根据封装的User对象判断用户是否存在
        User loginUser = service.login(user);
        if (loginUser != null) {
            //用户存在 判断用户是否激活
            if ("Y".equals(loginUser.getStatus())) {
                //用户已激活
                info.setFlag(true);
                request.getSession().setAttribute("loginUser", loginUser);
                System.out.println(loginUser.getUsername());
            } else {
                //用户未激活 回写错误信息
                info.setFlag(false);
                info.setErrorMsg("用户未激活，请激活后登录");
            }
        } else {
            //用户不存在 回写错误信息
            info.setFlag(false);
            info.setErrorMsg("用户名或密码错误");
        }
        writeValue(info, response);
    }

    /**
     * 查找用户
     * @param request
     * @param response
     * @throws ServletException
     * @throws IOException
     */
    public void find(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取session中的用户信息
        User loginUser = (User) request.getSession().getAttribute("loginUser");
        //将User对象转换为json
        writeValue(loginUser, response);
    }

    /**
     * 用户退出
     * @param request
     * @param response
     * @throws ServletException
     * @throws IOException
     */
    public void exit(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //销毁session
        request.getSession().invalidate();
        //重定向
        response.sendRedirect(request.getContextPath() + "/login.html");
    }
}

service

CategoryService

package com.xm.service;

import com.xm.domain.Category;

import java.util.List;

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

FavoriteService

package com.xm.service;

public interface FavoriteService {
    boolean isFavorite(int uid, String rid);
    void add(int uid, String rid);
}

RouteService

package com.xm.service;

import com.xm.domain.PageBean;
import com.xm.domain.Route;

public interface RouteService {
    public PageBean<Route> pageQuery(int cid, int currentPage, int pageSize, String rname);
    public Route detailQuery(int rid);
}

UserService

package com.xm.service;

import com.xm.domain.User;

public interface UserService {
    /**
     * 注册用户
     * @param user
     * @return
     */
    public boolean userRegister(User user);

    /**
     * 用户激活
     * @param code
     * @return
     */
    public boolean userActive(String code);

    /**
     * 用户登录
     * @param user
     * @return
     */
    public User login(User user);
}

impl/CategoryServiceImpl

package com.xm.service.impl;

import com.xm.dao.CategoryDao;
import com.xm.dao.impl.CategoryDaoImpl;
import com.xm.domain.Category;
import com.xm.service.CategoryService;
import com.xm.util.JedisUtil;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.Tuple;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

public class CategoryServiceImpl implements CategoryService {

    private CategoryDao dao = new CategoryDaoImpl();

    /**
     * 查询所有的分类类别
     * @return
     */
    @Override
    public List<Category> findAll() {
        //从redis中查询 使用封装的jedis工具类
        Jedis jedis = JedisUtil.getJedis();
        //使用SortedSet，可以使得分类展示的顺序和数据库中存储的数据一致
        Set<Tuple> categories = jedis.zrangeWithScores("category", 0, -1);
        List<Category> cs = null;
        //判断查询的集合是否为空
        if (categories == null || categories.size() == 0) {
            System.out.println("从数据库中查询");
            //集合为空 从数据库查询
            cs = dao.findAll();
            //遍历cs集合，将数据存进redis
            for (int i = 0; i < cs.size(); i++) {
                jedis.zadd("category", cs.get(i).getCid(), cs.get(i).getCname());
            }
        } else {
            System.out.println("从redis中查询");
            //集合不为空，将set集合categories中的数据放进list集合cs中
            cs = new ArrayList<Category>();
            for (Tuple tuple : categories) {
                Category category = new Category();
                int cid = (int) tuple.getScore();
                String cname = tuple.getElement();
                category.setCid(cid);
                category.setCname(cname);
                cs.add(category);
            }
        }
        return cs;
    }
}

impl/FavoriteServiceImpl

package com.xm.service.impl;

import com.xm.dao.FavoriteDao;
import com.xm.dao.impl.FavoriteDaoImpl;
import com.xm.domain.Favorite;
import com.xm.service.FavoriteService;

public class FavoriteServiceImpl implements FavoriteService {
    private FavoriteDao dao = new FavoriteDaoImpl();
    @Override
    public boolean isFavorite(int uid, String rid) {
        Favorite favorite = dao.findByUidAndRid(uid, Integer.parseInt(rid));
        if (favorite != null) {
            return true;
        } else {
            return false;
        }
    }

    @Override
    public void add(int uid, String rid) {
        dao.add(uid, Integer.parseInt(rid));
    }
}

impl/RouteServiceImpl

package com.xm.service.impl;

import com.xm.dao.FavoriteDao;
import com.xm.dao.RouteDao;
import com.xm.dao.RouteImgDao;
import com.xm.dao.RouteSellerDao;
import com.xm.dao.impl.FavoriteDaoImpl;
import com.xm.dao.impl.RouteDaoImpl;
import com.xm.dao.impl.RouteImgDaoImpl;
import com.xm.dao.impl.RouteSellerDaoImpl;
import com.xm.domain.PageBean;
import com.xm.domain.Route;
import com.xm.service.RouteService;

import java.util.List;

public class RouteServiceImpl implements RouteService {
    private RouteDao routeDao = new RouteDaoImpl();
    private RouteImgDao routeImgDao = new RouteImgDaoImpl();
    private RouteSellerDao routeSellerDao = new RouteSellerDaoImpl();
    private FavoriteDao favoriteDao = new FavoriteDaoImpl();
    @Override
    public PageBean<Route> pageQuery(int cid, int currentPage, int pageSize, String rname) {
        //封装PageBean对象
        PageBean<Route> pageBean = new PageBean<Route>();
        int totalCount = routeDao.findTotalCount(cid, rname);
        int start = (currentPage - 1) * pageSize;
        int totalPage = totalCount % pageSize == 0 ? totalCount / pageSize : totalCount / pageSize + 1;
        List<Route> list = routeDao.findByPage(cid, start, pageSize, rname);
        pageBean.setTotalCount(totalCount);
        pageBean.setTotalPage(totalPage);
        pageBean.setCurrentPage(currentPage);
        pageBean.setPageSize(pageSize);
        pageBean.setList(list);
        return pageBean;
    }

    @Override
    public Route detailQuery(int rid) {
        //根据rid查询tab_route表
        Route route = routeDao.findOne(rid);
        //根据rid查询tab_route_img表，将图片的集合设置到route对象中
        route.setRouteImgList(routeImgDao.findByRid(rid));
        //根据route的sid查询tab_seller表，将查询得到的Seller对象设置到route对象中
        route.setSeller(routeSellerDao.findBySid(route.getSid()));
        route.setCount(favoriteDao.findFavoriteCount(rid));
        return route;
    }
}

impl/UserServiceImpl

package com.xm.service.impl;

import com.xm.dao.UserDao;
import com.xm.dao.impl.UserDaoImpl;
import com.xm.domain.User;
import com.xm.service.UserService;
import com.xm.util.MailUtils;
import com.xm.util.UuidUtil;

import java.util.Random;

public class UserServiceImpl implements UserService {
    private UserDao dao = new UserDaoImpl();
    @Override
    public boolean userRegister(User user) {
        //调用dao层的通过用户名查询用户的方法
        User UserByUsername = dao.findUserByUsername(user.getUsername());
        if (UserByUsername != null) {
            //用户名已存在
            System.out.println("用户名已存在");
            return false;
        }
        //用户名不存在
        System.out.println("用户名不存在");
        //设置用户的激活码
        user.setCode(UuidUtil.getUuid());
        //设置用户的激活状态
        user.setStatus("N");
        //保存用户信息
        dao.saveUser(user);
        //发送邮件
        String content = "点击激活<a href='http://localhost/travel/user/active?code=" + user.getCode() + "'>【黑马旅游网】</a>";
        MailUtils.sendMail(user.getEmail(), content, "激活邮件");
        return true;
    }

    @Override
    public boolean userActive(String code) {
        //根据激活码查询用户
        User userByCode = dao.findUserByCode(code);
        //判断用户是否存在
        if (userByCode == null) {
            //用户不存在
            return false;
        }
        //用户存在，调用激活方法
        dao.updateStatus(userByCode);
        return true;
    }

    @Override
    public User login(User user) {
        return dao.findUserByUsernameAndPassword(user.getUsername(), user.getPassword());
    }
}

dao

CategoryDao

package com.xm.dao;

import com.xm.domain.Category;

import java.util.List;

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

FavoriteDao

package com.xm.dao;

import com.xm.domain.Favorite;

public interface FavoriteDao {
    Favorite findByUidAndRid(int uid, int rid);
    int findFavoriteCount(int rid);

    void add(int uid, int rid);
}

RouteDao

package com.xm.dao;

import com.xm.domain.Favorite;
import com.xm.domain.PageBean;
import com.xm.domain.Route;

import java.util.List;

public interface RouteDao {
    public int findTotalCount(int cid, String rname);
    public List<Route> findByPage(int cid, int start, int pageSize,String rname);
    public Route findOne(int rid);
}

RouteImgDao

package com.xm.dao;

import com.xm.domain.RouteImg;

import java.util.List;

public interface RouteImgDao {
    public List<RouteImg> findByRid(int rid);
}

RouteSellerDao

package com.xm.dao;

import com.xm.domain.Seller;

public interface RouteSellerDao {
    public Seller findBySid(int sid);
}

UseDao

package com.xm.dao;

import com.xm.domain.User;

public interface UserDao {
    /**
     * 根据用户名查询用户
     * @param username
     * @return
     */
    public User findUserByUsername(String username);

    /**
     * 保存用户数据
     * @param user
     */
    public void saveUser(User user);

    /**
     * 根据激活码查询用户
     * @param code
     * @return
     */
    public User findUserByCode(String code);

    /**
     * 更新用户的status状态，激活用户
     * @param user
     */
    public void updateStatus(User user);

    /**
     * 根据用户名和密码查询用户
     * @param username
     * @param password
     */
    public User findUserByUsernameAndPassword(String username, String password);
}

impl/CategoryDaoImpl

package com.xm.dao.impl;

import com.xm.dao.CategoryDao;
import com.xm.domain.Category;
import com.xm.util.JDBCUtils;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;

import java.util.List;

public class CategoryDaoImpl implements CategoryDao {
    private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());

    /**
     * 查询所有的分类类别
     * @return
     */
    @Override
    public List<Category> findAll() {
        String sql = "select * from tab_category";
        List<Category> categories = template.query(sql, new BeanPropertyRowMapper<Category>(Category.class));
        return categories;
    }
}

impl/FavoriteDaoImpl

package com.xm.dao.impl;

import com.xm.dao.FavoriteDao;
import com.xm.domain.Favorite;
import com.xm.util.JDBCUtils;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;

import java.util.Date;

public class FavoriteDaoImpl implements FavoriteDao {
    private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
    @Override
    public Favorite findByUidAndRid(int uid, int rid) {
        String sql ="select * from tab_favorite where uid = ? and rid = ?";
        Favorite favorite = null;
        try {
            favorite = template.queryForObject(sql, new BeanPropertyRowMapper<Favorite>(Favorite.class), uid, rid);
        } catch (Exception e) {

        }
        return favorite;
    }

    @Override
    public int findFavoriteCount(int rid) {
        String sql = "select count(*) from tab_favorite where rid = ?";
        return template.queryForObject(sql, Integer.class, rid);
    }

    @Override
    public void add(int uid, int rid) {
        String sql = "insert into tab_favorite values(?, ?, ?)";
        template.update(sql, rid, new Date(), uid);
    }
}

impl/RouteDaoImpl

package com.xm.dao.impl;

import com.xm.dao.RouteDao;
import com.xm.domain.Favorite;
import com.xm.domain.PageBean;
import com.xm.domain.Route;
import com.xm.util.JDBCUtils;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import java.util.ArrayList;
import java.util.List;

public class RouteDaoImpl implements RouteDao {
    JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());

    /**
     * 查询总记录数
     * @return
     */
    @Override
    public int findTotalCount(int cid, String rname) {
        //sql模板
        String sql = "select count(*) from tab_route where 1 = 1 ";//注意空格
        StringBuilder sb = new StringBuilder(sql);
        //参数集合
        List parameters = new ArrayList();
        if (cid != 0) {
            //cid有值
            sb.append("and cid = ? ");
            parameters.add(cid);
        }
        if (rname != null && rname.length() > 0) {
            sb.append("and rname like ?");
            parameters.add("%" + rname + "%");
        }
        sql = sb.toString();
        //select count(*) from tab_route where 1 = 1 and cid = cid and rname like %rname%;
        return template.queryForObject(sql, Integer.class, parameters.toArray());
    }

    /**
     * 查询当前页码的数据集合
     * @param cid
     * @param start
     * @param pageSize
     * @return
     */
    @Override
    public List<Route> findByPage(int cid, int start, int pageSize, String rname) {
        //sql模板
        String sql = "select * from tab_route where 1 = 1 ";
        StringBuilder sb = new StringBuilder(sql);
        //参数集合
        List parameters = new ArrayList();
        if (cid != 0) {
            sb.append("and cid = ? ");
            parameters.add(cid);
        }
        if (rname != null && rname.length() > 0) {
            sb.append("and rname like ? ");
            parameters.add("%" + rname + "%");
        }
        sb.append("limit ?, ?");
        parameters.add(start);
        parameters.add(pageSize);
        sql = sb.toString();
        //select * from tab_route where 1 = 1 and cid = cid and rname like %rname% limit ?, ?;
        return template.query(sql, new BeanPropertyRowMapper<Route>(Route.class), parameters.toArray());
    }

    @Override
    public Route findOne(int rid) {
        String sql = "select * from tab_route where rid = ?";
        Route route = null;
        try {
            route = template.queryForObject(sql, new BeanPropertyRowMapper<Route>(Route.class), rid);
        } catch (Exception e) {

        }
        return route;
    }
}

impl/RouteImgDaoImpl

package com.xm.dao.impl;

import com.xm.dao.RouteImgDao;
import com.xm.domain.RouteImg;
import com.xm.util.JDBCUtils;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;

import java.util.List;

public class RouteImgDaoImpl implements RouteImgDao {
    private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
    @Override
    public List<RouteImg> findByRid(int rid) {
        String sql = "select * from tab_route_img where rid = ?";
        return template.query(sql, new BeanPropertyRowMapper<RouteImg>(RouteImg.class), rid);
    }
}

impl/RouteSellerDaoImpl

package com.xm.dao.impl;

import com.xm.dao.RouteSellerDao;
import com.xm.domain.RouteImg;
import com.xm.domain.Seller;
import com.xm.util.JDBCUtils;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;

public class RouteSellerDaoImpl implements RouteSellerDao {
    private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
    @Override
    public Seller findBySid(int sid) {
        String sql = "select * from tab_seller where sid = ?";
        Seller seller = null;
        try {
            seller = template.queryForObject(sql, new BeanPropertyRowMapper<Seller>(Seller.class), sid);
        } catch (Exception e) {

        }
        return seller;
    }
}

impl/UserDaoImpl

package com.xm.dao.impl;

import com.xm.dao.UserDao;
import com.xm.domain.User;
import com.xm.util.JDBCUtils;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;

public class UserDaoImpl implements UserDao {
    private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
    @Override
    public User findUserByUsername(String username) {
        User user = null;
        String sql = "select * from tab_user where username = ?";
        try {
            user = template.queryForObject(sql, new BeanPropertyRowMapper<User>(User.class), username);
        } catch (Exception e) {
            //不进行处理，有异常直接返回null
            //进行try-catch是因为这里没有查询到用户不会返回null，会直接报异常
        }
        return user;
    }

    @Override
    public void saveUser(User user) {
        String sql = "insert into tab_user(username, password, name, birthday, sex, telephone, email, status, code) values(?, ?, ?, ?, ?, ?, ?, ?, ?)";
        template.update(sql, user.getUsername(), user.getPassword(), user.getName(), user.getBirthday(), user.getSex(), user.getTelephone(), user.getEmail(), user.getStatus(), user.getCode());
    }

    @Override
    public User findUserByCode(String code) {
        User user = null;
        String sql = "select * from tab_user where code = ?";
        try {
            user = template.queryForObject(sql, new BeanPropertyRowMapper<User>(User.class), code);
        } catch (Exception e) {

        }
        return user;
    }

    @Override
    public void updateStatus(User user) {
        String sql = "update tab_user set status = 'Y' where uid = ?";
        template.update(sql, user.getUid());
    }

    @Override
    public User findUserByUsernameAndPassword(String username, String password) {
        String sql = "select * from tab_user where username = ? and password = ?";
        User user = null;
        try {
            user = template.queryForObject(sql, new BeanPropertyRowMapper<User>(User.class), username, password);
        } catch (Exception e) {

        }
        return user;
    }
}