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;
}
}