hbh
洪彬浩 3 months ago
parent 984e3a1099
commit fe7485d87f

@ -1,43 +0,0 @@
package com;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.context.ApplicationContext;
import org.springframework.core.env.Environment;
import java.io.IOException;
/**
*
*/
@SpringBootApplication
@MapperScan("com.dao")
public class SpringbootApplication extends SpringBootServletInitializer {
private static Logger log = LoggerFactory.getLogger(SpringbootApplication.class);
public static void main(String[] args) throws IOException {
ApplicationContext context = SpringApplication.run(SpringbootApplication.class);
Environment env = context.getEnvironment();
log.info("====================================================================");
log.info("项目版本: {}", env.getProperty("project.version"));
log.info("启动环境: {}", env.getProperty("project.env"));
log.info("启动端口: {}", env.getProperty("server.port"));
log.info("日志等级: {}", env.getProperty("logback.level"));
log.info("日志Appender: {}", env.getProperty("logback.appender"));
log.info("Startup complete ...");
log.info("====================================================================");
Runtime.getRuntime().exec("cmd /c start http://localhost:" + env.getProperty("server.port") +env.getProperty("server.servlet.context-path")+"/front/dist/index.html");
}
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
return builder.sources(SpringbootApplication.class);
}
}

@ -1,13 +0,0 @@
package com.annotation;
import java.lang.annotation.*;
/**
* Token
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface IgnoreAuth {
}

@ -1,42 +0,0 @@
package com.config;
import com.interceptor.AuthorizationInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
/**
* @ClassName InterceptorConfig
* @Description
*/
@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
@Autowired
private AuthorizationInterceptor authorizationInterceptor;
/**
*
* @param registry
*/
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(authorizationInterceptor).addPathPatterns("/**").excludePathPatterns("/static/**");;
}
/**
*
* @param registry
*/
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("/**")
.addResourceLocations("classpath:/resources/")
.addResourceLocations("classpath:/static/")
.addResourceLocations("classpath:/admin/")
.addResourceLocations("classpath:/front/")
.addResourceLocations("classpath:/qian/")
.addResourceLocations("classpath:/public/");
}
}

@ -1,80 +0,0 @@
package com.controller;
import com.annotation.IgnoreAuth;
import com.util.*;
import org.springframework.util.ResourceUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.net.URLEncoder;
import java.util.Date;
/**
* @ClassName CommonController
* @Description
*/
@RestController
@RequestMapping("/common")
public class CommonController {
/**
*
*/
@IgnoreAuth
@RequestMapping("/uploadfile")
public ApiResponse<String> upload(@RequestParam("file") MultipartFile file, HttpServletRequest request) throws Exception {
if (file.isEmpty()) {
return ApiResponse.failed(400, "文件不能为空");
}
String fileExt = file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf(".") + 1);
File path = new File(ResourceUtils.getURL("classpath:static").getPath());
if (!path.exists()) {
path = new File("");
}
File upload = new File(path.getAbsolutePath(), "/upload/");
if (!upload.exists()) {
upload.mkdirs();
}
String fileName = new Date().getTime() + "." + fileExt;
File dest = new File(upload.getAbsolutePath() + "/" + fileName);
file.transferTo(dest);
return ApiResponse.success(fileName);
}
/**
*
*
* @throws IOException
*/
@IgnoreAuth
@RequestMapping(value = "/download", method = RequestMethod.GET)
public void download(@RequestParam(value = "filename") String filename,
HttpServletRequest request,
HttpServletResponse response) throws IOException {
//需要下载的文件
String path = ResourceUtils.getURL("classpath:static").getPath() + "/" + filename;
//获取输入流
InputStream bis = new BufferedInputStream(new FileInputStream(new File(path)));
//转码,免得文件名中文乱码
filename = URLEncoder.encode(filename, "UTF-8");
//设置文件下载头
response.addHeader("Content-Disposition", "attachment;filename=" + filename);
//1.设置文件ContentType类型这样设置会自动判断下载文件类型
response.setContentType("multipart/form-data");
BufferedOutputStream out = new BufferedOutputStream(response.getOutputStream());
int len = 0;
while ((len = bis.read()) != -1) {
out.write(len);
out.flush();
}
out.close();
}
}

@ -1,330 +0,0 @@
package com.controller;
import com.annotation.IgnoreAuth;
import com.entity.*;
import com.service.*;
import com.util.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpSession;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName DingdanController
* @Description
*/
@RequestMapping("dingdan")
@RestController
public class DingdanController {
@Autowired
private DingdanService dingdanService;
@Autowired
private GouwucheService gouwucheService;
@Autowired
private ShangpinService shangpinService;
@Autowired
private DingdanxiangService dingdanxiangService;
//前台-根据条件获取订单列表分页数据接口
@RequestMapping("/manaqian")
public ApiResponse<Dingdan> manaQian(Dingdan req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Dingdan> dingdanList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(dingdanList);
}
//前台-根据条件获取我的订单列表分页数据接口
@RequestMapping("/manamyqian")
public ApiResponse<Dingdan> manaMyQian(Dingdan req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Dingdan> dingdanList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(dingdanList);
}
//前台-根据条件获取订单图片列表分页数据接口
@RequestMapping("/manaqiantp")
public ApiResponse<Dingdan> manaQianTp(Dingdan req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Dingdan> dingdanList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(dingdanList);
}
//前台-订单详情
@RequestMapping("/detail/{id}")
public ApiResponse<Dingdan> detail(@PathVariable("id") Integer id) {
Dingdan info = dingdanService.findById(id);
return ApiResponse.success(info);
}
//前台-订单添加接口
@PostMapping("/add")
public ApiResponse<Integer> add(@RequestBody Dingdan req, HttpSession session, String shangPinId) {
Users users = (Users) session.getAttribute("users");
List<Gouwuche> gouwucheList = new ArrayList<>();
if (null != users && null != users.getId()) {
if (null == shangPinId || shangPinId.equals("0")) {
//从购物车里提交订单下单
Gouwuche gouwuche = new Gouwuche();
gouwuche.setUsersid(users.getId());
gouwucheList = gouwucheService.find(gouwuche);
}else {
//商品详情页里直接购买下单
Integer shangpinid = cn.hutool.core.convert.Convert.toInt(shangPinId);
Gouwuche gouwuche = new Gouwuche();
gouwuche.setShangpinid(shangpinid);
gouwuche.setId(0);
//直接购买时购买数量为1
gouwuche.setGoumaishuliang(1);
gouwucheList.add(gouwuche);
}
if (gouwucheList.size() == 0) {
return ApiResponse.failed("请先将商品添加到购物车再提交订单!");
} else {
for (Gouwuche info : gouwucheList) {
Integer shangpinid = info.getShangpinid();
if (null == shangpinid || shangpinid == 0) {
return ApiResponse.failed("购物车里的商品数据异常!");
}
Integer goumaishuliang = info.getGoumaishuliang();
//库存判断
Shangpin shangpin = shangpinService.findById(shangpinid);
if (null != shangpin) {
Integer kucunshuliang = shangpin.getKucunshuliang();
//判断库存是否大于或等于订单数量
if (kucunshuliang < goumaishuliang) {
return ApiResponse.failed("购物车里的商品库存不足,请修正后再提交!");
}
} else {
return ApiResponse.failed("购物车里的商品不存在!");
}
}
}
} else {
return ApiResponse.failed("请登陆后再操作!");
}
int result = dingdanService.saveOrUpdate(req);
//保存订单项数据、更新商品表数据以及删除购物车数据
for (Gouwuche info : gouwucheList) {
Integer shangpinid = info.getShangpinid();
Integer goumaishuliang = info.getGoumaishuliang();
//保存订单项数据
Dingdanxiang dingdanxiang = new Dingdanxiang();
dingdanxiang.setShangpinid(shangpinid);
dingdanxiang.setGoumaishuliang(goumaishuliang);
dingdanxiang.setUsersid(users.getId());
dingdanxiang.setDingdanid(result);
dingdanxiangService.saveOrUpdate(dingdanxiang);
//更新商品表数据
Shangpin shangpin = shangpinService.findById(shangpinid);
Integer kucunshuliang = shangpin.getKucunshuliang();
Integer xiaoshoushuliang = shangpin.getXiaoshoushuliang();
//商品库存数量减去购买数量
shangpin.setKucunshuliang(kucunshuliang - goumaishuliang);
//商品销售数量加上购买数量
shangpin.setXiaoshoushuliang(xiaoshoushuliang + goumaishuliang);
shangpinService.saveOrUpdate(shangpin);
//删除购物车数据
gouwucheService.deleteById(info.getId());
}
return ApiResponse.success(result);
}
//后台-根据条件获取订单管理列表分页数据接口
@RequestMapping("/mana")
public ApiResponse<Dingdan> mana(Dingdan req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Dingdan> dingdanList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(dingdanList);
}
//后台-根据条件获取订单管理我的列表分页数据接口
@RequestMapping("/manamy")
public ApiResponse<Dingdan> manaMy(Dingdan req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Dingdan> dingdanList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(dingdanList);
}
//后台-根据条件获取订单查看列表分页数据接口
@RequestMapping("/chakan")
public ApiResponse<Dingdan> chakan(Dingdan req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Dingdan> dingdanList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(dingdanList);
}
//后台-根据条件获取订单查看我的列表分页数据接口
@RequestMapping("/chakanmy")
public ApiResponse<Dingdan> chakanMy(Dingdan req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Dingdan> dingdanList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(dingdanList);
}
//后台-订单详情
@RequestMapping("/info/{id}")
public ApiResponse<Dingdan> info(@PathVariable("id") Integer id) {
Dingdan info = dingdanService.findById(id);
return ApiResponse.success(info);
}
//后台-订单添加接口
@PostMapping("/save")
public ApiResponse<Integer> save(@RequestBody Dingdan req, HttpSession session, String shangPinId) {
Users users = (Users) session.getAttribute("users");
List<Gouwuche> gouwucheList = new ArrayList<>();
if (null != users && null != users.getId()) {
if (null == shangPinId || shangPinId.equals("0")) {
//从购物车里提交订单下单
Gouwuche gouwuche = new Gouwuche();
gouwuche.setUsersid(users.getId());
gouwucheList = gouwucheService.find(gouwuche);
}else {
//商品详情页里直接购买下单
Integer shangpinid = cn.hutool.core.convert.Convert.toInt(shangPinId);
Gouwuche gouwuche = new Gouwuche();
gouwuche.setShangpinid(shangpinid);
gouwuche.setId(0);
//直接购买时购买数量为1
gouwuche.setGoumaishuliang(1);
gouwucheList.add(gouwuche);
}
if (gouwucheList.size() == 0) {
return ApiResponse.failed("请先将商品添加到购物车再提交订单!");
} else {
for (Gouwuche info : gouwucheList) {
Integer shangpinid = info.getShangpinid();
if (null == shangpinid || shangpinid == 0) {
return ApiResponse.failed("购物车里的商品数据异常!");
}
Integer goumaishuliang = info.getGoumaishuliang();
//库存判断
Shangpin shangpin = shangpinService.findById(shangpinid);
if (null != shangpin) {
Integer kucunshuliang = shangpin.getKucunshuliang();
//判断库存是否大于或等于订单数量
if (kucunshuliang < goumaishuliang) {
return ApiResponse.failed("购物车里的商品库存不足,请修正后再提交!");
}
} else {
return ApiResponse.failed("购物车里的商品不存在!");
}
}
}
} else {
return ApiResponse.failed("请登陆后再操作!");
}
int result = dingdanService.saveOrUpdate(req);
//保存订单项数据、更新商品表数据以及删除购物车数据
for (Gouwuche info : gouwucheList) {
Integer shangpinid = info.getShangpinid();
Integer goumaishuliang = info.getGoumaishuliang();
//保存订单项数据
Dingdanxiang dingdanxiang = new Dingdanxiang();
dingdanxiang.setShangpinid(shangpinid);
dingdanxiang.setGoumaishuliang(goumaishuliang);
dingdanxiang.setUsersid(users.getId());
dingdanxiang.setDingdanid(result);
dingdanxiangService.saveOrUpdate(dingdanxiang);
//更新商品表数据
Shangpin shangpin = shangpinService.findById(shangpinid);
Integer kucunshuliang = shangpin.getKucunshuliang();
Integer xiaoshoushuliang = shangpin.getXiaoshoushuliang();
//商品库存数量减去购买数量
shangpin.setKucunshuliang(kucunshuliang - goumaishuliang);
//商品销售数量加上购买数量
shangpin.setXiaoshoushuliang(xiaoshoushuliang + goumaishuliang);
shangpinService.saveOrUpdate(shangpin);
//删除购物车数据
gouwucheService.deleteById(info.getId());
}
return ApiResponse.success(result);
}
//订单删除(含批量删除)接口
@RequestMapping("/delete")
public ApiResponse<Integer> delete(@RequestBody Integer[] ids) {
int result = 0;
for (Integer id : ids) {
result = dingdanService.deleteById(id);
}
return ApiResponse.success(result);
}
//订单修改接口
@PostMapping("/set")
public ApiResponse<Integer> set(@RequestBody Dingdan req) {
int result = dingdanService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//根据条件获取订单总金额接口
@RequestMapping("/totalamount")
public ApiResponse<Integer> getTotalamount(Dingdan req) {
//计算订单总金额
Integer totalAmount = 0;
List<Dingdan> dingdanList = dingdanService.find(req);
for (Dingdan dingdan : dingdanList) {
totalAmount += dingdan.getJine();
}
return ApiResponse.success(totalAmount);
}
//获取所有订单数据接口
@RequestMapping("/all")
public ApiResponse<Dingdan> dingdanAll() {
List<Dingdan> dingdanList = dingdanService.findAll();
return ApiResponse.success(dingdanList);
}
//根据条件(字符类型模糊匹配查询)获取订单数据接口
@IgnoreAuth
@RequestMapping("/search")
public ApiResponse<Dingdan> dingdanSearch(Dingdan req) {
List<Dingdan> dingdanList = dingdanService.find(req);
return ApiResponse.success(dingdanList);
}
//根据条件(字符类型完全匹配查询)获取订单数据接口
@IgnoreAuth
@RequestMapping("/searchByEqualTo")
public ApiResponse<Dingdan> dingdanSearchByEqualTo(Dingdan req) {
List<Dingdan> dingdanList = dingdanService.findByEqualTo(req);
return ApiResponse.success(dingdanList);
}
//按条件查询订单分页数据方法(模糊匹配查询)
private PageData<Dingdan> getPageList(Dingdan req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Dingdan> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Dingdan> dingdanList = dingdanService.findPage(pageWrap);
return dingdanList;
}
//按条件查询订单分页数据方法(完全匹配查询)
private PageData<Dingdan> getPageListByEqualTo(Dingdan req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Dingdan> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Dingdan> dingdanList = dingdanService.findPageByEqualTo(pageWrap);
return dingdanList;
}
//获取订单查询用户数据搜索条件
private PageWrap<Dingdan> getPageWrap(Dingdan req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Dingdan> pageWrap = new PageWrap<>();
pageWrap.setModel(req);
pageWrap.setPageNum(pageNo);
pageWrap.setPageSize(pageSize);
PageWrap.SortData sortData = new PageWrap.SortData();
sortData.setDirection("DESC");
sortData.setProperty(sortProperty);
List<PageWrap.SortData> sorts = new ArrayList<>();
sorts.add(sortData);
pageWrap.setSorts(sorts);
return pageWrap;
}
}

@ -1,178 +0,0 @@
package com.controller;
import com.annotation.IgnoreAuth;
import com.entity.*;
import com.service.*;
import com.util.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName DingdanxiangController
* @Description
*/
@RequestMapping("dingdanxiang")
@RestController
public class DingdanxiangController {
@Autowired
private DingdanxiangService dingdanxiangService;
//前台-根据条件获取订单项列表分页数据接口
@IgnoreAuth
@RequestMapping("/manaqian")
public ApiResponse<Dingdanxiang> manaQian(Dingdanxiang req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Dingdanxiang> dingdanxiangList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(dingdanxiangList);
}
//前台-根据条件获取我的订单项列表分页数据接口
@RequestMapping("/manamyqian")
public ApiResponse<Dingdanxiang> manaMyQian(Dingdanxiang req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Dingdanxiang> dingdanxiangList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(dingdanxiangList);
}
//前台-根据条件获取订单项图片列表分页数据接口
@IgnoreAuth
@RequestMapping("/manaqiantp")
public ApiResponse<Dingdanxiang> manaQianTp(Dingdanxiang req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Dingdanxiang> dingdanxiangList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(dingdanxiangList);
}
//前台-订单项详情
@IgnoreAuth
@RequestMapping("/detail/{id}")
public ApiResponse<Dingdanxiang> detail(@PathVariable("id") Integer id) {
Dingdanxiang info = dingdanxiangService.findById(id);
return ApiResponse.success(info);
}
//前台-订单项添加接口
@PostMapping("/add")
public ApiResponse<Integer> add(@RequestBody Dingdanxiang req) {
int result = dingdanxiangService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//后台-根据条件获取订单项管理列表分页数据接口
@RequestMapping("/mana")
public ApiResponse<Dingdanxiang> mana(Dingdanxiang req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Dingdanxiang> dingdanxiangList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(dingdanxiangList);
}
//后台-根据条件获取订单项管理我的列表分页数据接口
@RequestMapping("/manamy")
public ApiResponse<Dingdanxiang> manaMy(Dingdanxiang req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Dingdanxiang> dingdanxiangList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(dingdanxiangList);
}
//后台-根据条件获取订单项查看列表分页数据接口
@RequestMapping("/chakan")
public ApiResponse<Dingdanxiang> chakan(Dingdanxiang req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Dingdanxiang> dingdanxiangList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(dingdanxiangList);
}
//后台-根据条件获取订单项查看我的列表分页数据接口
@RequestMapping("/chakanmy")
public ApiResponse<Dingdanxiang> chakanMy(Dingdanxiang req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Dingdanxiang> dingdanxiangList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(dingdanxiangList);
}
//后台-订单项详情
@RequestMapping("/info/{id}")
public ApiResponse<Dingdanxiang> info(@PathVariable("id") Integer id) {
Dingdanxiang info = dingdanxiangService.findById(id);
return ApiResponse.success(info);
}
//后台-订单项添加接口
@PostMapping("/save")
public ApiResponse<Integer> save(@RequestBody Dingdanxiang req) {
int result = dingdanxiangService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//订单项删除(含批量删除)接口
@RequestMapping("/delete")
public ApiResponse<Integer> delete(@RequestBody Integer[] ids) {
int result = 0;
for (Integer id : ids) {
result = dingdanxiangService.deleteById(id);
}
return ApiResponse.success(result);
}
//订单项修改接口
@PostMapping("/set")
public ApiResponse<Integer> set(@RequestBody Dingdanxiang req) {
int result = dingdanxiangService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//获取所有订单项数据接口
@IgnoreAuth
@RequestMapping("/all")
public ApiResponse<Dingdanxiang> dingdanxiangAll() {
List<Dingdanxiang> dingdanxiangList = dingdanxiangService.findAll();
return ApiResponse.success(dingdanxiangList);
}
//根据条件(字符类型模糊匹配查询)获取订单项数据接口
@IgnoreAuth
@RequestMapping("/search")
public ApiResponse<Dingdanxiang> dingdanxiangSearch(Dingdanxiang req) {
List<Dingdanxiang> dingdanxiangList = dingdanxiangService.find(req);
return ApiResponse.success(dingdanxiangList);
}
//根据条件(字符类型完全匹配查询)获取订单项数据接口
@IgnoreAuth
@RequestMapping("/searchByEqualTo")
public ApiResponse<Dingdanxiang> dingdanxiangSearchByEqualTo(Dingdanxiang req) {
List<Dingdanxiang> dingdanxiangList = dingdanxiangService.findByEqualTo(req);
return ApiResponse.success(dingdanxiangList);
}
//按条件查询订单项分页数据方法(模糊匹配查询)
private PageData<Dingdanxiang> getPageList(Dingdanxiang req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Dingdanxiang> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Dingdanxiang> dingdanxiangList = dingdanxiangService.findPage(pageWrap);
return dingdanxiangList;
}
//按条件查询订单项分页数据方法(完全匹配查询)
private PageData<Dingdanxiang> getPageListByEqualTo(Dingdanxiang req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Dingdanxiang> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Dingdanxiang> dingdanxiangList = dingdanxiangService.findPageByEqualTo(pageWrap);
return dingdanxiangList;
}
//获取订单项查询数据搜索条件
private PageWrap<Dingdanxiang> getPageWrap(Dingdanxiang req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Dingdanxiang> pageWrap = new PageWrap<>();
pageWrap.setModel(req);
pageWrap.setPageNum(pageNo);
pageWrap.setPageSize(pageSize);
PageWrap.SortData sortData = new PageWrap.SortData();
sortData.setDirection("DESC");
sortData.setProperty(sortProperty);
List<PageWrap.SortData> sorts = new ArrayList<>();
sorts.add(sortData);
pageWrap.setSorts(sorts);
return pageWrap;
}
}

@ -1,178 +0,0 @@
package com.controller;
import com.annotation.IgnoreAuth;
import com.entity.*;
import com.service.*;
import com.util.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName DxController
* @Description
*/
@RequestMapping("dx")
@RestController
public class DxController {
@Autowired
private DxService dxService;
//前台-根据条件获取信息介绍列表分页数据接口
@IgnoreAuth
@RequestMapping("/manaqian")
public ApiResponse<Dx> manaQian(Dx req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Dx> dxList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(dxList);
}
//前台-根据条件获取我的信息介绍列表分页数据接口
@RequestMapping("/manamyqian")
public ApiResponse<Dx> manaMyQian(Dx req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Dx> dxList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(dxList);
}
//前台-根据条件获取信息介绍图片列表分页数据接口
@IgnoreAuth
@RequestMapping("/manaqiantp")
public ApiResponse<Dx> manaQianTp(Dx req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Dx> dxList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(dxList);
}
//前台-信息介绍详情
@IgnoreAuth
@RequestMapping("/detail/{id}")
public ApiResponse<Dx> detail(@PathVariable("id") Integer id) {
Dx info = dxService.findById(id);
return ApiResponse.success(info);
}
//前台-信息介绍添加接口
@PostMapping("/add")
public ApiResponse<Integer> add(@RequestBody Dx req) {
int result = dxService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//后台-根据条件获取信息介绍管理列表分页数据接口
@RequestMapping("/mana")
public ApiResponse<Dx> mana(Dx req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Dx> dxList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(dxList);
}
//后台-根据条件获取信息介绍管理我的列表分页数据接口
@RequestMapping("/manamy")
public ApiResponse<Dx> manaMy(Dx req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Dx> dxList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(dxList);
}
//后台-根据条件获取信息介绍查看列表分页数据接口
@RequestMapping("/chakan")
public ApiResponse<Dx> chakan(Dx req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Dx> dxList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(dxList);
}
//后台-根据条件获取信息介绍查看我的列表分页数据接口
@RequestMapping("/chakanmy")
public ApiResponse<Dx> chakanMy(Dx req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Dx> dxList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(dxList);
}
//后台-信息介绍详情
@RequestMapping("/info/{id}")
public ApiResponse<Dx> info(@PathVariable("id") Integer id) {
Dx info = dxService.findById(id);
return ApiResponse.success(info);
}
//后台-信息介绍添加接口
@PostMapping("/save")
public ApiResponse<Integer> save(@RequestBody Dx req) {
int result = dxService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//信息介绍删除(含批量删除)接口
@RequestMapping("/delete")
public ApiResponse<Integer> delete(@RequestBody Integer[] ids) {
int result = 0;
for (Integer id : ids) {
result = dxService.deleteById(id);
}
return ApiResponse.success(result);
}
//信息介绍修改接口
@PostMapping("/set")
public ApiResponse<Integer> set(@RequestBody Dx req) {
int result = dxService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//获取所有信息介绍数据接口
@IgnoreAuth
@RequestMapping("/all")
public ApiResponse<Dx> dxAll() {
List<Dx> dxList = dxService.findAll();
return ApiResponse.success(dxList);
}
//根据条件(字符类型模糊匹配查询)获取信息介绍数据接口
@IgnoreAuth
@RequestMapping("/search")
public ApiResponse<Dx> dxSearch(Dx req) {
List<Dx> dxList = dxService.find(req);
return ApiResponse.success(dxList);
}
//根据条件(字符类型完全匹配查询)获取信息介绍数据接口
@IgnoreAuth
@RequestMapping("/searchByEqualTo")
public ApiResponse<Dx> dxSearchByEqualTo(Dx req) {
List<Dx> dxList = dxService.findByEqualTo(req);
return ApiResponse.success(dxList);
}
//按条件查询信息介绍分页数据方法(模糊匹配查询)
private PageData<Dx> getPageList(Dx req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Dx> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Dx> dxList = dxService.findPage(pageWrap);
return dxList;
}
//按条件查询信息介绍分页数据方法(完全匹配查询)
private PageData<Dx> getPageListByEqualTo(Dx req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Dx> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Dx> dxList = dxService.findPageByEqualTo(pageWrap);
return dxList;
}
//获取信息介绍查询数据搜索条件
private PageWrap<Dx> getPageWrap(Dx req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Dx> pageWrap = new PageWrap<>();
pageWrap.setModel(req);
pageWrap.setPageNum(pageNo);
pageWrap.setPageSize(pageSize);
PageWrap.SortData sortData = new PageWrap.SortData();
sortData.setDirection("DESC");
sortData.setProperty(sortProperty);
List<PageWrap.SortData> sorts = new ArrayList<>();
sorts.add(sortData);
pageWrap.setSorts(sorts);
return pageWrap;
}
}

@ -1,178 +0,0 @@
package com.controller;
import com.annotation.IgnoreAuth;
import com.entity.*;
import com.service.*;
import com.util.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName GonggaoController
* @Description
*/
@RequestMapping("gonggao")
@RestController
public class GonggaoController {
@Autowired
private GonggaoService gonggaoService;
//前台-根据条件获取公告列表分页数据接口
@IgnoreAuth
@RequestMapping("/manaqian")
public ApiResponse<Gonggao> manaQian(Gonggao req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Gonggao> gonggaoList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(gonggaoList);
}
//前台-根据条件获取我的公告列表分页数据接口
@RequestMapping("/manamyqian")
public ApiResponse<Gonggao> manaMyQian(Gonggao req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Gonggao> gonggaoList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(gonggaoList);
}
//前台-根据条件获取公告图片列表分页数据接口
@IgnoreAuth
@RequestMapping("/manaqiantp")
public ApiResponse<Gonggao> manaQianTp(Gonggao req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Gonggao> gonggaoList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(gonggaoList);
}
//前台-公告详情
@IgnoreAuth
@RequestMapping("/detail/{id}")
public ApiResponse<Gonggao> detail(@PathVariable("id") Integer id) {
Gonggao info = gonggaoService.findById(id);
return ApiResponse.success(info);
}
//前台-公告添加接口
@PostMapping("/add")
public ApiResponse<Integer> add(@RequestBody Gonggao req) {
int result = gonggaoService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//后台-根据条件获取公告管理列表分页数据接口
@RequestMapping("/mana")
public ApiResponse<Gonggao> mana(Gonggao req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Gonggao> gonggaoList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(gonggaoList);
}
//后台-根据条件获取公告管理我的列表分页数据接口
@RequestMapping("/manamy")
public ApiResponse<Gonggao> manaMy(Gonggao req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Gonggao> gonggaoList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(gonggaoList);
}
//后台-根据条件获取公告查看列表分页数据接口
@RequestMapping("/chakan")
public ApiResponse<Gonggao> chakan(Gonggao req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Gonggao> gonggaoList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(gonggaoList);
}
//后台-根据条件获取公告查看我的列表分页数据接口
@RequestMapping("/chakanmy")
public ApiResponse<Gonggao> chakanMy(Gonggao req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Gonggao> gonggaoList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(gonggaoList);
}
//后台-公告详情
@RequestMapping("/info/{id}")
public ApiResponse<Gonggao> info(@PathVariable("id") Integer id) {
Gonggao info = gonggaoService.findById(id);
return ApiResponse.success(info);
}
//后台-公告添加接口
@PostMapping("/save")
public ApiResponse<Integer> save(@RequestBody Gonggao req) {
int result = gonggaoService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//公告删除(含批量删除)接口
@RequestMapping("/delete")
public ApiResponse<Integer> delete(@RequestBody Integer[] ids) {
int result = 0;
for (Integer id : ids) {
result = gonggaoService.deleteById(id);
}
return ApiResponse.success(result);
}
//公告修改接口
@PostMapping("/set")
public ApiResponse<Integer> set(@RequestBody Gonggao req) {
int result = gonggaoService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//获取所有公告数据接口
@IgnoreAuth
@RequestMapping("/all")
public ApiResponse<Gonggao> gonggaoAll() {
List<Gonggao> gonggaoList = gonggaoService.findAll();
return ApiResponse.success(gonggaoList);
}
//根据条件(字符类型模糊匹配查询)获取公告数据接口
@IgnoreAuth
@RequestMapping("/search")
public ApiResponse<Gonggao> gonggaoSearch(Gonggao req) {
List<Gonggao> gonggaoList = gonggaoService.find(req);
return ApiResponse.success(gonggaoList);
}
//根据条件(字符类型完全匹配查询)获取公告数据接口
@IgnoreAuth
@RequestMapping("/searchByEqualTo")
public ApiResponse<Gonggao> gonggaoSearchByEqualTo(Gonggao req) {
List<Gonggao> gonggaoList = gonggaoService.findByEqualTo(req);
return ApiResponse.success(gonggaoList);
}
//按条件查询公告分页数据方法(模糊匹配查询)
private PageData<Gonggao> getPageList(Gonggao req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Gonggao> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Gonggao> gonggaoList = gonggaoService.findPage(pageWrap);
return gonggaoList;
}
//按条件查询公告分页数据方法(完全匹配查询)
private PageData<Gonggao> getPageListByEqualTo(Gonggao req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Gonggao> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Gonggao> gonggaoList = gonggaoService.findPageByEqualTo(pageWrap);
return gonggaoList;
}
//获取公告查询数据搜索条件
private PageWrap<Gonggao> getPageWrap(Gonggao req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Gonggao> pageWrap = new PageWrap<>();
pageWrap.setModel(req);
pageWrap.setPageNum(pageNo);
pageWrap.setPageSize(pageSize);
PageWrap.SortData sortData = new PageWrap.SortData();
sortData.setDirection("DESC");
sortData.setProperty(sortProperty);
List<PageWrap.SortData> sorts = new ArrayList<>();
sorts.add(sortData);
pageWrap.setSorts(sorts);
return pageWrap;
}
}

@ -1,244 +0,0 @@
package com.controller;
import com.annotation.IgnoreAuth;
import com.entity.*;
import com.service.*;
import com.util.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpSession;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName GouwucheController
* @Description
*/
@RequestMapping("gouwuche")
@RestController
public class GouwucheController {
@Autowired
private GouwucheService gouwucheService;
@Autowired
private ShangpinService shangpinService;
//前台-根据条件获取购物车列表分页数据接口
@RequestMapping("/manaqian")
public ApiResponse<Gouwuche> manaQian(Gouwuche req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Gouwuche> gouwucheList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(gouwucheList);
}
//前台-根据条件获取我的购物车列表分页数据接口
@RequestMapping("/manamyqian")
public ApiResponse<Gouwuche> manaMyQian(Gouwuche req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Gouwuche> gouwucheList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(gouwucheList);
}
//前台-根据条件获取购物车图片列表分页数据接口
@RequestMapping("/manaqiantp")
public ApiResponse<Gouwuche> manaQianTp(Gouwuche req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Gouwuche> gouwucheList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(gouwucheList);
}
//前台-购物车详情
@RequestMapping("/detail/{id}")
public ApiResponse<Gouwuche> detail(@PathVariable("id") Integer id) {
Gouwuche info = gouwucheService.findById(id);
return ApiResponse.success(info);
}
//前台-购物车添加接口
@PostMapping("/add")
public ApiResponse<Integer> add(@RequestBody Gouwuche req, HttpSession session) {
//判断商品是否已存在购物车
Users users = (Users) session.getAttribute("users");
if (null != req && null != req.getShangpinid() && null != users && null != users.getId()) {
Gouwuche instance = new Gouwuche();
instance.setUsersid(users.getId());
instance.setShangpinid(req.getShangpinid());
List<Gouwuche> gouwucheList = gouwucheService.find(instance);
if (gouwucheList.size() > 0) {
//我的购物车已有此商品,则增加数量
Gouwuche gouwuche = gouwucheList.get(0);
Integer ishuliang = gouwuche.getGoumaishuliang();
Integer ishuliangadd = req.getGoumaishuliang();
req.setId(gouwuche.getId());
req.setGoumaishuliang((ishuliang + ishuliangadd));
}
} else {
return ApiResponse.failed("数据不存在");
}
int result = gouwucheService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//后台-根据条件获取购物车管理列表分页数据接口
@RequestMapping("/mana")
public ApiResponse<Gouwuche> mana(Gouwuche req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Gouwuche> gouwucheList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(gouwucheList);
}
//后台-根据条件获取购物车管理我的列表分页数据接口
@RequestMapping("/manamy")
public ApiResponse<Gouwuche> manaMy(Gouwuche req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Gouwuche> gouwucheList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(gouwucheList);
}
//后台-根据条件获取购物车查看列表分页数据接口
@RequestMapping("/chakan")
public ApiResponse<Gouwuche> chakan(Gouwuche req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Gouwuche> gouwucheList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(gouwucheList);
}
//后台-根据条件获取购物车查看我的列表分页数据接口
@RequestMapping("/chakanmy")
public ApiResponse<Gouwuche> chakanMy(Gouwuche req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Gouwuche> gouwucheList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(gouwucheList);
}
//后台-购物车详情
@RequestMapping("/info/{id}")
public ApiResponse<Gouwuche> info(@PathVariable("id") Integer id) {
Gouwuche info = gouwucheService.findById(id);
return ApiResponse.success(info);
}
//后台-购物车添加接口
@PostMapping("/save")
public ApiResponse<Integer> save(@RequestBody Gouwuche req, HttpSession session) {
//判断商品是否已存在购物车
Users users = (Users) session.getAttribute("users");
if (null != req && null != req.getShangpinid() && null != users && null != users.getId()) {
Gouwuche instance = new Gouwuche();
instance.setUsersid(users.getId());
instance.setShangpinid(req.getShangpinid());
List<Gouwuche> gouwucheList = gouwucheService.find(instance);
if (gouwucheList.size() > 0) {
//我的购物车已有此商品,则增加数量
Gouwuche gouwuche = gouwucheList.get(0);
Integer ishuliang = gouwuche.getGoumaishuliang();
Integer ishuliangadd = req.getGoumaishuliang();
req.setId(gouwuche.getId());
req.setGoumaishuliang((ishuliang + ishuliangadd));
}
} else {
return ApiResponse.failed("数据不存在");
}
int result = gouwucheService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//购物车删除(含批量删除)接口
@RequestMapping("/delete")
public ApiResponse<Integer> delete(@RequestBody Integer[] ids) {
int result = 0;
for (Integer id : ids) {
result = gouwucheService.deleteById(id);
}
return ApiResponse.success(result);
}
//购物车修改接口
@PostMapping("/set")
public ApiResponse<Integer> set(@RequestBody Gouwuche req) {
int result = gouwucheService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//获取所有购物车数据接口
@RequestMapping("/all")
public ApiResponse<Gouwuche> gouwucheAll() {
List<Gouwuche> gouwucheList = gouwucheService.findAll();
return ApiResponse.success(gouwucheList);
}
//根据条件获取订单总金额接口
@RequestMapping("/totalamount")
public ApiResponse<Integer> getTotalamount(Gouwuche req) {
//计算购物车总金额
Integer totalAmount = 0;
List<Gouwuche> gouwucheList = gouwucheService.find(req);
for (Gouwuche gouwuche : gouwucheList) {
Integer shangpinid = gouwuche.getShangpinid();
if (null != shangpinid && shangpinid > 0) {
Shangpin shangpin = shangpinService.findById(shangpinid);
if (null != shangpin) {
totalAmount += gouwuche.getGoumaishuliang() * shangpin.getJiage();
}
}
}
return ApiResponse.success(totalAmount);
}
//购物车提交订单
@PostMapping("/submitdingdan")
@ResponseBody
public ApiResponse<Integer> submitDingdan(@RequestBody(required = false) List<Gouwuche> gouwucheList, HttpSession session) {
Users users = (Users) session.getAttribute("users");
if (null != gouwucheList && gouwucheList.size() > 0 && null != users && null != users.getId()) {
for (Gouwuche gouwuche : gouwucheList) {
if (null != gouwuche.getId()) {
gouwucheService.saveOrUpdate(gouwuche);
}
}
} else {
return ApiResponse.failed("数据不存在");
}
return ApiResponse.success(1);
}
//根据条件(字符类型模糊匹配查询)获取购物车数据接口
@RequestMapping("/search")
public ApiResponse<Gouwuche> gouwucheSearch(Gouwuche req) {
List<Gouwuche> gouwucheList = gouwucheService.find(req);
return ApiResponse.success(gouwucheList);
}
//根据条件(字符类型完全匹配查询)获取购物车数据接口
@RequestMapping("/searchByEqualTo")
public ApiResponse<Gouwuche> gouwucheSearchByEqualTo(Gouwuche req) {
List<Gouwuche> gouwucheList = gouwucheService.findByEqualTo(req);
return ApiResponse.success(gouwucheList);
}
//按条件查询购物车分页数据方法(模糊匹配查询)
private PageData<Gouwuche> getPageList(Gouwuche req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Gouwuche> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Gouwuche> gouwucheList = gouwucheService.findPage(pageWrap);
return gouwucheList;
}
//按条件查询购物车分页数据方法(完全匹配查询)
private PageData<Gouwuche> getPageListByEqualTo(Gouwuche req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Gouwuche> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Gouwuche> gouwucheList = gouwucheService.findPageByEqualTo(pageWrap);
return gouwucheList;
}
//获取购物车查询数据搜索条件
private PageWrap<Gouwuche> getPageWrap(Gouwuche req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Gouwuche> pageWrap = new PageWrap<>();
pageWrap.setModel(req);
pageWrap.setPageNum(pageNo);
pageWrap.setPageSize(pageSize);
PageWrap.SortData sortData = new PageWrap.SortData();
sortData.setDirection("DESC");
sortData.setProperty(sortProperty);
List<PageWrap.SortData> sorts = new ArrayList<>();
sorts.add(sortData);
pageWrap.setSorts(sorts);
return pageWrap;
}
}

@ -1,178 +0,0 @@
package com.controller;
import com.annotation.IgnoreAuth;
import com.entity.*;
import com.service.*;
import com.util.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName LianjieController
* @Description
*/
@RequestMapping("lianjie")
@RestController
public class LianjieController {
@Autowired
private LianjieService lianjieService;
//前台-根据条件获取友情链接列表分页数据接口
@IgnoreAuth
@RequestMapping("/manaqian")
public ApiResponse<Lianjie> manaQian(Lianjie req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Lianjie> lianjieList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(lianjieList);
}
//前台-根据条件获取我的友情链接列表分页数据接口
@RequestMapping("/manamyqian")
public ApiResponse<Lianjie> manaMyQian(Lianjie req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Lianjie> lianjieList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(lianjieList);
}
//前台-根据条件获取友情链接图片列表分页数据接口
@IgnoreAuth
@RequestMapping("/manaqiantp")
public ApiResponse<Lianjie> manaQianTp(Lianjie req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Lianjie> lianjieList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(lianjieList);
}
//前台-友情链接详情
@IgnoreAuth
@RequestMapping("/detail/{id}")
public ApiResponse<Lianjie> detail(@PathVariable("id") Integer id) {
Lianjie info = lianjieService.findById(id);
return ApiResponse.success(info);
}
//前台-友情链接添加接口
@PostMapping("/add")
public ApiResponse<Integer> add(@RequestBody Lianjie req) {
int result = lianjieService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//后台-根据条件获取友情链接管理列表分页数据接口
@RequestMapping("/mana")
public ApiResponse<Lianjie> mana(Lianjie req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Lianjie> lianjieList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(lianjieList);
}
//后台-根据条件获取友情链接管理我的列表分页数据接口
@RequestMapping("/manamy")
public ApiResponse<Lianjie> manaMy(Lianjie req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Lianjie> lianjieList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(lianjieList);
}
//后台-根据条件获取友情链接查看列表分页数据接口
@RequestMapping("/chakan")
public ApiResponse<Lianjie> chakan(Lianjie req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Lianjie> lianjieList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(lianjieList);
}
//后台-根据条件获取友情链接查看我的列表分页数据接口
@RequestMapping("/chakanmy")
public ApiResponse<Lianjie> chakanMy(Lianjie req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Lianjie> lianjieList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(lianjieList);
}
//后台-友情链接详情
@RequestMapping("/info/{id}")
public ApiResponse<Lianjie> info(@PathVariable("id") Integer id) {
Lianjie info = lianjieService.findById(id);
return ApiResponse.success(info);
}
//后台-友情链接添加接口
@PostMapping("/save")
public ApiResponse<Integer> save(@RequestBody Lianjie req) {
int result = lianjieService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//友情链接删除(含批量删除)接口
@RequestMapping("/delete")
public ApiResponse<Integer> delete(@RequestBody Integer[] ids) {
int result = 0;
for (Integer id : ids) {
result = lianjieService.deleteById(id);
}
return ApiResponse.success(result);
}
//友情链接修改接口
@PostMapping("/set")
public ApiResponse<Integer> set(@RequestBody Lianjie req) {
int result = lianjieService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//获取所有友情链接数据接口
@IgnoreAuth
@RequestMapping("/all")
public ApiResponse<Lianjie> lianjieAll() {
List<Lianjie> lianjieList = lianjieService.findAll();
return ApiResponse.success(lianjieList);
}
//根据条件(字符类型模糊匹配查询)获取友情链接数据接口
@IgnoreAuth
@RequestMapping("/search")
public ApiResponse<Lianjie> lianjieSearch(Lianjie req) {
List<Lianjie> lianjieList = lianjieService.find(req);
return ApiResponse.success(lianjieList);
}
//根据条件(字符类型完全匹配查询)获取友情链接数据接口
@IgnoreAuth
@RequestMapping("/searchByEqualTo")
public ApiResponse<Lianjie> lianjieSearchByEqualTo(Lianjie req) {
List<Lianjie> lianjieList = lianjieService.findByEqualTo(req);
return ApiResponse.success(lianjieList);
}
//按条件查询友情链接分页数据方法(模糊匹配查询)
private PageData<Lianjie> getPageList(Lianjie req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Lianjie> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Lianjie> lianjieList = lianjieService.findPage(pageWrap);
return lianjieList;
}
//按条件查询友情链接分页数据方法(完全匹配查询)
private PageData<Lianjie> getPageListByEqualTo(Lianjie req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Lianjie> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Lianjie> lianjieList = lianjieService.findPageByEqualTo(pageWrap);
return lianjieList;
}
//获取友情链接查询数据搜索条件
private PageWrap<Lianjie> getPageWrap(Lianjie req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Lianjie> pageWrap = new PageWrap<>();
pageWrap.setModel(req);
pageWrap.setPageNum(pageNo);
pageWrap.setPageSize(pageSize);
PageWrap.SortData sortData = new PageWrap.SortData();
sortData.setDirection("DESC");
sortData.setProperty(sortProperty);
List<PageWrap.SortData> sorts = new ArrayList<>();
sorts.add(sortData);
pageWrap.setSorts(sorts);
return pageWrap;
}
}

@ -1,178 +0,0 @@
package com.controller;
import com.annotation.IgnoreAuth;
import com.entity.*;
import com.service.*;
import com.util.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName LiuyanController
* @Description
*/
@RequestMapping("liuyan")
@RestController
public class LiuyanController {
@Autowired
private LiuyanService liuyanService;
//前台-根据条件获取留言反馈列表分页数据接口
@IgnoreAuth
@RequestMapping("/manaqian")
public ApiResponse<Liuyan> manaQian(Liuyan req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Liuyan> liuyanList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(liuyanList);
}
//前台-根据条件获取我的留言反馈列表分页数据接口
@RequestMapping("/manamyqian")
public ApiResponse<Liuyan> manaMyQian(Liuyan req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Liuyan> liuyanList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(liuyanList);
}
//前台-根据条件获取留言反馈图片列表分页数据接口
@IgnoreAuth
@RequestMapping("/manaqiantp")
public ApiResponse<Liuyan> manaQianTp(Liuyan req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Liuyan> liuyanList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(liuyanList);
}
//前台-留言反馈详情
@IgnoreAuth
@RequestMapping("/detail/{id}")
public ApiResponse<Liuyan> detail(@PathVariable("id") Integer id) {
Liuyan info = liuyanService.findById(id);
return ApiResponse.success(info);
}
//前台-留言反馈添加接口
@PostMapping("/add")
public ApiResponse<Integer> add(@RequestBody Liuyan req) {
int result = liuyanService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//后台-根据条件获取留言反馈管理列表分页数据接口
@RequestMapping("/mana")
public ApiResponse<Liuyan> mana(Liuyan req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Liuyan> liuyanList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(liuyanList);
}
//后台-根据条件获取留言反馈管理我的列表分页数据接口
@RequestMapping("/manamy")
public ApiResponse<Liuyan> manaMy(Liuyan req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Liuyan> liuyanList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(liuyanList);
}
//后台-根据条件获取留言反馈查看列表分页数据接口
@RequestMapping("/chakan")
public ApiResponse<Liuyan> chakan(Liuyan req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Liuyan> liuyanList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(liuyanList);
}
//后台-根据条件获取留言反馈查看我的列表分页数据接口
@RequestMapping("/chakanmy")
public ApiResponse<Liuyan> chakanMy(Liuyan req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Liuyan> liuyanList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(liuyanList);
}
//后台-留言反馈详情
@RequestMapping("/info/{id}")
public ApiResponse<Liuyan> info(@PathVariable("id") Integer id) {
Liuyan info = liuyanService.findById(id);
return ApiResponse.success(info);
}
//后台-留言反馈添加接口
@PostMapping("/save")
public ApiResponse<Integer> save(@RequestBody Liuyan req) {
int result = liuyanService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//留言反馈删除(含批量删除)接口
@RequestMapping("/delete")
public ApiResponse<Integer> delete(@RequestBody Integer[] ids) {
int result = 0;
for (Integer id : ids) {
result = liuyanService.deleteById(id);
}
return ApiResponse.success(result);
}
//留言反馈修改接口
@PostMapping("/set")
public ApiResponse<Integer> set(@RequestBody Liuyan req) {
int result = liuyanService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//获取所有留言反馈数据接口
@IgnoreAuth
@RequestMapping("/all")
public ApiResponse<Liuyan> liuyanAll() {
List<Liuyan> liuyanList = liuyanService.findAll();
return ApiResponse.success(liuyanList);
}
//根据条件(字符类型模糊匹配查询)获取留言反馈数据接口
@IgnoreAuth
@RequestMapping("/search")
public ApiResponse<Liuyan> liuyanSearch(Liuyan req) {
List<Liuyan> liuyanList = liuyanService.find(req);
return ApiResponse.success(liuyanList);
}
//根据条件(字符类型完全匹配查询)获取留言反馈数据接口
@IgnoreAuth
@RequestMapping("/searchByEqualTo")
public ApiResponse<Liuyan> liuyanSearchByEqualTo(Liuyan req) {
List<Liuyan> liuyanList = liuyanService.findByEqualTo(req);
return ApiResponse.success(liuyanList);
}
//按条件查询留言反馈分页数据方法(模糊匹配查询)
private PageData<Liuyan> getPageList(Liuyan req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Liuyan> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Liuyan> liuyanList = liuyanService.findPage(pageWrap);
return liuyanList;
}
//按条件查询留言反馈分页数据方法(完全匹配查询)
private PageData<Liuyan> getPageListByEqualTo(Liuyan req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Liuyan> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Liuyan> liuyanList = liuyanService.findPageByEqualTo(pageWrap);
return liuyanList;
}
//获取留言反馈查询数据搜索条件
private PageWrap<Liuyan> getPageWrap(Liuyan req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Liuyan> pageWrap = new PageWrap<>();
pageWrap.setModel(req);
pageWrap.setPageNum(pageNo);
pageWrap.setPageSize(pageSize);
PageWrap.SortData sortData = new PageWrap.SortData();
sortData.setDirection("DESC");
sortData.setProperty(sortProperty);
List<PageWrap.SortData> sorts = new ArrayList<>();
sorts.add(sortData);
pageWrap.setSorts(sorts);
return pageWrap;
}
}

@ -1,66 +0,0 @@
package com.controller;
import com.annotation.IgnoreAuth;
import com.entity.Users;
import com.service.UsersService;
import com.util.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.util.HashMap;
/**
* @ClassName LoginController
* @Description
*/
@RestController
public class LoginController {
@Autowired
private UsersService usersService;
//登陆验证
@IgnoreAuth
@RequestMapping("/login")
@ResponseBody
public ApiResponse verify(HttpServletRequest request, String loginpw, String type, String loginname) {
String result = "";
Users users = new Users();
users.setLoginname(loginname);
users.setLoginpw(Md5Util.strToMd5(loginpw));
if (null != type && !type.equals("")) {
users.setType(type);
}
users = usersService.findOneByEqualTo(users);
if (null == users || null == users.getId() || users.getId() == 0) {
//返回登录失败
result = "用户名或密码错误";
return ApiResponse.failed(result);
} else {
// if (null == users.getShenhe() || (!users.getShenhe().toLowerCase().equals("yes") && !users.getShenhe().equals("是"))) {
// //未审核返回登录失败
// result = "用户未通过审核,请及时联系管理员处理";
// return ApiResponse.failed(result);
// }
//返回登录成功
String token = CommonUtil.getRandomString(32);
System.out.println("生成token:" + token);
HttpSession session = request.getSession();
session.setAttribute("usersType", users.getType());
session.setAttribute("usersId", users.getId());
session.setAttribute("users", users);
session.setAttribute("token", token);
//session有效时间单位为秒-1表示当前会话内一直有效
session.setMaxInactiveInterval(-1);
HashMap<String,String> loginSuccess=new HashMap<>();
loginSuccess.put("token",token);
loginSuccess.put("usersId",users.getId().toString());
return ApiResponse.success(loginSuccess);
}
}
}

@ -1,178 +0,0 @@
package com.controller;
import com.annotation.IgnoreAuth;
import com.entity.*;
import com.service.*;
import com.util.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName LunboController
* @Description
*/
@RequestMapping("lunbo")
@RestController
public class LunboController {
@Autowired
private LunboService lunboService;
//前台-根据条件获取轮播图列表分页数据接口
@IgnoreAuth
@RequestMapping("/manaqian")
public ApiResponse<Lunbo> manaQian(Lunbo req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Lunbo> lunboList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(lunboList);
}
//前台-根据条件获取我的轮播图列表分页数据接口
@RequestMapping("/manamyqian")
public ApiResponse<Lunbo> manaMyQian(Lunbo req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Lunbo> lunboList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(lunboList);
}
//前台-根据条件获取轮播图图片列表分页数据接口
@IgnoreAuth
@RequestMapping("/manaqiantp")
public ApiResponse<Lunbo> manaQianTp(Lunbo req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Lunbo> lunboList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(lunboList);
}
//前台-轮播图详情
@IgnoreAuth
@RequestMapping("/detail/{id}")
public ApiResponse<Lunbo> detail(@PathVariable("id") Integer id) {
Lunbo info = lunboService.findById(id);
return ApiResponse.success(info);
}
//前台-轮播图添加接口
@PostMapping("/add")
public ApiResponse<Integer> add(@RequestBody Lunbo req) {
int result = lunboService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//后台-根据条件获取轮播图管理列表分页数据接口
@RequestMapping("/mana")
public ApiResponse<Lunbo> mana(Lunbo req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Lunbo> lunboList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(lunboList);
}
//后台-根据条件获取轮播图管理我的列表分页数据接口
@RequestMapping("/manamy")
public ApiResponse<Lunbo> manaMy(Lunbo req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Lunbo> lunboList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(lunboList);
}
//后台-根据条件获取轮播图查看列表分页数据接口
@RequestMapping("/chakan")
public ApiResponse<Lunbo> chakan(Lunbo req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Lunbo> lunboList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(lunboList);
}
//后台-根据条件获取轮播图查看我的列表分页数据接口
@RequestMapping("/chakanmy")
public ApiResponse<Lunbo> chakanMy(Lunbo req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Lunbo> lunboList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(lunboList);
}
//后台-轮播图详情
@RequestMapping("/info/{id}")
public ApiResponse<Lunbo> info(@PathVariable("id") Integer id) {
Lunbo info = lunboService.findById(id);
return ApiResponse.success(info);
}
//后台-轮播图添加接口
@PostMapping("/save")
public ApiResponse<Integer> save(@RequestBody Lunbo req) {
int result = lunboService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//轮播图删除(含批量删除)接口
@RequestMapping("/delete")
public ApiResponse<Integer> delete(@RequestBody Integer[] ids) {
int result = 0;
for (Integer id : ids) {
result = lunboService.deleteById(id);
}
return ApiResponse.success(result);
}
//轮播图修改接口
@PostMapping("/set")
public ApiResponse<Integer> set(@RequestBody Lunbo req) {
int result = lunboService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//获取所有轮播图数据接口
@IgnoreAuth
@RequestMapping("/all")
public ApiResponse<Lunbo> lunboAll() {
List<Lunbo> lunboList = lunboService.findAll();
return ApiResponse.success(lunboList);
}
//根据条件(字符类型模糊匹配查询)获取轮播图数据接口
@IgnoreAuth
@RequestMapping("/search")
public ApiResponse<Lunbo> lunboSearch(Lunbo req) {
List<Lunbo> lunboList = lunboService.find(req);
return ApiResponse.success(lunboList);
}
//根据条件(字符类型完全匹配查询)获取轮播图数据接口
@IgnoreAuth
@RequestMapping("/searchByEqualTo")
public ApiResponse<Lunbo> lunboSearchByEqualTo(Lunbo req) {
List<Lunbo> lunboList = lunboService.findByEqualTo(req);
return ApiResponse.success(lunboList);
}
//按条件查询轮播图分页数据方法(模糊匹配查询)
private PageData<Lunbo> getPageList(Lunbo req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Lunbo> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Lunbo> lunboList = lunboService.findPage(pageWrap);
return lunboList;
}
//按条件查询轮播图分页数据方法(完全匹配查询)
private PageData<Lunbo> getPageListByEqualTo(Lunbo req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Lunbo> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Lunbo> lunboList = lunboService.findPageByEqualTo(pageWrap);
return lunboList;
}
//获取轮播图查询数据搜索条件
private PageWrap<Lunbo> getPageWrap(Lunbo req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Lunbo> pageWrap = new PageWrap<>();
pageWrap.setModel(req);
pageWrap.setPageNum(pageNo);
pageWrap.setPageSize(pageSize);
PageWrap.SortData sortData = new PageWrap.SortData();
sortData.setDirection("DESC");
sortData.setProperty(sortProperty);
List<PageWrap.SortData> sorts = new ArrayList<>();
sorts.add(sortData);
pageWrap.setSorts(sorts);
return pageWrap;
}
}

@ -1,178 +0,0 @@
package com.controller;
import com.annotation.IgnoreAuth;
import com.entity.*;
import com.service.*;
import com.util.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName PingjiaController
* @Description
*/
@RequestMapping("pingjia")
@RestController
public class PingjiaController {
@Autowired
private PingjiaService pingjiaService;
//前台-根据条件获取评论列表分页数据接口
@IgnoreAuth
@RequestMapping("/manaqian")
public ApiResponse<Pingjia> manaQian(Pingjia req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Pingjia> pingjiaList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(pingjiaList);
}
//前台-根据条件获取我的评论列表分页数据接口
@RequestMapping("/manamyqian")
public ApiResponse<Pingjia> manaMyQian(Pingjia req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Pingjia> pingjiaList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(pingjiaList);
}
//前台-根据条件获取评论图片列表分页数据接口
@IgnoreAuth
@RequestMapping("/manaqiantp")
public ApiResponse<Pingjia> manaQianTp(Pingjia req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Pingjia> pingjiaList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(pingjiaList);
}
//前台-评论详情
@IgnoreAuth
@RequestMapping("/detail/{id}")
public ApiResponse<Pingjia> detail(@PathVariable("id") Integer id) {
Pingjia info = pingjiaService.findById(id);
return ApiResponse.success(info);
}
//前台-评论添加接口
@PostMapping("/add")
public ApiResponse<Integer> add(@RequestBody Pingjia req) {
int result = pingjiaService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//后台-根据条件获取评论管理列表分页数据接口
@RequestMapping("/mana")
public ApiResponse<Pingjia> mana(Pingjia req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Pingjia> pingjiaList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(pingjiaList);
}
//后台-根据条件获取评论管理我的列表分页数据接口
@RequestMapping("/manamy")
public ApiResponse<Pingjia> manaMy(Pingjia req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Pingjia> pingjiaList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(pingjiaList);
}
//后台-根据条件获取评论查看列表分页数据接口
@RequestMapping("/chakan")
public ApiResponse<Pingjia> chakan(Pingjia req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Pingjia> pingjiaList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(pingjiaList);
}
//后台-根据条件获取评论查看我的列表分页数据接口
@RequestMapping("/chakanmy")
public ApiResponse<Pingjia> chakanMy(Pingjia req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Pingjia> pingjiaList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(pingjiaList);
}
//后台-评论详情
@RequestMapping("/info/{id}")
public ApiResponse<Pingjia> info(@PathVariable("id") Integer id) {
Pingjia info = pingjiaService.findById(id);
return ApiResponse.success(info);
}
//后台-评论添加接口
@PostMapping("/save")
public ApiResponse<Integer> save(@RequestBody Pingjia req) {
int result = pingjiaService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//评论删除(含批量删除)接口
@RequestMapping("/delete")
public ApiResponse<Integer> delete(@RequestBody Integer[] ids) {
int result = 0;
for (Integer id : ids) {
result = pingjiaService.deleteById(id);
}
return ApiResponse.success(result);
}
//评论修改接口
@PostMapping("/set")
public ApiResponse<Integer> set(@RequestBody Pingjia req) {
int result = pingjiaService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//获取所有评论数据接口
@IgnoreAuth
@RequestMapping("/all")
public ApiResponse<Pingjia> pingjiaAll() {
List<Pingjia> pingjiaList = pingjiaService.findAll();
return ApiResponse.success(pingjiaList);
}
//根据条件(字符类型模糊匹配查询)获取评论数据接口
@IgnoreAuth
@RequestMapping("/search")
public ApiResponse<Pingjia> pingjiaSearch(Pingjia req) {
List<Pingjia> pingjiaList = pingjiaService.find(req);
return ApiResponse.success(pingjiaList);
}
//根据条件(字符类型完全匹配查询)获取评论数据接口
@IgnoreAuth
@RequestMapping("/searchByEqualTo")
public ApiResponse<Pingjia> pingjiaSearchByEqualTo(Pingjia req) {
List<Pingjia> pingjiaList = pingjiaService.findByEqualTo(req);
return ApiResponse.success(pingjiaList);
}
//按条件查询评论分页数据方法(模糊匹配查询)
private PageData<Pingjia> getPageList(Pingjia req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Pingjia> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Pingjia> pingjiaList = pingjiaService.findPage(pageWrap);
return pingjiaList;
}
//按条件查询评论分页数据方法(完全匹配查询)
private PageData<Pingjia> getPageListByEqualTo(Pingjia req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Pingjia> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Pingjia> pingjiaList = pingjiaService.findPageByEqualTo(pageWrap);
return pingjiaList;
}
//获取评论查询数据搜索条件
private PageWrap<Pingjia> getPageWrap(Pingjia req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Pingjia> pageWrap = new PageWrap<>();
pageWrap.setModel(req);
pageWrap.setPageNum(pageNo);
pageWrap.setPageSize(pageSize);
PageWrap.SortData sortData = new PageWrap.SortData();
sortData.setDirection("DESC");
sortData.setProperty(sortProperty);
List<PageWrap.SortData> sorts = new ArrayList<>();
sorts.add(sortData);
pageWrap.setSorts(sorts);
return pageWrap;
}
}

@ -1,178 +0,0 @@
package com.controller;
import com.annotation.IgnoreAuth;
import com.entity.*;
import com.service.*;
import com.util.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName PinleiController
* @Description
*/
@RequestMapping("pinlei")
@RestController
public class PinleiController {
@Autowired
private PinleiService pinleiService;
//前台-根据条件获取分类列表分页数据接口
@IgnoreAuth
@RequestMapping("/manaqian")
public ApiResponse<Pinlei> manaQian(Pinlei req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Pinlei> pinleiList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(pinleiList);
}
//前台-根据条件获取我的分类列表分页数据接口
@RequestMapping("/manamyqian")
public ApiResponse<Pinlei> manaMyQian(Pinlei req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Pinlei> pinleiList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(pinleiList);
}
//前台-根据条件获取分类图片列表分页数据接口
@IgnoreAuth
@RequestMapping("/manaqiantp")
public ApiResponse<Pinlei> manaQianTp(Pinlei req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Pinlei> pinleiList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(pinleiList);
}
//前台-分类详情
@IgnoreAuth
@RequestMapping("/detail/{id}")
public ApiResponse<Pinlei> detail(@PathVariable("id") Integer id) {
Pinlei info = pinleiService.findById(id);
return ApiResponse.success(info);
}
//前台-分类添加接口
@PostMapping("/add")
public ApiResponse<Integer> add(@RequestBody Pinlei req) {
int result = pinleiService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//后台-根据条件获取分类管理列表分页数据接口
@RequestMapping("/mana")
public ApiResponse<Pinlei> mana(Pinlei req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Pinlei> pinleiList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(pinleiList);
}
//后台-根据条件获取分类管理我的列表分页数据接口
@RequestMapping("/manamy")
public ApiResponse<Pinlei> manaMy(Pinlei req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Pinlei> pinleiList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(pinleiList);
}
//后台-根据条件获取分类查看列表分页数据接口
@RequestMapping("/chakan")
public ApiResponse<Pinlei> chakan(Pinlei req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Pinlei> pinleiList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(pinleiList);
}
//后台-根据条件获取分类查看我的列表分页数据接口
@RequestMapping("/chakanmy")
public ApiResponse<Pinlei> chakanMy(Pinlei req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Pinlei> pinleiList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(pinleiList);
}
//后台-分类详情
@RequestMapping("/info/{id}")
public ApiResponse<Pinlei> info(@PathVariable("id") Integer id) {
Pinlei info = pinleiService.findById(id);
return ApiResponse.success(info);
}
//后台-分类添加接口
@PostMapping("/save")
public ApiResponse<Integer> save(@RequestBody Pinlei req) {
int result = pinleiService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//分类删除(含批量删除)接口
@RequestMapping("/delete")
public ApiResponse<Integer> delete(@RequestBody Integer[] ids) {
int result = 0;
for (Integer id : ids) {
result = pinleiService.deleteById(id);
}
return ApiResponse.success(result);
}
//分类修改接口
@PostMapping("/set")
public ApiResponse<Integer> set(@RequestBody Pinlei req) {
int result = pinleiService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//获取所有分类数据接口
@IgnoreAuth
@RequestMapping("/all")
public ApiResponse<Pinlei> pinleiAll() {
List<Pinlei> pinleiList = pinleiService.findAll();
return ApiResponse.success(pinleiList);
}
//根据条件(字符类型模糊匹配查询)获取分类数据接口
@IgnoreAuth
@RequestMapping("/search")
public ApiResponse<Pinlei> pinleiSearch(Pinlei req) {
List<Pinlei> pinleiList = pinleiService.find(req);
return ApiResponse.success(pinleiList);
}
//根据条件(字符类型完全匹配查询)获取分类数据接口
@IgnoreAuth
@RequestMapping("/searchByEqualTo")
public ApiResponse<Pinlei> pinleiSearchByEqualTo(Pinlei req) {
List<Pinlei> pinleiList = pinleiService.findByEqualTo(req);
return ApiResponse.success(pinleiList);
}
//按条件查询分类分页数据方法(模糊匹配查询)
private PageData<Pinlei> getPageList(Pinlei req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Pinlei> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Pinlei> pinleiList = pinleiService.findPage(pageWrap);
return pinleiList;
}
//按条件查询分类分页数据方法(完全匹配查询)
private PageData<Pinlei> getPageListByEqualTo(Pinlei req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Pinlei> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Pinlei> pinleiList = pinleiService.findPageByEqualTo(pageWrap);
return pinleiList;
}
//获取分类查询数据搜索条件
private PageWrap<Pinlei> getPageWrap(Pinlei req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Pinlei> pageWrap = new PageWrap<>();
pageWrap.setModel(req);
pageWrap.setPageNum(pageNo);
pageWrap.setPageSize(pageSize);
PageWrap.SortData sortData = new PageWrap.SortData();
sortData.setDirection("DESC");
sortData.setProperty(sortProperty);
List<PageWrap.SortData> sorts = new ArrayList<>();
sorts.add(sortData);
pageWrap.setSorts(sorts);
return pageWrap;
}
}

@ -1,178 +0,0 @@
package com.controller;
import com.annotation.IgnoreAuth;
import com.entity.*;
import com.service.*;
import com.util.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName ShangpinController
* @Description
*/
@RequestMapping("shangpin")
@RestController
public class ShangpinController {
@Autowired
private ShangpinService shangpinService;
//前台-根据条件获取零食列表分页数据接口
@IgnoreAuth
@RequestMapping("/manaqian")
public ApiResponse<Shangpin> manaQian(Shangpin req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Shangpin> shangpinList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(shangpinList);
}
//前台-根据条件获取我的零食列表分页数据接口
@RequestMapping("/manamyqian")
public ApiResponse<Shangpin> manaMyQian(Shangpin req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Shangpin> shangpinList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(shangpinList);
}
//前台-根据条件获取零食图片列表分页数据接口
@IgnoreAuth
@RequestMapping("/manaqiantp")
public ApiResponse<Shangpin> manaQianTp(Shangpin req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Shangpin> shangpinList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(shangpinList);
}
//前台-零食详情
@IgnoreAuth
@RequestMapping("/detail/{id}")
public ApiResponse<Shangpin> detail(@PathVariable("id") Integer id) {
Shangpin info = shangpinService.findById(id);
return ApiResponse.success(info);
}
//前台-零食添加接口
@PostMapping("/add")
public ApiResponse<Integer> add(@RequestBody Shangpin req) {
int result = shangpinService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//后台-根据条件获取零食管理列表分页数据接口
@RequestMapping("/mana")
public ApiResponse<Shangpin> mana(Shangpin req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Shangpin> shangpinList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(shangpinList);
}
//后台-根据条件获取零食管理我的列表分页数据接口
@RequestMapping("/manamy")
public ApiResponse<Shangpin> manaMy(Shangpin req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Shangpin> shangpinList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(shangpinList);
}
//后台-根据条件获取零食查看列表分页数据接口
@RequestMapping("/chakan")
public ApiResponse<Shangpin> chakan(Shangpin req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Shangpin> shangpinList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(shangpinList);
}
//后台-根据条件获取零食查看我的列表分页数据接口
@RequestMapping("/chakanmy")
public ApiResponse<Shangpin> chakanMy(Shangpin req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Shangpin> shangpinList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(shangpinList);
}
//后台-零食详情
@RequestMapping("/info/{id}")
public ApiResponse<Shangpin> info(@PathVariable("id") Integer id) {
Shangpin info = shangpinService.findById(id);
return ApiResponse.success(info);
}
//后台-零食添加接口
@PostMapping("/save")
public ApiResponse<Integer> save(@RequestBody Shangpin req) {
int result = shangpinService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//零食删除(含批量删除)接口
@RequestMapping("/delete")
public ApiResponse<Integer> delete(@RequestBody Integer[] ids) {
int result = 0;
for (Integer id : ids) {
result = shangpinService.deleteById(id);
}
return ApiResponse.success(result);
}
//零食修改接口
@PostMapping("/set")
public ApiResponse<Integer> set(@RequestBody Shangpin req) {
int result = shangpinService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//获取所有零食数据接口
@IgnoreAuth
@RequestMapping("/all")
public ApiResponse<Shangpin> shangpinAll() {
List<Shangpin> shangpinList = shangpinService.findAll();
return ApiResponse.success(shangpinList);
}
//根据条件(字符类型模糊匹配查询)获取零食数据接口
@IgnoreAuth
@RequestMapping("/search")
public ApiResponse<Shangpin> shangpinSearch(Shangpin req) {
List<Shangpin> shangpinList = shangpinService.find(req);
return ApiResponse.success(shangpinList);
}
//根据条件(字符类型完全匹配查询)获取零食数据接口
@IgnoreAuth
@RequestMapping("/searchByEqualTo")
public ApiResponse<Shangpin> shangpinSearchByEqualTo(Shangpin req) {
List<Shangpin> shangpinList = shangpinService.findByEqualTo(req);
return ApiResponse.success(shangpinList);
}
//按条件查询零食分页数据方法(模糊匹配查询)
private PageData<Shangpin> getPageList(Shangpin req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Shangpin> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Shangpin> shangpinList = shangpinService.findPage(pageWrap);
return shangpinList;
}
//按条件查询零食分页数据方法(完全匹配查询)
private PageData<Shangpin> getPageListByEqualTo(Shangpin req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Shangpin> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Shangpin> shangpinList = shangpinService.findPageByEqualTo(pageWrap);
return shangpinList;
}
//获取零食查询数据搜索条件
private PageWrap<Shangpin> getPageWrap(Shangpin req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Shangpin> pageWrap = new PageWrap<>();
pageWrap.setModel(req);
pageWrap.setPageNum(pageNo);
pageWrap.setPageSize(pageSize);
PageWrap.SortData sortData = new PageWrap.SortData();
sortData.setDirection("DESC");
sortData.setProperty(sortProperty);
List<PageWrap.SortData> sorts = new ArrayList<>();
sorts.add(sortData);
pageWrap.setSorts(sorts);
return pageWrap;
}
}

@ -1,178 +0,0 @@
package com.controller;
import com.annotation.IgnoreAuth;
import com.entity.*;
import com.service.*;
import com.util.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName ShenqingController
* @Description
*/
@RequestMapping("shenqing")
@RestController
public class ShenqingController {
@Autowired
private ShenqingService shenqingService;
//前台-根据条件获取售后申请列表分页数据接口
@IgnoreAuth
@RequestMapping("/manaqian")
public ApiResponse<Shenqing> manaQian(Shenqing req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Shenqing> shenqingList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(shenqingList);
}
//前台-根据条件获取我的售后申请列表分页数据接口
@RequestMapping("/manamyqian")
public ApiResponse<Shenqing> manaMyQian(Shenqing req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Shenqing> shenqingList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(shenqingList);
}
//前台-根据条件获取售后申请图片列表分页数据接口
@IgnoreAuth
@RequestMapping("/manaqiantp")
public ApiResponse<Shenqing> manaQianTp(Shenqing req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Shenqing> shenqingList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(shenqingList);
}
//前台-售后申请详情
@IgnoreAuth
@RequestMapping("/detail/{id}")
public ApiResponse<Shenqing> detail(@PathVariable("id") Integer id) {
Shenqing info = shenqingService.findById(id);
return ApiResponse.success(info);
}
//前台-售后申请添加接口
@PostMapping("/add")
public ApiResponse<Integer> add(@RequestBody Shenqing req) {
int result = shenqingService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//后台-根据条件获取售后申请管理列表分页数据接口
@RequestMapping("/mana")
public ApiResponse<Shenqing> mana(Shenqing req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Shenqing> shenqingList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(shenqingList);
}
//后台-根据条件获取售后申请管理我的列表分页数据接口
@RequestMapping("/manamy")
public ApiResponse<Shenqing> manaMy(Shenqing req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Shenqing> shenqingList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(shenqingList);
}
//后台-根据条件获取售后申请查看列表分页数据接口
@RequestMapping("/chakan")
public ApiResponse<Shenqing> chakan(Shenqing req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Shenqing> shenqingList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(shenqingList);
}
//后台-根据条件获取售后申请查看我的列表分页数据接口
@RequestMapping("/chakanmy")
public ApiResponse<Shenqing> chakanMy(Shenqing req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Shenqing> shenqingList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(shenqingList);
}
//后台-售后申请详情
@RequestMapping("/info/{id}")
public ApiResponse<Shenqing> info(@PathVariable("id") Integer id) {
Shenqing info = shenqingService.findById(id);
return ApiResponse.success(info);
}
//后台-售后申请添加接口
@PostMapping("/save")
public ApiResponse<Integer> save(@RequestBody Shenqing req) {
int result = shenqingService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//售后申请删除(含批量删除)接口
@RequestMapping("/delete")
public ApiResponse<Integer> delete(@RequestBody Integer[] ids) {
int result = 0;
for (Integer id : ids) {
result = shenqingService.deleteById(id);
}
return ApiResponse.success(result);
}
//售后申请修改接口
@PostMapping("/set")
public ApiResponse<Integer> set(@RequestBody Shenqing req) {
int result = shenqingService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//获取所有售后申请数据接口
@IgnoreAuth
@RequestMapping("/all")
public ApiResponse<Shenqing> shenqingAll() {
List<Shenqing> shenqingList = shenqingService.findAll();
return ApiResponse.success(shenqingList);
}
//根据条件(字符类型模糊匹配查询)获取售后申请数据接口
@IgnoreAuth
@RequestMapping("/search")
public ApiResponse<Shenqing> shenqingSearch(Shenqing req) {
List<Shenqing> shenqingList = shenqingService.find(req);
return ApiResponse.success(shenqingList);
}
//根据条件(字符类型完全匹配查询)获取售后申请数据接口
@IgnoreAuth
@RequestMapping("/searchByEqualTo")
public ApiResponse<Shenqing> shenqingSearchByEqualTo(Shenqing req) {
List<Shenqing> shenqingList = shenqingService.findByEqualTo(req);
return ApiResponse.success(shenqingList);
}
//按条件查询售后申请分页数据方法(模糊匹配查询)
private PageData<Shenqing> getPageList(Shenqing req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Shenqing> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Shenqing> shenqingList = shenqingService.findPage(pageWrap);
return shenqingList;
}
//按条件查询售后申请分页数据方法(完全匹配查询)
private PageData<Shenqing> getPageListByEqualTo(Shenqing req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Shenqing> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Shenqing> shenqingList = shenqingService.findPageByEqualTo(pageWrap);
return shenqingList;
}
//获取售后申请查询数据搜索条件
private PageWrap<Shenqing> getPageWrap(Shenqing req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Shenqing> pageWrap = new PageWrap<>();
pageWrap.setModel(req);
pageWrap.setPageNum(pageNo);
pageWrap.setPageSize(pageSize);
PageWrap.SortData sortData = new PageWrap.SortData();
sortData.setDirection("DESC");
sortData.setProperty(sortProperty);
List<PageWrap.SortData> sorts = new ArrayList<>();
sorts.add(sortData);
pageWrap.setSorts(sorts);
return pageWrap;
}
}

@ -1,178 +0,0 @@
package com.controller;
import com.annotation.IgnoreAuth;
import com.entity.*;
import com.service.*;
import com.util.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName ShoucangController
* @Description
*/
@RequestMapping("shoucang")
@RestController
public class ShoucangController {
@Autowired
private ShoucangService shoucangService;
//前台-根据条件获取收藏列表分页数据接口
@IgnoreAuth
@RequestMapping("/manaqian")
public ApiResponse<Shoucang> manaQian(Shoucang req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Shoucang> shoucangList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(shoucangList);
}
//前台-根据条件获取我的收藏列表分页数据接口
@RequestMapping("/manamyqian")
public ApiResponse<Shoucang> manaMyQian(Shoucang req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Shoucang> shoucangList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(shoucangList);
}
//前台-根据条件获取收藏图片列表分页数据接口
@IgnoreAuth
@RequestMapping("/manaqiantp")
public ApiResponse<Shoucang> manaQianTp(Shoucang req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Shoucang> shoucangList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(shoucangList);
}
//前台-收藏详情
@IgnoreAuth
@RequestMapping("/detail/{id}")
public ApiResponse<Shoucang> detail(@PathVariable("id") Integer id) {
Shoucang info = shoucangService.findById(id);
return ApiResponse.success(info);
}
//前台-收藏添加接口
@PostMapping("/add")
public ApiResponse<Integer> add(@RequestBody Shoucang req) {
int result = shoucangService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//后台-根据条件获取收藏管理列表分页数据接口
@RequestMapping("/mana")
public ApiResponse<Shoucang> mana(Shoucang req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Shoucang> shoucangList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(shoucangList);
}
//后台-根据条件获取收藏管理我的列表分页数据接口
@RequestMapping("/manamy")
public ApiResponse<Shoucang> manaMy(Shoucang req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Shoucang> shoucangList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(shoucangList);
}
//后台-根据条件获取收藏查看列表分页数据接口
@RequestMapping("/chakan")
public ApiResponse<Shoucang> chakan(Shoucang req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Shoucang> shoucangList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(shoucangList);
}
//后台-根据条件获取收藏查看我的列表分页数据接口
@RequestMapping("/chakanmy")
public ApiResponse<Shoucang> chakanMy(Shoucang req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Shoucang> shoucangList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(shoucangList);
}
//后台-收藏详情
@RequestMapping("/info/{id}")
public ApiResponse<Shoucang> info(@PathVariable("id") Integer id) {
Shoucang info = shoucangService.findById(id);
return ApiResponse.success(info);
}
//后台-收藏添加接口
@PostMapping("/save")
public ApiResponse<Integer> save(@RequestBody Shoucang req) {
int result = shoucangService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//收藏删除(含批量删除)接口
@RequestMapping("/delete")
public ApiResponse<Integer> delete(@RequestBody Integer[] ids) {
int result = 0;
for (Integer id : ids) {
result = shoucangService.deleteById(id);
}
return ApiResponse.success(result);
}
//收藏修改接口
@PostMapping("/set")
public ApiResponse<Integer> set(@RequestBody Shoucang req) {
int result = shoucangService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//获取所有收藏数据接口
@IgnoreAuth
@RequestMapping("/all")
public ApiResponse<Shoucang> shoucangAll() {
List<Shoucang> shoucangList = shoucangService.findAll();
return ApiResponse.success(shoucangList);
}
//根据条件(字符类型模糊匹配查询)获取收藏数据接口
@IgnoreAuth
@RequestMapping("/search")
public ApiResponse<Shoucang> shoucangSearch(Shoucang req) {
List<Shoucang> shoucangList = shoucangService.find(req);
return ApiResponse.success(shoucangList);
}
//根据条件(字符类型完全匹配查询)获取收藏数据接口
@IgnoreAuth
@RequestMapping("/searchByEqualTo")
public ApiResponse<Shoucang> shoucangSearchByEqualTo(Shoucang req) {
List<Shoucang> shoucangList = shoucangService.findByEqualTo(req);
return ApiResponse.success(shoucangList);
}
//按条件查询收藏分页数据方法(模糊匹配查询)
private PageData<Shoucang> getPageList(Shoucang req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Shoucang> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Shoucang> shoucangList = shoucangService.findPage(pageWrap);
return shoucangList;
}
//按条件查询收藏分页数据方法(完全匹配查询)
private PageData<Shoucang> getPageListByEqualTo(Shoucang req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Shoucang> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Shoucang> shoucangList = shoucangService.findPageByEqualTo(pageWrap);
return shoucangList;
}
//获取收藏查询数据搜索条件
private PageWrap<Shoucang> getPageWrap(Shoucang req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Shoucang> pageWrap = new PageWrap<>();
pageWrap.setModel(req);
pageWrap.setPageNum(pageNo);
pageWrap.setPageSize(pageSize);
PageWrap.SortData sortData = new PageWrap.SortData();
sortData.setDirection("DESC");
sortData.setProperty(sortProperty);
List<PageWrap.SortData> sorts = new ArrayList<>();
sorts.add(sortData);
pageWrap.setSorts(sorts);
return pageWrap;
}
}

@ -1,247 +0,0 @@
package com.controller;
import com.annotation.IgnoreAuth;
import com.entity.*;
import com.service.*;
import com.util.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName UsersController
* @Description
*/
@RequestMapping("users")
@RestController
public class UsersController {
@Autowired
private UsersService usersService;
//前台-根据条件获取用户列表分页数据接口
@IgnoreAuth
@RequestMapping("/manaqian")
public ApiResponse<Users> manaQian(Users req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Users> usersList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(usersList);
}
//前台-根据条件获取我的用户列表分页数据接口
@RequestMapping("/manamyqian")
public ApiResponse<Users> manaMyQian(Users req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Users> usersList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(usersList);
}
//前台-根据条件获取用户图片列表分页数据接口
@IgnoreAuth
@RequestMapping("/manaqiantp")
public ApiResponse<Users> manaQianTp(Users req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Users> usersList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(usersList);
}
//前台-用户详情
@IgnoreAuth
@RequestMapping("/detail/{id}")
public ApiResponse<Users> detail(@PathVariable("id") Integer id) {
Users info = usersService.findById(id);
return ApiResponse.success(info);
}
//前台-用户添加接口
@IgnoreAuth
@PostMapping("/add")
public ApiResponse<Integer> add(@RequestBody Users req) {
if (null == req.getLoginname() || req.getLoginname().equals("")) {
return ApiResponse.failed("用户名loginname不能为空");
}
//判断用户名loginname是否已存在
Users instance = new Users();
instance.setLoginname(req.getLoginname());
instance = usersService.findOneByEqualTo(instance);
if (null != instance && (null == req.getId() || req.getId() == 0) || (null != instance && !instance.getId().equals(req.getId()))) {
return ApiResponse.failed("用户名" + req.getLoginname() + "已存在");
}
if (null != req.getLoginpw() && !req.getLoginpw().equals("")) {
req.setLoginpw(Md5Util.strToMd5(req.getLoginpw()));
} else {
req.setLoginpw(null);
}
int result = usersService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//后台-根据条件获取用户管理列表分页数据接口
@RequestMapping("/mana")
public ApiResponse<Users> mana(Users req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Users> usersList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(usersList);
}
//后台-根据条件获取用户管理我的列表分页数据接口
@RequestMapping("/manamy")
public ApiResponse<Users> manaMy(Users req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Users> usersList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(usersList);
}
//后台-根据条件获取用户查看列表分页数据接口
@RequestMapping("/chakan")
public ApiResponse<Users> chakan(Users req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Users> usersList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(usersList);
}
//后台-根据条件获取用户查看我的列表分页数据接口
@RequestMapping("/chakanmy")
public ApiResponse<Users> chakanMy(Users req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Users> usersList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(usersList);
}
//后台-用户详情
@RequestMapping("/info/{id}")
public ApiResponse<Users> info(@PathVariable("id") Integer id) {
Users info = usersService.findById(id);
return ApiResponse.success(info);
}
//后台-用户添加接口
@IgnoreAuth
@PostMapping("/save")
public ApiResponse<Integer> save(@RequestBody Users req) {
if (null == req.getLoginname() || req.getLoginname().equals("")) {
return ApiResponse.failed("用户名loginname不能为空");
}
//判断用户名是否已存在
Users instance = new Users();
instance.setLoginname(req.getLoginname());
instance = usersService.findOneByEqualTo(instance);
if (null != instance && (null == req.getId() || req.getId() == 0) || (null != instance && !instance.getId().equals(req.getId()))) {
return ApiResponse.failed("用户名" + req.getLoginname() + "已存在");
}
if (null != req.getLoginpw() && !req.getLoginpw().equals("")) {
req.setLoginpw(Md5Util.strToMd5(req.getLoginpw()));
} else {
req.setLoginpw(null);
}
int result = usersService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//用户删除(含批量删除)接口
@RequestMapping("/delete")
public ApiResponse<Integer> delete(@RequestBody Integer[] ids) {
int result = 0;
for (Integer id : ids) {
result = usersService.deleteById(id);
}
return ApiResponse.success(result);
}
//用户修改接口
@PostMapping("/set")
public ApiResponse<Integer> set(@RequestBody Users req) {
// if (null == req.getLoginname() || req.getLoginname().equals("")) {
// return ApiResponse.failed("用户名loginname不能为空");
// }
//判断用户名是否已存在
// Users instance = new Users();
// instance.setLoginname(req.getLoginname());
// instance = usersService.findOneByEqualTo(instance);
// if (null != instance && (null == req.getId() || req.getId() == 0) || (null != instance && !instance.getId().equals(req.getId()))) {
// return ApiResponse.failed("用户名" + req.getLoginname() + "已存在");
// }
// if (null != req.getLoginpw() && !req.getLoginpw().equals("")) {
// req.setLoginpw(Md5Util.strToMd5(req.getLoginpw()));
// } else {
// req.setLoginpw(null);
// }
int result = usersService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//获取当前登陆用户的个人信息
@RequestMapping("/session")
public ApiResponse<Users> getCurrUser(HttpServletRequest request) {
Integer id = (Integer) request.getSession().getAttribute("usersId");
Users info = usersService.findById(id);
return ApiResponse.success(info);
}
//用户重置密码接口
@IgnoreAuth
@RequestMapping("/resetPw")
public ApiResponse<String> usersResetPw(@RequestBody Users req) {
Users info = usersService.findOneByEqualTo(req);
if (null == info || info.getId() == 0) {
return ApiResponse.failed("请确认您的用户名、姓名和电话是否正确!");
}
info.setLoginpw(Md5Util.strToMd5("000000"));
usersService.saveOrUpdate(info);
return ApiResponse.success("您的密码已被重置为000000如需修改请登陆个人中心操作!");
}
//获取所有用户数据接口
@IgnoreAuth
@RequestMapping("/all")
public ApiResponse<Users> usersAll() {
List<Users> usersList = usersService.findAll();
return ApiResponse.success(usersList);
}
//根据条件(字符类型模糊匹配查询)获取用户数据接口
@IgnoreAuth
@RequestMapping("/search")
public ApiResponse<Users> usersSearch(Users req) {
List<Users> usersList = usersService.find(req);
return ApiResponse.success(usersList);
}
//根据条件(字符类型完全匹配查询)获取用户数据接口
@IgnoreAuth
@RequestMapping("/searchByEqualTo")
public ApiResponse<Users> usersSearchByEqualTo(Users req) {
List<Users> usersList = usersService.findByEqualTo(req);
return ApiResponse.success(usersList);
}
//按条件查询用户分页数据方法(模糊匹配查询)
private PageData<Users> getPageList(Users req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Users> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Users> usersList = usersService.findPage(pageWrap);
return usersList;
}
//按条件查询用户分页数据方法(完全匹配查询)
private PageData<Users> getPageListByEqualTo(Users req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Users> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Users> usersList = usersService.findPageByEqualTo(pageWrap);
return usersList;
}
//获取用户查询数据搜索条件
private PageWrap<Users> getPageWrap(Users req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Users> pageWrap = new PageWrap<>();
pageWrap.setModel(req);
pageWrap.setPageNum(pageNo);
pageWrap.setPageSize(pageSize);
PageWrap.SortData sortData = new PageWrap.SortData();
sortData.setDirection("DESC");
sortData.setProperty(sortProperty);
List<PageWrap.SortData> sorts = new ArrayList<>();
sorts.add(sortData);
pageWrap.setSorts(sorts);
return pageWrap;
}
}

@ -1,178 +0,0 @@
package com.controller;
import com.annotation.IgnoreAuth;
import com.entity.*;
import com.service.*;
import com.util.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName XinwenController
* @Description
*/
@RequestMapping("xinwen")
@RestController
public class XinwenController {
@Autowired
private XinwenService xinwenService;
//前台-根据条件获取新闻列表分页数据接口
@IgnoreAuth
@RequestMapping("/manaqian")
public ApiResponse<Xinwen> manaQian(Xinwen req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Xinwen> xinwenList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(xinwenList);
}
//前台-根据条件获取我的新闻列表分页数据接口
@RequestMapping("/manamyqian")
public ApiResponse<Xinwen> manaMyQian(Xinwen req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Xinwen> xinwenList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(xinwenList);
}
//前台-根据条件获取新闻图片列表分页数据接口
@IgnoreAuth
@RequestMapping("/manaqiantp")
public ApiResponse<Xinwen> manaQianTp(Xinwen req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Xinwen> xinwenList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(xinwenList);
}
//前台-新闻详情
@IgnoreAuth
@RequestMapping("/detail/{id}")
public ApiResponse<Xinwen> detail(@PathVariable("id") Integer id) {
Xinwen info = xinwenService.findById(id);
return ApiResponse.success(info);
}
//前台-新闻添加接口
@PostMapping("/add")
public ApiResponse<Integer> add(@RequestBody Xinwen req) {
int result = xinwenService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//后台-根据条件获取新闻管理列表分页数据接口
@RequestMapping("/mana")
public ApiResponse<Xinwen> mana(Xinwen req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Xinwen> xinwenList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(xinwenList);
}
//后台-根据条件获取新闻管理我的列表分页数据接口
@RequestMapping("/manamy")
public ApiResponse<Xinwen> manaMy(Xinwen req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Xinwen> xinwenList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(xinwenList);
}
//后台-根据条件获取新闻查看列表分页数据接口
@RequestMapping("/chakan")
public ApiResponse<Xinwen> chakan(Xinwen req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Xinwen> xinwenList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(xinwenList);
}
//后台-根据条件获取新闻查看我的列表分页数据接口
@RequestMapping("/chakanmy")
public ApiResponse<Xinwen> chakanMy(Xinwen req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Xinwen> xinwenList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(xinwenList);
}
//后台-新闻详情
@RequestMapping("/info/{id}")
public ApiResponse<Xinwen> info(@PathVariable("id") Integer id) {
Xinwen info = xinwenService.findById(id);
return ApiResponse.success(info);
}
//后台-新闻添加接口
@PostMapping("/save")
public ApiResponse<Integer> save(@RequestBody Xinwen req) {
int result = xinwenService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//新闻删除(含批量删除)接口
@RequestMapping("/delete")
public ApiResponse<Integer> delete(@RequestBody Integer[] ids) {
int result = 0;
for (Integer id : ids) {
result = xinwenService.deleteById(id);
}
return ApiResponse.success(result);
}
//新闻修改接口
@PostMapping("/set")
public ApiResponse<Integer> set(@RequestBody Xinwen req) {
int result = xinwenService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//获取所有新闻数据接口
@IgnoreAuth
@RequestMapping("/all")
public ApiResponse<Xinwen> xinwenAll() {
List<Xinwen> xinwenList = xinwenService.findAll();
return ApiResponse.success(xinwenList);
}
//根据条件(字符类型模糊匹配查询)获取新闻数据接口
@IgnoreAuth
@RequestMapping("/search")
public ApiResponse<Xinwen> xinwenSearch(Xinwen req) {
List<Xinwen> xinwenList = xinwenService.find(req);
return ApiResponse.success(xinwenList);
}
//根据条件(字符类型完全匹配查询)获取新闻数据接口
@IgnoreAuth
@RequestMapping("/searchByEqualTo")
public ApiResponse<Xinwen> xinwenSearchByEqualTo(Xinwen req) {
List<Xinwen> xinwenList = xinwenService.findByEqualTo(req);
return ApiResponse.success(xinwenList);
}
//按条件查询新闻分页数据方法(模糊匹配查询)
private PageData<Xinwen> getPageList(Xinwen req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Xinwen> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Xinwen> xinwenList = xinwenService.findPage(pageWrap);
return xinwenList;
}
//按条件查询新闻分页数据方法(完全匹配查询)
private PageData<Xinwen> getPageListByEqualTo(Xinwen req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Xinwen> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Xinwen> xinwenList = xinwenService.findPageByEqualTo(pageWrap);
return xinwenList;
}
//获取新闻查询数据搜索条件
private PageWrap<Xinwen> getPageWrap(Xinwen req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Xinwen> pageWrap = new PageWrap<>();
pageWrap.setModel(req);
pageWrap.setPageNum(pageNo);
pageWrap.setPageSize(pageSize);
PageWrap.SortData sortData = new PageWrap.SortData();
sortData.setDirection("DESC");
sortData.setProperty(sortProperty);
List<PageWrap.SortData> sorts = new ArrayList<>();
sorts.add(sortData);
pageWrap.setSorts(sorts);
return pageWrap;
}
}

@ -1,178 +0,0 @@
package com.controller;
import com.annotation.IgnoreAuth;
import com.entity.*;
import com.service.*;
import com.util.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName ZhifufangshiController
* @Description
*/
@RequestMapping("zhifufangshi")
@RestController
public class ZhifufangshiController {
@Autowired
private ZhifufangshiService zhifufangshiService;
//前台-根据条件获取支付方式列表分页数据接口
@IgnoreAuth
@RequestMapping("/manaqian")
public ApiResponse<Zhifufangshi> manaQian(Zhifufangshi req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Zhifufangshi> zhifufangshiList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(zhifufangshiList);
}
//前台-根据条件获取我的支付方式列表分页数据接口
@RequestMapping("/manamyqian")
public ApiResponse<Zhifufangshi> manaMyQian(Zhifufangshi req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Zhifufangshi> zhifufangshiList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(zhifufangshiList);
}
//前台-根据条件获取支付方式图片列表分页数据接口
@IgnoreAuth
@RequestMapping("/manaqiantp")
public ApiResponse<Zhifufangshi> manaQianTp(Zhifufangshi req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Zhifufangshi> zhifufangshiList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(zhifufangshiList);
}
//前台-支付方式详情
@IgnoreAuth
@RequestMapping("/detail/{id}")
public ApiResponse<Zhifufangshi> detail(@PathVariable("id") Integer id) {
Zhifufangshi info = zhifufangshiService.findById(id);
return ApiResponse.success(info);
}
//前台-支付方式添加接口
@PostMapping("/add")
public ApiResponse<Integer> add(@RequestBody Zhifufangshi req) {
int result = zhifufangshiService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//后台-根据条件获取支付方式管理列表分页数据接口
@RequestMapping("/mana")
public ApiResponse<Zhifufangshi> mana(Zhifufangshi req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Zhifufangshi> zhifufangshiList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(zhifufangshiList);
}
//后台-根据条件获取支付方式管理我的列表分页数据接口
@RequestMapping("/manamy")
public ApiResponse<Zhifufangshi> manaMy(Zhifufangshi req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Zhifufangshi> zhifufangshiList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(zhifufangshiList);
}
//后台-根据条件获取支付方式查看列表分页数据接口
@RequestMapping("/chakan")
public ApiResponse<Zhifufangshi> chakan(Zhifufangshi req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Zhifufangshi> zhifufangshiList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(zhifufangshiList);
}
//后台-根据条件获取支付方式查看我的列表分页数据接口
@RequestMapping("/chakanmy")
public ApiResponse<Zhifufangshi> chakanMy(Zhifufangshi req, @RequestParam(defaultValue = "1", value = "pageNo") int pageNo, @RequestParam(defaultValue = "10", value = "pageSize") int pageSize, @RequestParam(defaultValue = "id", value = "sortProperty") String sortProperty) {
PageData<Zhifufangshi> zhifufangshiList = getPageList(req, pageNo, pageSize, sortProperty);
return ApiResponse.success(zhifufangshiList);
}
//后台-支付方式详情
@RequestMapping("/info/{id}")
public ApiResponse<Zhifufangshi> info(@PathVariable("id") Integer id) {
Zhifufangshi info = zhifufangshiService.findById(id);
return ApiResponse.success(info);
}
//后台-支付方式添加接口
@PostMapping("/save")
public ApiResponse<Integer> save(@RequestBody Zhifufangshi req) {
int result = zhifufangshiService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//支付方式删除(含批量删除)接口
@RequestMapping("/delete")
public ApiResponse<Integer> delete(@RequestBody Integer[] ids) {
int result = 0;
for (Integer id : ids) {
result = zhifufangshiService.deleteById(id);
}
return ApiResponse.success(result);
}
//支付方式修改接口
@PostMapping("/set")
public ApiResponse<Integer> set(@RequestBody Zhifufangshi req) {
int result = zhifufangshiService.saveOrUpdate(req);
return ApiResponse.success(result);
}
//获取所有支付方式数据接口
@IgnoreAuth
@RequestMapping("/all")
public ApiResponse<Zhifufangshi> zhifufangshiAll() {
List<Zhifufangshi> zhifufangshiList = zhifufangshiService.findAll();
return ApiResponse.success(zhifufangshiList);
}
//根据条件(字符类型模糊匹配查询)获取支付方式数据接口
@IgnoreAuth
@RequestMapping("/search")
public ApiResponse<Zhifufangshi> zhifufangshiSearch(Zhifufangshi req) {
List<Zhifufangshi> zhifufangshiList = zhifufangshiService.find(req);
return ApiResponse.success(zhifufangshiList);
}
//根据条件(字符类型完全匹配查询)获取支付方式数据接口
@IgnoreAuth
@RequestMapping("/searchByEqualTo")
public ApiResponse<Zhifufangshi> zhifufangshiSearchByEqualTo(Zhifufangshi req) {
List<Zhifufangshi> zhifufangshiList = zhifufangshiService.findByEqualTo(req);
return ApiResponse.success(zhifufangshiList);
}
//按条件查询支付方式分页数据方法(模糊匹配查询)
private PageData<Zhifufangshi> getPageList(Zhifufangshi req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Zhifufangshi> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Zhifufangshi> zhifufangshiList = zhifufangshiService.findPage(pageWrap);
return zhifufangshiList;
}
//按条件查询支付方式分页数据方法(完全匹配查询)
private PageData<Zhifufangshi> getPageListByEqualTo(Zhifufangshi req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Zhifufangshi> pageWrap = getPageWrap(req, pageNo, pageSize, sortProperty);
PageData<Zhifufangshi> zhifufangshiList = zhifufangshiService.findPageByEqualTo(pageWrap);
return zhifufangshiList;
}
//获取支付方式查询数据搜索条件
private PageWrap<Zhifufangshi> getPageWrap(Zhifufangshi req, int pageNo, int pageSize, String sortProperty) {
PageWrap<Zhifufangshi> pageWrap = new PageWrap<>();
pageWrap.setModel(req);
pageWrap.setPageNum(pageNo);
pageWrap.setPageSize(pageSize);
PageWrap.SortData sortData = new PageWrap.SortData();
sortData.setDirection("DESC");
sortData.setProperty(sortProperty);
List<PageWrap.SortData> sorts = new ArrayList<>();
sorts.add(sortData);
pageWrap.setSorts(sorts);
return pageWrap;
}
}

@ -1,47 +0,0 @@
package com.dao;
import com.entity.Dingdan;
import com.entity.DingdanExample;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* @ClassName DingdanMapper
* @Description
*/
public interface DingdanMapper {
//根据条件获取订单表dingdan的数据数量
int countByExample(DingdanExample example);
//根据条件删除订单表dingdan的数据
int deleteByExample(DingdanExample example);
//根据主键ID列删除订单表dingdan的数据
int deleteByPrimaryKey(Integer id);
//插入订单表dingdan的实体数据包含null值
int insert(Dingdan record);
//插入订单表dingdan的实体数据不包含null值
int insertSelective(Dingdan record);
//根据条件获取订单表dingdan的数据列表
List<Dingdan> selectByExample(DingdanExample example);
//根据主键ID列获取订单表dingdan的数据实体
Dingdan selectByPrimaryKey(Integer id);
//根据条件更新订单表dingdan的实体数据不包含null值
int updateByExampleSelective(@Param("record") Dingdan record, @Param("example") DingdanExample example);
//根据条件更新订单表dingdan的实体数据包含null值
int updateByExample(@Param("record") Dingdan record, @Param("example") DingdanExample example);
//根据主键ID列更新订单表dingdan的实体数据不包含null值
int updateByPrimaryKeySelective(Dingdan record);
//根据主键ID列更新订单表dingdan的实体数据包含null值
int updateByPrimaryKey(Dingdan record);
}

@ -1,47 +0,0 @@
package com.dao;
import com.entity.Dingdanxiang;
import com.entity.DingdanxiangExample;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* @ClassName DingdanxiangMapper
* @Description
*/
public interface DingdanxiangMapper {
//根据条件获取订单项表dingdanxiang的数据数量
int countByExample(DingdanxiangExample example);
//根据条件删除订单项表dingdanxiang的数据
int deleteByExample(DingdanxiangExample example);
//根据主键ID列删除订单项表dingdanxiang的数据
int deleteByPrimaryKey(Integer id);
//插入订单项表dingdanxiang的实体数据包含null值
int insert(Dingdanxiang record);
//插入订单项表dingdanxiang的实体数据不包含null值
int insertSelective(Dingdanxiang record);
//根据条件获取订单项表dingdanxiang的数据列表
List<Dingdanxiang> selectByExample(DingdanxiangExample example);
//根据主键ID列获取订单项表dingdanxiang的数据实体
Dingdanxiang selectByPrimaryKey(Integer id);
//根据条件更新订单项表dingdanxiang的实体数据不包含null值
int updateByExampleSelective(@Param("record") Dingdanxiang record, @Param("example") DingdanxiangExample example);
//根据条件更新订单项表dingdanxiang的实体数据包含null值
int updateByExample(@Param("record") Dingdanxiang record, @Param("example") DingdanxiangExample example);
//根据主键ID列更新订单项表dingdanxiang的实体数据不包含null值
int updateByPrimaryKeySelective(Dingdanxiang record);
//根据主键ID列更新订单项表dingdanxiang的实体数据包含null值
int updateByPrimaryKey(Dingdanxiang record);
}

@ -1,47 +0,0 @@
package com.dao;
import com.entity.Dx;
import com.entity.DxExample;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* @ClassName DxMapper
* @Description
*/
public interface DxMapper {
//根据条件获取信息介绍表dx的数据数量
int countByExample(DxExample example);
//根据条件删除信息介绍表dx的数据
int deleteByExample(DxExample example);
//根据主键ID列删除信息介绍表dx的数据
int deleteByPrimaryKey(Integer id);
//插入信息介绍表dx的实体数据包含null值
int insert(Dx record);
//插入信息介绍表dx的实体数据不包含null值
int insertSelective(Dx record);
//根据条件获取信息介绍表dx的数据列表
List<Dx> selectByExample(DxExample example);
//根据主键ID列获取信息介绍表dx的数据实体
Dx selectByPrimaryKey(Integer id);
//根据条件更新信息介绍表dx的实体数据不包含null值
int updateByExampleSelective(@Param("record") Dx record, @Param("example") DxExample example);
//根据条件更新信息介绍表dx的实体数据包含null值
int updateByExample(@Param("record") Dx record, @Param("example") DxExample example);
//根据主键ID列更新信息介绍表dx的实体数据不包含null值
int updateByPrimaryKeySelective(Dx record);
//根据主键ID列更新信息介绍表dx的实体数据包含null值
int updateByPrimaryKey(Dx record);
}

@ -1,47 +0,0 @@
package com.dao;
import com.entity.Gonggao;
import com.entity.GonggaoExample;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* @ClassName GonggaoMapper
* @Description
*/
public interface GonggaoMapper {
//根据条件获取公告表gonggao的数据数量
int countByExample(GonggaoExample example);
//根据条件删除公告表gonggao的数据
int deleteByExample(GonggaoExample example);
//根据主键ID列删除公告表gonggao的数据
int deleteByPrimaryKey(Integer id);
//插入公告表gonggao的实体数据包含null值
int insert(Gonggao record);
//插入公告表gonggao的实体数据不包含null值
int insertSelective(Gonggao record);
//根据条件获取公告表gonggao的数据列表
List<Gonggao> selectByExample(GonggaoExample example);
//根据主键ID列获取公告表gonggao的数据实体
Gonggao selectByPrimaryKey(Integer id);
//根据条件更新公告表gonggao的实体数据不包含null值
int updateByExampleSelective(@Param("record") Gonggao record, @Param("example") GonggaoExample example);
//根据条件更新公告表gonggao的实体数据包含null值
int updateByExample(@Param("record") Gonggao record, @Param("example") GonggaoExample example);
//根据主键ID列更新公告表gonggao的实体数据不包含null值
int updateByPrimaryKeySelective(Gonggao record);
//根据主键ID列更新公告表gonggao的实体数据包含null值
int updateByPrimaryKey(Gonggao record);
}

@ -1,47 +0,0 @@
package com.dao;
import com.entity.Gouwuche;
import com.entity.GouwucheExample;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* @ClassName GouwucheMapper
* @Description
*/
public interface GouwucheMapper {
//根据条件获取购物车表gouwuche的数据数量
int countByExample(GouwucheExample example);
//根据条件删除购物车表gouwuche的数据
int deleteByExample(GouwucheExample example);
//根据主键ID列删除购物车表gouwuche的数据
int deleteByPrimaryKey(Integer id);
//插入购物车表gouwuche的实体数据包含null值
int insert(Gouwuche record);
//插入购物车表gouwuche的实体数据不包含null值
int insertSelective(Gouwuche record);
//根据条件获取购物车表gouwuche的数据列表
List<Gouwuche> selectByExample(GouwucheExample example);
//根据主键ID列获取购物车表gouwuche的数据实体
Gouwuche selectByPrimaryKey(Integer id);
//根据条件更新购物车表gouwuche的实体数据不包含null值
int updateByExampleSelective(@Param("record") Gouwuche record, @Param("example") GouwucheExample example);
//根据条件更新购物车表gouwuche的实体数据包含null值
int updateByExample(@Param("record") Gouwuche record, @Param("example") GouwucheExample example);
//根据主键ID列更新购物车表gouwuche的实体数据不包含null值
int updateByPrimaryKeySelective(Gouwuche record);
//根据主键ID列更新购物车表gouwuche的实体数据包含null值
int updateByPrimaryKey(Gouwuche record);
}

@ -1,47 +0,0 @@
package com.dao;
import com.entity.Lianjie;
import com.entity.LianjieExample;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* @ClassName LianjieMapper
* @Description
*/
public interface LianjieMapper {
//根据条件获取友情链接表lianjie的数据数量
int countByExample(LianjieExample example);
//根据条件删除友情链接表lianjie的数据
int deleteByExample(LianjieExample example);
//根据主键ID列删除友情链接表lianjie的数据
int deleteByPrimaryKey(Integer id);
//插入友情链接表lianjie的实体数据包含null值
int insert(Lianjie record);
//插入友情链接表lianjie的实体数据不包含null值
int insertSelective(Lianjie record);
//根据条件获取友情链接表lianjie的数据列表
List<Lianjie> selectByExample(LianjieExample example);
//根据主键ID列获取友情链接表lianjie的数据实体
Lianjie selectByPrimaryKey(Integer id);
//根据条件更新友情链接表lianjie的实体数据不包含null值
int updateByExampleSelective(@Param("record") Lianjie record, @Param("example") LianjieExample example);
//根据条件更新友情链接表lianjie的实体数据包含null值
int updateByExample(@Param("record") Lianjie record, @Param("example") LianjieExample example);
//根据主键ID列更新友情链接表lianjie的实体数据不包含null值
int updateByPrimaryKeySelective(Lianjie record);
//根据主键ID列更新友情链接表lianjie的实体数据包含null值
int updateByPrimaryKey(Lianjie record);
}

@ -1,47 +0,0 @@
package com.dao;
import com.entity.Liuyan;
import com.entity.LiuyanExample;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* @ClassName LiuyanMapper
* @Description
*/
public interface LiuyanMapper {
//根据条件获取留言反馈表liuyan的数据数量
int countByExample(LiuyanExample example);
//根据条件删除留言反馈表liuyan的数据
int deleteByExample(LiuyanExample example);
//根据主键ID列删除留言反馈表liuyan的数据
int deleteByPrimaryKey(Integer id);
//插入留言反馈表liuyan的实体数据包含null值
int insert(Liuyan record);
//插入留言反馈表liuyan的实体数据不包含null值
int insertSelective(Liuyan record);
//根据条件获取留言反馈表liuyan的数据列表
List<Liuyan> selectByExample(LiuyanExample example);
//根据主键ID列获取留言反馈表liuyan的数据实体
Liuyan selectByPrimaryKey(Integer id);
//根据条件更新留言反馈表liuyan的实体数据不包含null值
int updateByExampleSelective(@Param("record") Liuyan record, @Param("example") LiuyanExample example);
//根据条件更新留言反馈表liuyan的实体数据包含null值
int updateByExample(@Param("record") Liuyan record, @Param("example") LiuyanExample example);
//根据主键ID列更新留言反馈表liuyan的实体数据不包含null值
int updateByPrimaryKeySelective(Liuyan record);
//根据主键ID列更新留言反馈表liuyan的实体数据包含null值
int updateByPrimaryKey(Liuyan record);
}

@ -1,47 +0,0 @@
package com.dao;
import com.entity.Lunbo;
import com.entity.LunboExample;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* @ClassName LunboMapper
* @Description
*/
public interface LunboMapper {
//根据条件获取轮播图表lunbo的数据数量
int countByExample(LunboExample example);
//根据条件删除轮播图表lunbo的数据
int deleteByExample(LunboExample example);
//根据主键ID列删除轮播图表lunbo的数据
int deleteByPrimaryKey(Integer id);
//插入轮播图表lunbo的实体数据包含null值
int insert(Lunbo record);
//插入轮播图表lunbo的实体数据不包含null值
int insertSelective(Lunbo record);
//根据条件获取轮播图表lunbo的数据列表
List<Lunbo> selectByExample(LunboExample example);
//根据主键ID列获取轮播图表lunbo的数据实体
Lunbo selectByPrimaryKey(Integer id);
//根据条件更新轮播图表lunbo的实体数据不包含null值
int updateByExampleSelective(@Param("record") Lunbo record, @Param("example") LunboExample example);
//根据条件更新轮播图表lunbo的实体数据包含null值
int updateByExample(@Param("record") Lunbo record, @Param("example") LunboExample example);
//根据主键ID列更新轮播图表lunbo的实体数据不包含null值
int updateByPrimaryKeySelective(Lunbo record);
//根据主键ID列更新轮播图表lunbo的实体数据包含null值
int updateByPrimaryKey(Lunbo record);
}

@ -1,47 +0,0 @@
package com.dao;
import com.entity.Pingjia;
import com.entity.PingjiaExample;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* @ClassName PingjiaMapper
* @Description
*/
public interface PingjiaMapper {
//根据条件获取评论表pingjia的数据数量
int countByExample(PingjiaExample example);
//根据条件删除评论表pingjia的数据
int deleteByExample(PingjiaExample example);
//根据主键ID列删除评论表pingjia的数据
int deleteByPrimaryKey(Integer id);
//插入评论表pingjia的实体数据包含null值
int insert(Pingjia record);
//插入评论表pingjia的实体数据不包含null值
int insertSelective(Pingjia record);
//根据条件获取评论表pingjia的数据列表
List<Pingjia> selectByExample(PingjiaExample example);
//根据主键ID列获取评论表pingjia的数据实体
Pingjia selectByPrimaryKey(Integer id);
//根据条件更新评论表pingjia的实体数据不包含null值
int updateByExampleSelective(@Param("record") Pingjia record, @Param("example") PingjiaExample example);
//根据条件更新评论表pingjia的实体数据包含null值
int updateByExample(@Param("record") Pingjia record, @Param("example") PingjiaExample example);
//根据主键ID列更新评论表pingjia的实体数据不包含null值
int updateByPrimaryKeySelective(Pingjia record);
//根据主键ID列更新评论表pingjia的实体数据包含null值
int updateByPrimaryKey(Pingjia record);
}

@ -1,47 +0,0 @@
package com.dao;
import com.entity.Pinlei;
import com.entity.PinleiExample;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* @ClassName PinleiMapper
* @Description
*/
public interface PinleiMapper {
//根据条件获取分类表pinlei的数据数量
int countByExample(PinleiExample example);
//根据条件删除分类表pinlei的数据
int deleteByExample(PinleiExample example);
//根据主键ID列删除分类表pinlei的数据
int deleteByPrimaryKey(Integer id);
//插入分类表pinlei的实体数据包含null值
int insert(Pinlei record);
//插入分类表pinlei的实体数据不包含null值
int insertSelective(Pinlei record);
//根据条件获取分类表pinlei的数据列表
List<Pinlei> selectByExample(PinleiExample example);
//根据主键ID列获取分类表pinlei的数据实体
Pinlei selectByPrimaryKey(Integer id);
//根据条件更新分类表pinlei的实体数据不包含null值
int updateByExampleSelective(@Param("record") Pinlei record, @Param("example") PinleiExample example);
//根据条件更新分类表pinlei的实体数据包含null值
int updateByExample(@Param("record") Pinlei record, @Param("example") PinleiExample example);
//根据主键ID列更新分类表pinlei的实体数据不包含null值
int updateByPrimaryKeySelective(Pinlei record);
//根据主键ID列更新分类表pinlei的实体数据包含null值
int updateByPrimaryKey(Pinlei record);
}

@ -1,47 +0,0 @@
package com.dao;
import com.entity.Shangpin;
import com.entity.ShangpinExample;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* @ClassName ShangpinMapper
* @Description
*/
public interface ShangpinMapper {
//根据条件获取零食表shangpin的数据数量
int countByExample(ShangpinExample example);
//根据条件删除零食表shangpin的数据
int deleteByExample(ShangpinExample example);
//根据主键ID列删除零食表shangpin的数据
int deleteByPrimaryKey(Integer id);
//插入零食表shangpin的实体数据包含null值
int insert(Shangpin record);
//插入零食表shangpin的实体数据不包含null值
int insertSelective(Shangpin record);
//根据条件获取零食表shangpin的数据列表
List<Shangpin> selectByExample(ShangpinExample example);
//根据主键ID列获取零食表shangpin的数据实体
Shangpin selectByPrimaryKey(Integer id);
//根据条件更新零食表shangpin的实体数据不包含null值
int updateByExampleSelective(@Param("record") Shangpin record, @Param("example") ShangpinExample example);
//根据条件更新零食表shangpin的实体数据包含null值
int updateByExample(@Param("record") Shangpin record, @Param("example") ShangpinExample example);
//根据主键ID列更新零食表shangpin的实体数据不包含null值
int updateByPrimaryKeySelective(Shangpin record);
//根据主键ID列更新零食表shangpin的实体数据包含null值
int updateByPrimaryKey(Shangpin record);
}

@ -1,47 +0,0 @@
package com.dao;
import com.entity.Shenqing;
import com.entity.ShenqingExample;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* @ClassName ShenqingMapper
* @Description
*/
public interface ShenqingMapper {
//根据条件获取售后申请表shenqing的数据数量
int countByExample(ShenqingExample example);
//根据条件删除售后申请表shenqing的数据
int deleteByExample(ShenqingExample example);
//根据主键ID列删除售后申请表shenqing的数据
int deleteByPrimaryKey(Integer id);
//插入售后申请表shenqing的实体数据包含null值
int insert(Shenqing record);
//插入售后申请表shenqing的实体数据不包含null值
int insertSelective(Shenqing record);
//根据条件获取售后申请表shenqing的数据列表
List<Shenqing> selectByExample(ShenqingExample example);
//根据主键ID列获取售后申请表shenqing的数据实体
Shenqing selectByPrimaryKey(Integer id);
//根据条件更新售后申请表shenqing的实体数据不包含null值
int updateByExampleSelective(@Param("record") Shenqing record, @Param("example") ShenqingExample example);
//根据条件更新售后申请表shenqing的实体数据包含null值
int updateByExample(@Param("record") Shenqing record, @Param("example") ShenqingExample example);
//根据主键ID列更新售后申请表shenqing的实体数据不包含null值
int updateByPrimaryKeySelective(Shenqing record);
//根据主键ID列更新售后申请表shenqing的实体数据包含null值
int updateByPrimaryKey(Shenqing record);
}

@ -1,47 +0,0 @@
package com.dao;
import com.entity.Shoucang;
import com.entity.ShoucangExample;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* @ClassName ShoucangMapper
* @Description
*/
public interface ShoucangMapper {
//根据条件获取收藏表shoucang的数据数量
int countByExample(ShoucangExample example);
//根据条件删除收藏表shoucang的数据
int deleteByExample(ShoucangExample example);
//根据主键ID列删除收藏表shoucang的数据
int deleteByPrimaryKey(Integer id);
//插入收藏表shoucang的实体数据包含null值
int insert(Shoucang record);
//插入收藏表shoucang的实体数据不包含null值
int insertSelective(Shoucang record);
//根据条件获取收藏表shoucang的数据列表
List<Shoucang> selectByExample(ShoucangExample example);
//根据主键ID列获取收藏表shoucang的数据实体
Shoucang selectByPrimaryKey(Integer id);
//根据条件更新收藏表shoucang的实体数据不包含null值
int updateByExampleSelective(@Param("record") Shoucang record, @Param("example") ShoucangExample example);
//根据条件更新收藏表shoucang的实体数据包含null值
int updateByExample(@Param("record") Shoucang record, @Param("example") ShoucangExample example);
//根据主键ID列更新收藏表shoucang的实体数据不包含null值
int updateByPrimaryKeySelective(Shoucang record);
//根据主键ID列更新收藏表shoucang的实体数据包含null值
int updateByPrimaryKey(Shoucang record);
}

@ -1,47 +0,0 @@
package com.dao;
import com.entity.Users;
import com.entity.UsersExample;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* @ClassName UsersMapper
* @Description
*/
public interface UsersMapper {
//根据条件获取用户表users的数据数量
int countByExample(UsersExample example);
//根据条件删除用户表users的数据
int deleteByExample(UsersExample example);
//根据主键ID列删除用户表users的数据
int deleteByPrimaryKey(Integer id);
//插入用户表users的实体数据包含null值
int insert(Users record);
//插入用户表users的实体数据不包含null值
int insertSelective(Users record);
//根据条件获取用户表users的数据列表
List<Users> selectByExample(UsersExample example);
//根据主键ID列获取用户表users的数据实体
Users selectByPrimaryKey(Integer id);
//根据条件更新用户表users的实体数据不包含null值
int updateByExampleSelective(@Param("record") Users record, @Param("example") UsersExample example);
//根据条件更新用户表users的实体数据包含null值
int updateByExample(@Param("record") Users record, @Param("example") UsersExample example);
//根据主键ID列更新用户表users的实体数据不包含null值
int updateByPrimaryKeySelective(Users record);
//根据主键ID列更新用户表users的实体数据包含null值
int updateByPrimaryKey(Users record);
}

@ -1,47 +0,0 @@
package com.dao;
import com.entity.Xinwen;
import com.entity.XinwenExample;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* @ClassName XinwenMapper
* @Description
*/
public interface XinwenMapper {
//根据条件获取新闻表xinwen的数据数量
int countByExample(XinwenExample example);
//根据条件删除新闻表xinwen的数据
int deleteByExample(XinwenExample example);
//根据主键ID列删除新闻表xinwen的数据
int deleteByPrimaryKey(Integer id);
//插入新闻表xinwen的实体数据包含null值
int insert(Xinwen record);
//插入新闻表xinwen的实体数据不包含null值
int insertSelective(Xinwen record);
//根据条件获取新闻表xinwen的数据列表
List<Xinwen> selectByExample(XinwenExample example);
//根据主键ID列获取新闻表xinwen的数据实体
Xinwen selectByPrimaryKey(Integer id);
//根据条件更新新闻表xinwen的实体数据不包含null值
int updateByExampleSelective(@Param("record") Xinwen record, @Param("example") XinwenExample example);
//根据条件更新新闻表xinwen的实体数据包含null值
int updateByExample(@Param("record") Xinwen record, @Param("example") XinwenExample example);
//根据主键ID列更新新闻表xinwen的实体数据不包含null值
int updateByPrimaryKeySelective(Xinwen record);
//根据主键ID列更新新闻表xinwen的实体数据包含null值
int updateByPrimaryKey(Xinwen record);
}

@ -1,47 +0,0 @@
package com.dao;
import com.entity.Zhifufangshi;
import com.entity.ZhifufangshiExample;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* @ClassName ZhifufangshiMapper
* @Description
*/
public interface ZhifufangshiMapper {
//根据条件获取支付方式表zhifufangshi的数据数量
int countByExample(ZhifufangshiExample example);
//根据条件删除支付方式表zhifufangshi的数据
int deleteByExample(ZhifufangshiExample example);
//根据主键ID列删除支付方式表zhifufangshi的数据
int deleteByPrimaryKey(Integer id);
//插入支付方式表zhifufangshi的实体数据包含null值
int insert(Zhifufangshi record);
//插入支付方式表zhifufangshi的实体数据不包含null值
int insertSelective(Zhifufangshi record);
//根据条件获取支付方式表zhifufangshi的数据列表
List<Zhifufangshi> selectByExample(ZhifufangshiExample example);
//根据主键ID列获取支付方式表zhifufangshi的数据实体
Zhifufangshi selectByPrimaryKey(Integer id);
//根据条件更新支付方式表zhifufangshi的实体数据不包含null值
int updateByExampleSelective(@Param("record") Zhifufangshi record, @Param("example") ZhifufangshiExample example);
//根据条件更新支付方式表zhifufangshi的实体数据包含null值
int updateByExample(@Param("record") Zhifufangshi record, @Param("example") ZhifufangshiExample example);
//根据主键ID列更新支付方式表zhifufangshi的实体数据不包含null值
int updateByPrimaryKeySelective(Zhifufangshi record);
//根据主键ID列更新支付方式表zhifufangshi的实体数据包含null值
int updateByPrimaryKey(Zhifufangshi record);
}

@ -1,319 +0,0 @@
package com.entity;
/**
* @ClassName Dingdan
* @Description
*/
public class Dingdan {
//id列
private Integer id;
//编号
private String bianhao;
//订单金额
private Integer jine;
//是否支付
private String zhifushenhe;
//是否发货
private String fahuoshenhe;
//是否收货
private String shouhuoshenhe;
//支付方式
private Integer zhifufangshiid;
//姓名
private String xingming;
//电话
private String dianhua;
//送货地址
private String dizhi;
//时间
private String shijian;
//物流信息
private String wuliu;
//备注
private String beizhu;
//用户id
private Integer usersid;
//父表支付方式表zhifufangshi
private Zhifufangshi zhifufangshi;
//父表用户表users
private Users users;
/**
* id
*
* @return id id
*/
public Integer getId() {
return this.id;
}
/**
* id
*
* @param id id
*/
public void setId(Integer id) {
this.id = id;
}
/**
*
*
* @return bianhao
*/
public String getBianhao() {
return this.bianhao;
}
/**
*
*
* @param bianhao
*/
public void setBianhao(String bianhao) {
this.bianhao = bianhao;
}
/**
*
*
* @return jine
*/
public Integer getJine() {
return this.jine;
}
/**
*
*
* @param jine
*/
public void setJine(Integer jine) {
this.jine = jine;
}
/**
*
*
* @return zhifushenhe
*/
public String getZhifushenhe() {
return this.zhifushenhe;
}
/**
*
*
* @param zhifushenhe
*/
public void setZhifushenhe(String zhifushenhe) {
this.zhifushenhe = zhifushenhe;
}
/**
*
*
* @return fahuoshenhe
*/
public String getFahuoshenhe() {
return this.fahuoshenhe;
}
/**
*
*
* @param fahuoshenhe
*/
public void setFahuoshenhe(String fahuoshenhe) {
this.fahuoshenhe = fahuoshenhe;
}
/**
*
*
* @return shouhuoshenhe
*/
public String getShouhuoshenhe() {
return this.shouhuoshenhe;
}
/**
*
*
* @param shouhuoshenhe
*/
public void setShouhuoshenhe(String shouhuoshenhe) {
this.shouhuoshenhe = shouhuoshenhe;
}
/**
*
*
* @return zhifufangshiid
*/
public Integer getZhifufangshiid() {
return this.zhifufangshiid;
}
/**
*
*
* @param zhifufangshiid
*/
public void setZhifufangshiid(Integer zhifufangshiid) {
this.zhifufangshiid = zhifufangshiid;
}
/**
*
*
* @return xingming
*/
public String getXingming() {
return this.xingming;
}
/**
*
*
* @param xingming
*/
public void setXingming(String xingming) {
this.xingming = xingming;
}
/**
*
*
* @return dianhua
*/
public String getDianhua() {
return this.dianhua;
}
/**
*
*
* @param dianhua
*/
public void setDianhua(String dianhua) {
this.dianhua = dianhua;
}
/**
*
*
* @return dizhi
*/
public String getDizhi() {
return this.dizhi;
}
/**
*
*
* @param dizhi
*/
public void setDizhi(String dizhi) {
this.dizhi = dizhi;
}
/**
*
*
* @return shijian
*/
public String getShijian() {
return this.shijian;
}
/**
*
*
* @param shijian
*/
public void setShijian(String shijian) {
this.shijian = shijian;
}
/**
*
*
* @return wuliu
*/
public String getWuliu() {
return this.wuliu;
}
/**
*
*
* @param wuliu
*/
public void setWuliu(String wuliu) {
this.wuliu = wuliu;
}
/**
*
*
* @return beizhu
*/
public String getBeizhu() {
return this.beizhu;
}
/**
*
*
* @param beizhu
*/
public void setBeizhu(String beizhu) {
this.beizhu = beizhu;
}
/**
* id
*
* @return usersid id
*/
public Integer getUsersid() {
return this.usersid;
}
/**
* id
*
* @param usersid id
*/
public void setUsersid(Integer usersid) {
this.usersid = usersid;
}
/**
* zhifufangshi
*
* @return zhifufangshi zhifufangshi
*/
public Zhifufangshi getZhifufangshi() {
return this.zhifufangshi;
}
/**
* zhifufangshi
*
* @param zhifufangshi zhifufangshi
*/
public void setZhifufangshi(Zhifufangshi zhifufangshi) {
this.zhifufangshi = zhifufangshi;
}
/**
* users
*
* @return users users
*/
public Users getUsers() {
return this.users;
}
/**
* users
*
* @param users users
*/
public void setUsers(Users users) {
this.users = users;
}
}

File diff suppressed because it is too large Load Diff

@ -1,167 +0,0 @@
package com.entity;
/**
* @ClassName Dingdanxiang
* @Description
*/
public class Dingdanxiang {
//id列
private Integer id;
//订单id
private Integer dingdanid;
//商品id
private Integer shangpinid;
//商品数量
private Integer goumaishuliang;
//用户id
private Integer usersid;
//父表订单表dingdan
private Dingdan dingdan;
//父表零食表shangpin
private Shangpin shangpin;
//父表用户表users
private Users users;
/**
* id
*
* @return id id
*/
public Integer getId() {
return this.id;
}
/**
* id
*
* @param id id
*/
public void setId(Integer id) {
this.id = id;
}
/**
* id
*
* @return dingdanid id
*/
public Integer getDingdanid() {
return this.dingdanid;
}
/**
* id
*
* @param dingdanid id
*/
public void setDingdanid(Integer dingdanid) {
this.dingdanid = dingdanid;
}
/**
* id
*
* @return shangpinid id
*/
public Integer getShangpinid() {
return this.shangpinid;
}
/**
* id
*
* @param shangpinid id
*/
public void setShangpinid(Integer shangpinid) {
this.shangpinid = shangpinid;
}
/**
*
*
* @return goumaishuliang
*/
public Integer getGoumaishuliang() {
return this.goumaishuliang;
}
/**
*
*
* @param goumaishuliang
*/
public void setGoumaishuliang(Integer goumaishuliang) {
this.goumaishuliang = goumaishuliang;
}
/**
* id
*
* @return usersid id
*/
public Integer getUsersid() {
return this.usersid;
}
/**
* id
*
* @param usersid id
*/
public void setUsersid(Integer usersid) {
this.usersid = usersid;
}
/**
* dingdan
*
* @return dingdan dingdan
*/
public Dingdan getDingdan() {
return this.dingdan;
}
/**
* dingdan
*
* @param dingdan dingdan
*/
public void setDingdan(Dingdan dingdan) {
this.dingdan = dingdan;
}
/**
* shangpin
*
* @return shangpin shangpin
*/
public Shangpin getShangpin() {
return this.shangpin;
}
/**
* shangpin
*
* @param shangpin shangpin
*/
public void setShangpin(Shangpin shangpin) {
this.shangpin = shangpin;
}
/**
* users
*
* @return users users
*/
public Users getUsers() {
return this.users;
}
/**
* users
*
* @param users users
*/
public void setUsers(Users users) {
this.users = users;
}
}

@ -1,542 +0,0 @@
package com.entity;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName Dingdanxiang
* @Description mybatis
*/
public class DingdanxiangExample {
protected String orderByClause;
protected boolean distinct;
protected List<Criteria> oredCriteria;
public DingdanxiangExample() {
oredCriteria = new ArrayList<Criteria>();
}
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
public String getOrderByClause() {
return orderByClause;
}
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
public boolean isDistinct() {
return distinct;
}
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
return criteria;
}
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
protected abstract static class GeneratedCriteria {
protected List<Criterion> criteria;
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
public boolean isValid() {
return criteria.size() > 0;
}
public List<Criterion> getAllCriteria() {
return criteria;
}
public List<Criterion> getCriteria() {
return criteria;
}
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
}
criteria.add(new Criterion(condition));
}
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value));
}
protected void addCriterion(String condition, Object value1, Object value2, String property) {
if (value1 == null || value2 == null) {
throw new RuntimeException("Between values for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value1, value2));
}
public Criteria andIdIsNull() {
addCriterion("id is null");
return (Criteria) this;
}
public Criteria andIdIsNotNull() {
addCriterion("id is not null");
return (Criteria) this;
}
public Criteria andIdEqualTo(Integer value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(Integer value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Integer value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Integer value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Integer value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Integer> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andDingdanidIsNull() {
addCriterion("dingdanid is null");
return (Criteria) this;
}
public Criteria andDingdanidIsNotNull() {
addCriterion("dingdanid is not null");
return (Criteria) this;
}
public Criteria andDingdanidEqualTo(Integer value) {
addCriterion("dingdanid =", value, "dingdanid");
return (Criteria) this;
}
public Criteria andDingdanidNotEqualTo(Integer value) {
addCriterion("dingdanid <>", value, "dingdanid");
return (Criteria) this;
}
public Criteria andDingdanidGreaterThan(Integer value) {
addCriterion("dingdanid >", value, "dingdanid");
return (Criteria) this;
}
public Criteria andDingdanidGreaterThanOrEqualTo(Integer value) {
addCriterion("dingdanid >=", value, "dingdanid");
return (Criteria) this;
}
public Criteria andDingdanidLessThan(Integer value) {
addCriterion("dingdanid <", value, "dingdanid");
return (Criteria) this;
}
public Criteria andDingdanidLessThanOrEqualTo(Integer value) {
addCriterion("dingdanid <=", value, "dingdanid");
return (Criteria) this;
}
public Criteria andDingdanidLike(Integer value) {
addCriterion("dingdanid like", value, "dingdanid");
return (Criteria) this;
}
public Criteria andDingdanidNotLike(Integer value) {
addCriterion("dingdanid not like", value, "dingdanid");
return (Criteria) this;
}
public Criteria andDingdanidIn(List<Integer> values) {
addCriterion("dingdanid in", values, "dingdanid");
return (Criteria) this;
}
public Criteria andDingdanidNotIn(List<Integer> values) {
addCriterion("dingdanid not in", values, "dingdanid");
return (Criteria) this;
}
public Criteria andDingdanidBetween(Integer value1, Integer value2) {
addCriterion("dingdanid between", value1, value2, "dingdanid");
return (Criteria) this;
}
public Criteria andDingdanidNotBetween(Integer value1, Integer value2) {
addCriterion("dingdanid not between", value1, value2, "dingdanid");
return (Criteria) this;
}
public Criteria andShangpinidIsNull() {
addCriterion("shangpinid is null");
return (Criteria) this;
}
public Criteria andShangpinidIsNotNull() {
addCriterion("shangpinid is not null");
return (Criteria) this;
}
public Criteria andShangpinidEqualTo(Integer value) {
addCriterion("shangpinid =", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidNotEqualTo(Integer value) {
addCriterion("shangpinid <>", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidGreaterThan(Integer value) {
addCriterion("shangpinid >", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidGreaterThanOrEqualTo(Integer value) {
addCriterion("shangpinid >=", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidLessThan(Integer value) {
addCriterion("shangpinid <", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidLessThanOrEqualTo(Integer value) {
addCriterion("shangpinid <=", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidLike(Integer value) {
addCriterion("shangpinid like", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidNotLike(Integer value) {
addCriterion("shangpinid not like", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidIn(List<Integer> values) {
addCriterion("shangpinid in", values, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidNotIn(List<Integer> values) {
addCriterion("shangpinid not in", values, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidBetween(Integer value1, Integer value2) {
addCriterion("shangpinid between", value1, value2, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidNotBetween(Integer value1, Integer value2) {
addCriterion("shangpinid not between", value1, value2, "shangpinid");
return (Criteria) this;
}
public Criteria andGoumaishuliangIsNull() {
addCriterion("goumaishuliang is null");
return (Criteria) this;
}
public Criteria andGoumaishuliangIsNotNull() {
addCriterion("goumaishuliang is not null");
return (Criteria) this;
}
public Criteria andGoumaishuliangEqualTo(Integer value) {
addCriterion("goumaishuliang =", value, "goumaishuliang");
return (Criteria) this;
}
public Criteria andGoumaishuliangNotEqualTo(Integer value) {
addCriterion("goumaishuliang <>", value, "goumaishuliang");
return (Criteria) this;
}
public Criteria andGoumaishuliangGreaterThan(Integer value) {
addCriterion("goumaishuliang >", value, "goumaishuliang");
return (Criteria) this;
}
public Criteria andGoumaishuliangGreaterThanOrEqualTo(Integer value) {
addCriterion("goumaishuliang >=", value, "goumaishuliang");
return (Criteria) this;
}
public Criteria andGoumaishuliangLessThan(Integer value) {
addCriterion("goumaishuliang <", value, "goumaishuliang");
return (Criteria) this;
}
public Criteria andGoumaishuliangLessThanOrEqualTo(Integer value) {
addCriterion("goumaishuliang <=", value, "goumaishuliang");
return (Criteria) this;
}
public Criteria andGoumaishuliangLike(Integer value) {
addCriterion("goumaishuliang like", value, "goumaishuliang");
return (Criteria) this;
}
public Criteria andGoumaishuliangNotLike(Integer value) {
addCriterion("goumaishuliang not like", value, "goumaishuliang");
return (Criteria) this;
}
public Criteria andGoumaishuliangIn(List<Integer> values) {
addCriterion("goumaishuliang in", values, "goumaishuliang");
return (Criteria) this;
}
public Criteria andGoumaishuliangNotIn(List<Integer> values) {
addCriterion("goumaishuliang not in", values, "goumaishuliang");
return (Criteria) this;
}
public Criteria andGoumaishuliangBetween(Integer value1, Integer value2) {
addCriterion("goumaishuliang between", value1, value2, "goumaishuliang");
return (Criteria) this;
}
public Criteria andGoumaishuliangNotBetween(Integer value1, Integer value2) {
addCriterion("goumaishuliang not between", value1, value2, "goumaishuliang");
return (Criteria) this;
}
public Criteria andUsersidIsNull() {
addCriterion("usersid is null");
return (Criteria) this;
}
public Criteria andUsersidIsNotNull() {
addCriterion("usersid is not null");
return (Criteria) this;
}
public Criteria andUsersidEqualTo(Integer value) {
addCriterion("usersid =", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidNotEqualTo(Integer value) {
addCriterion("usersid <>", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidGreaterThan(Integer value) {
addCriterion("usersid >", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidGreaterThanOrEqualTo(Integer value) {
addCriterion("usersid >=", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidLessThan(Integer value) {
addCriterion("usersid <", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidLessThanOrEqualTo(Integer value) {
addCriterion("usersid <=", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidLike(Integer value) {
addCriterion("usersid like", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidNotLike(Integer value) {
addCriterion("usersid not like", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidIn(List<Integer> values) {
addCriterion("usersid in", values, "usersid");
return (Criteria) this;
}
public Criteria andUsersidNotIn(List<Integer> values) {
addCriterion("usersid not in", values, "usersid");
return (Criteria) this;
}
public Criteria andUsersidBetween(Integer value1, Integer value2) {
addCriterion("usersid between", value1, value2, "usersid");
return (Criteria) this;
}
public Criteria andUsersidNotBetween(Integer value1, Integer value2) {
addCriterion("usersid not between", value1, value2, "usersid");
return (Criteria) this;
}
}
public static class Criteria extends GeneratedCriteria {
protected Criteria() {
super();
}
}
public static class Criterion {
private String condition;
private Object value;
private Object secondValue;
private boolean noValue;
private boolean singleValue;
private boolean betweenValue;
private boolean listValue;
private String typeHandler;
public String getCondition() {
return condition;
}
public Object getValue() {
return value;
}
public Object getSecondValue() {
return secondValue;
}
public boolean isNoValue() {
return noValue;
}
public boolean isSingleValue() {
return singleValue;
}
public boolean isBetweenValue() {
return betweenValue;
}
public boolean isListValue() {
return listValue;
}
public String getTypeHandler() {
return typeHandler;
}
protected Criterion(String condition) {
super();
this.condition = condition;
this.typeHandler = null;
this.noValue = true;
}
protected Criterion(String condition, Object value, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.typeHandler = typeHandler;
if (value instanceof List<?>) {
this.listValue = true;
} else {
this.singleValue = true;
}
}
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.secondValue = secondValue;
this.typeHandler = typeHandler;
this.betweenValue = true;
}
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}
}
}

@ -1,91 +0,0 @@
package com.entity;
/**
* @ClassName Dx
* @Description
*/
public class Dx {
//id列
private Integer id;
//类别
private String leibie;
//内容
private String content;
//时间
private String addtime;
/**
* id
*
* @return id id
*/
public Integer getId() {
return this.id;
}
/**
* id
*
* @param id id
*/
public void setId(Integer id) {
this.id = id;
}
/**
*
*
* @return leibie
*/
public String getLeibie() {
return this.leibie;
}
/**
*
*
* @param leibie
*/
public void setLeibie(String leibie) {
this.leibie = leibie;
}
/**
*
*
* @return content
*/
public String getContent() {
return this.content;
}
/**
*
*
* @param content
*/
public void setContent(String content) {
this.content = content;
}
/**
*
*
* @return addtime
*/
public String getAddtime() {
return this.addtime;
}
/**
*
*
* @param addtime
*/
public void setAddtime(String addtime) {
this.addtime = addtime;
}
}

@ -1,473 +0,0 @@
package com.entity;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName Dx
* @Description mybatis
*/
public class DxExample {
protected String orderByClause;
protected boolean distinct;
protected List<Criteria> oredCriteria;
public DxExample() {
oredCriteria = new ArrayList<Criteria>();
}
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
public String getOrderByClause() {
return orderByClause;
}
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
public boolean isDistinct() {
return distinct;
}
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
return criteria;
}
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
protected abstract static class GeneratedCriteria {
protected List<Criterion> criteria;
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
public boolean isValid() {
return criteria.size() > 0;
}
public List<Criterion> getAllCriteria() {
return criteria;
}
public List<Criterion> getCriteria() {
return criteria;
}
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
}
criteria.add(new Criterion(condition));
}
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value));
}
protected void addCriterion(String condition, Object value1, Object value2, String property) {
if (value1 == null || value2 == null) {
throw new RuntimeException("Between values for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value1, value2));
}
public Criteria andIdIsNull() {
addCriterion("id is null");
return (Criteria) this;
}
public Criteria andIdIsNotNull() {
addCriterion("id is not null");
return (Criteria) this;
}
public Criteria andIdEqualTo(Integer value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(Integer value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Integer value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Integer value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Integer value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Integer> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andLeibieIsNull() {
addCriterion("leibie is null");
return (Criteria) this;
}
public Criteria andLeibieIsNotNull() {
addCriterion("leibie is not null");
return (Criteria) this;
}
public Criteria andLeibieEqualTo(String value) {
addCriterion("leibie =", value, "leibie");
return (Criteria) this;
}
public Criteria andLeibieNotEqualTo(String value) {
addCriterion("leibie <>", value, "leibie");
return (Criteria) this;
}
public Criteria andLeibieGreaterThan(String value) {
addCriterion("leibie >", value, "leibie");
return (Criteria) this;
}
public Criteria andLeibieGreaterThanOrEqualTo(String value) {
addCriterion("leibie >=", value, "leibie");
return (Criteria) this;
}
public Criteria andLeibieLessThan(String value) {
addCriterion("leibie <", value, "leibie");
return (Criteria) this;
}
public Criteria andLeibieLessThanOrEqualTo(String value) {
addCriterion("leibie <=", value, "leibie");
return (Criteria) this;
}
public Criteria andLeibieLike(String value) {
addCriterion("leibie like", value, "leibie");
return (Criteria) this;
}
public Criteria andLeibieNotLike(String value) {
addCriterion("leibie not like", value, "leibie");
return (Criteria) this;
}
public Criteria andLeibieIn(List<String> values) {
addCriterion("leibie in", values, "leibie");
return (Criteria) this;
}
public Criteria andLeibieNotIn(List<String> values) {
addCriterion("leibie not in", values, "leibie");
return (Criteria) this;
}
public Criteria andLeibieBetween(String value1, String value2) {
addCriterion("leibie between", value1, value2, "leibie");
return (Criteria) this;
}
public Criteria andLeibieNotBetween(String value1, String value2) {
addCriterion("leibie not between", value1, value2, "leibie");
return (Criteria) this;
}
public Criteria andContentIsNull() {
addCriterion("content is null");
return (Criteria) this;
}
public Criteria andContentIsNotNull() {
addCriterion("content is not null");
return (Criteria) this;
}
public Criteria andContentEqualTo(String value) {
addCriterion("content =", value, "content");
return (Criteria) this;
}
public Criteria andContentNotEqualTo(String value) {
addCriterion("content <>", value, "content");
return (Criteria) this;
}
public Criteria andContentGreaterThan(String value) {
addCriterion("content >", value, "content");
return (Criteria) this;
}
public Criteria andContentGreaterThanOrEqualTo(String value) {
addCriterion("content >=", value, "content");
return (Criteria) this;
}
public Criteria andContentLessThan(String value) {
addCriterion("content <", value, "content");
return (Criteria) this;
}
public Criteria andContentLessThanOrEqualTo(String value) {
addCriterion("content <=", value, "content");
return (Criteria) this;
}
public Criteria andContentLike(String value) {
addCriterion("content like", value, "content");
return (Criteria) this;
}
public Criteria andContentNotLike(String value) {
addCriterion("content not like", value, "content");
return (Criteria) this;
}
public Criteria andContentIn(List<String> values) {
addCriterion("content in", values, "content");
return (Criteria) this;
}
public Criteria andContentNotIn(List<String> values) {
addCriterion("content not in", values, "content");
return (Criteria) this;
}
public Criteria andContentBetween(String value1, String value2) {
addCriterion("content between", value1, value2, "content");
return (Criteria) this;
}
public Criteria andContentNotBetween(String value1, String value2) {
addCriterion("content not between", value1, value2, "content");
return (Criteria) this;
}
public Criteria andAddtimeIsNull() {
addCriterion("addtime is null");
return (Criteria) this;
}
public Criteria andAddtimeIsNotNull() {
addCriterion("addtime is not null");
return (Criteria) this;
}
public Criteria andAddtimeEqualTo(String value) {
addCriterion("addtime =", value, "addtime");
return (Criteria) this;
}
public Criteria andAddtimeNotEqualTo(String value) {
addCriterion("addtime <>", value, "addtime");
return (Criteria) this;
}
public Criteria andAddtimeGreaterThan(String value) {
addCriterion("addtime >", value, "addtime");
return (Criteria) this;
}
public Criteria andAddtimeGreaterThanOrEqualTo(String value) {
addCriterion("addtime >=", value, "addtime");
return (Criteria) this;
}
public Criteria andAddtimeLessThan(String value) {
addCriterion("addtime <", value, "addtime");
return (Criteria) this;
}
public Criteria andAddtimeLessThanOrEqualTo(String value) {
addCriterion("addtime <=", value, "addtime");
return (Criteria) this;
}
public Criteria andAddtimeLike(String value) {
addCriterion("addtime like", value, "addtime");
return (Criteria) this;
}
public Criteria andAddtimeNotLike(String value) {
addCriterion("addtime not like", value, "addtime");
return (Criteria) this;
}
public Criteria andAddtimeIn(List<String> values) {
addCriterion("addtime in", values, "addtime");
return (Criteria) this;
}
public Criteria andAddtimeNotIn(List<String> values) {
addCriterion("addtime not in", values, "addtime");
return (Criteria) this;
}
public Criteria andAddtimeBetween(String value1, String value2) {
addCriterion("addtime between", value1, value2, "addtime");
return (Criteria) this;
}
public Criteria andAddtimeNotBetween(String value1, String value2) {
addCriterion("addtime not between", value1, value2, "addtime");
return (Criteria) this;
}
}
public static class Criteria extends GeneratedCriteria {
protected Criteria() {
super();
}
}
public static class Criterion {
private String condition;
private Object value;
private Object secondValue;
private boolean noValue;
private boolean singleValue;
private boolean betweenValue;
private boolean listValue;
private String typeHandler;
public String getCondition() {
return condition;
}
public Object getValue() {
return value;
}
public Object getSecondValue() {
return secondValue;
}
public boolean isNoValue() {
return noValue;
}
public boolean isSingleValue() {
return singleValue;
}
public boolean isBetweenValue() {
return betweenValue;
}
public boolean isListValue() {
return listValue;
}
public String getTypeHandler() {
return typeHandler;
}
protected Criterion(String condition) {
super();
this.condition = condition;
this.typeHandler = null;
this.noValue = true;
}
protected Criterion(String condition, Object value, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.typeHandler = typeHandler;
if (value instanceof List<?>) {
this.listValue = true;
} else {
this.singleValue = true;
}
}
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.secondValue = secondValue;
this.typeHandler = typeHandler;
this.betweenValue = true;
}
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}
}
}

@ -1,110 +0,0 @@
package com.entity;
/**
* @ClassName Gonggao
* @Description
*/
public class Gonggao {
//id列
private Integer id;
//标题
private String biaoti;
//内容
private String neirong;
//图片
private String tupian;
//时间
private String shijian;
/**
* id
*
* @return id id
*/
public Integer getId() {
return this.id;
}
/**
* id
*
* @param id id
*/
public void setId(Integer id) {
this.id = id;
}
/**
*
*
* @return biaoti
*/
public String getBiaoti() {
return this.biaoti;
}
/**
*
*
* @param biaoti
*/
public void setBiaoti(String biaoti) {
this.biaoti = biaoti;
}
/**
*
*
* @return neirong
*/
public String getNeirong() {
return this.neirong;
}
/**
*
*
* @param neirong
*/
public void setNeirong(String neirong) {
this.neirong = neirong;
}
/**
*
*
* @return tupian
*/
public String getTupian() {
return this.tupian;
}
/**
*
*
* @param tupian
*/
public void setTupian(String tupian) {
this.tupian = tupian;
}
/**
*
*
* @return shijian
*/
public String getShijian() {
return this.shijian;
}
/**
*
*
* @param shijian
*/
public void setShijian(String shijian) {
this.shijian = shijian;
}
}

@ -1,542 +0,0 @@
package com.entity;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName Gonggao
* @Description mybatis
*/
public class GonggaoExample {
protected String orderByClause;
protected boolean distinct;
protected List<Criteria> oredCriteria;
public GonggaoExample() {
oredCriteria = new ArrayList<Criteria>();
}
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
public String getOrderByClause() {
return orderByClause;
}
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
public boolean isDistinct() {
return distinct;
}
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
return criteria;
}
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
protected abstract static class GeneratedCriteria {
protected List<Criterion> criteria;
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
public boolean isValid() {
return criteria.size() > 0;
}
public List<Criterion> getAllCriteria() {
return criteria;
}
public List<Criterion> getCriteria() {
return criteria;
}
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
}
criteria.add(new Criterion(condition));
}
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value));
}
protected void addCriterion(String condition, Object value1, Object value2, String property) {
if (value1 == null || value2 == null) {
throw new RuntimeException("Between values for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value1, value2));
}
public Criteria andIdIsNull() {
addCriterion("id is null");
return (Criteria) this;
}
public Criteria andIdIsNotNull() {
addCriterion("id is not null");
return (Criteria) this;
}
public Criteria andIdEqualTo(Integer value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(Integer value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Integer value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Integer value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Integer value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Integer> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andBiaotiIsNull() {
addCriterion("biaoti is null");
return (Criteria) this;
}
public Criteria andBiaotiIsNotNull() {
addCriterion("biaoti is not null");
return (Criteria) this;
}
public Criteria andBiaotiEqualTo(String value) {
addCriterion("biaoti =", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiNotEqualTo(String value) {
addCriterion("biaoti <>", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiGreaterThan(String value) {
addCriterion("biaoti >", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiGreaterThanOrEqualTo(String value) {
addCriterion("biaoti >=", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiLessThan(String value) {
addCriterion("biaoti <", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiLessThanOrEqualTo(String value) {
addCriterion("biaoti <=", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiLike(String value) {
addCriterion("biaoti like", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiNotLike(String value) {
addCriterion("biaoti not like", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiIn(List<String> values) {
addCriterion("biaoti in", values, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiNotIn(List<String> values) {
addCriterion("biaoti not in", values, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiBetween(String value1, String value2) {
addCriterion("biaoti between", value1, value2, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiNotBetween(String value1, String value2) {
addCriterion("biaoti not between", value1, value2, "biaoti");
return (Criteria) this;
}
public Criteria andNeirongIsNull() {
addCriterion("neirong is null");
return (Criteria) this;
}
public Criteria andNeirongIsNotNull() {
addCriterion("neirong is not null");
return (Criteria) this;
}
public Criteria andNeirongEqualTo(String value) {
addCriterion("neirong =", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongNotEqualTo(String value) {
addCriterion("neirong <>", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongGreaterThan(String value) {
addCriterion("neirong >", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongGreaterThanOrEqualTo(String value) {
addCriterion("neirong >=", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongLessThan(String value) {
addCriterion("neirong <", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongLessThanOrEqualTo(String value) {
addCriterion("neirong <=", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongLike(String value) {
addCriterion("neirong like", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongNotLike(String value) {
addCriterion("neirong not like", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongIn(List<String> values) {
addCriterion("neirong in", values, "neirong");
return (Criteria) this;
}
public Criteria andNeirongNotIn(List<String> values) {
addCriterion("neirong not in", values, "neirong");
return (Criteria) this;
}
public Criteria andNeirongBetween(String value1, String value2) {
addCriterion("neirong between", value1, value2, "neirong");
return (Criteria) this;
}
public Criteria andNeirongNotBetween(String value1, String value2) {
addCriterion("neirong not between", value1, value2, "neirong");
return (Criteria) this;
}
public Criteria andTupianIsNull() {
addCriterion("tupian is null");
return (Criteria) this;
}
public Criteria andTupianIsNotNull() {
addCriterion("tupian is not null");
return (Criteria) this;
}
public Criteria andTupianEqualTo(String value) {
addCriterion("tupian =", value, "tupian");
return (Criteria) this;
}
public Criteria andTupianNotEqualTo(String value) {
addCriterion("tupian <>", value, "tupian");
return (Criteria) this;
}
public Criteria andTupianGreaterThan(String value) {
addCriterion("tupian >", value, "tupian");
return (Criteria) this;
}
public Criteria andTupianGreaterThanOrEqualTo(String value) {
addCriterion("tupian >=", value, "tupian");
return (Criteria) this;
}
public Criteria andTupianLessThan(String value) {
addCriterion("tupian <", value, "tupian");
return (Criteria) this;
}
public Criteria andTupianLessThanOrEqualTo(String value) {
addCriterion("tupian <=", value, "tupian");
return (Criteria) this;
}
public Criteria andTupianLike(String value) {
addCriterion("tupian like", value, "tupian");
return (Criteria) this;
}
public Criteria andTupianNotLike(String value) {
addCriterion("tupian not like", value, "tupian");
return (Criteria) this;
}
public Criteria andTupianIn(List<String> values) {
addCriterion("tupian in", values, "tupian");
return (Criteria) this;
}
public Criteria andTupianNotIn(List<String> values) {
addCriterion("tupian not in", values, "tupian");
return (Criteria) this;
}
public Criteria andTupianBetween(String value1, String value2) {
addCriterion("tupian between", value1, value2, "tupian");
return (Criteria) this;
}
public Criteria andTupianNotBetween(String value1, String value2) {
addCriterion("tupian not between", value1, value2, "tupian");
return (Criteria) this;
}
public Criteria andShijianIsNull() {
addCriterion("shijian is null");
return (Criteria) this;
}
public Criteria andShijianIsNotNull() {
addCriterion("shijian is not null");
return (Criteria) this;
}
public Criteria andShijianEqualTo(String value) {
addCriterion("shijian =", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianNotEqualTo(String value) {
addCriterion("shijian <>", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianGreaterThan(String value) {
addCriterion("shijian >", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianGreaterThanOrEqualTo(String value) {
addCriterion("shijian >=", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianLessThan(String value) {
addCriterion("shijian <", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianLessThanOrEqualTo(String value) {
addCriterion("shijian <=", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianLike(String value) {
addCriterion("shijian like", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianNotLike(String value) {
addCriterion("shijian not like", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianIn(List<String> values) {
addCriterion("shijian in", values, "shijian");
return (Criteria) this;
}
public Criteria andShijianNotIn(List<String> values) {
addCriterion("shijian not in", values, "shijian");
return (Criteria) this;
}
public Criteria andShijianBetween(String value1, String value2) {
addCriterion("shijian between", value1, value2, "shijian");
return (Criteria) this;
}
public Criteria andShijianNotBetween(String value1, String value2) {
addCriterion("shijian not between", value1, value2, "shijian");
return (Criteria) this;
}
}
public static class Criteria extends GeneratedCriteria {
protected Criteria() {
super();
}
}
public static class Criterion {
private String condition;
private Object value;
private Object secondValue;
private boolean noValue;
private boolean singleValue;
private boolean betweenValue;
private boolean listValue;
private String typeHandler;
public String getCondition() {
return condition;
}
public Object getValue() {
return value;
}
public Object getSecondValue() {
return secondValue;
}
public boolean isNoValue() {
return noValue;
}
public boolean isSingleValue() {
return singleValue;
}
public boolean isBetweenValue() {
return betweenValue;
}
public boolean isListValue() {
return listValue;
}
public String getTypeHandler() {
return typeHandler;
}
protected Criterion(String condition) {
super();
this.condition = condition;
this.typeHandler = null;
this.noValue = true;
}
protected Criterion(String condition, Object value, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.typeHandler = typeHandler;
if (value instanceof List<?>) {
this.listValue = true;
} else {
this.singleValue = true;
}
}
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.secondValue = secondValue;
this.typeHandler = typeHandler;
this.betweenValue = true;
}
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}
}
}

@ -1,129 +0,0 @@
package com.entity;
/**
* @ClassName Gouwuche
* @Description
*/
public class Gouwuche {
//id列
private Integer id;
//商品id
private Integer shangpinid;
//商品数量
private Integer goumaishuliang;
//用户id
private Integer usersid;
//父表零食表shangpin
private Shangpin shangpin;
//父表用户表users
private Users users;
/**
* id
*
* @return id id
*/
public Integer getId() {
return this.id;
}
/**
* id
*
* @param id id
*/
public void setId(Integer id) {
this.id = id;
}
/**
* id
*
* @return shangpinid id
*/
public Integer getShangpinid() {
return this.shangpinid;
}
/**
* id
*
* @param shangpinid id
*/
public void setShangpinid(Integer shangpinid) {
this.shangpinid = shangpinid;
}
/**
*
*
* @return goumaishuliang
*/
public Integer getGoumaishuliang() {
return this.goumaishuliang;
}
/**
*
*
* @param goumaishuliang
*/
public void setGoumaishuliang(Integer goumaishuliang) {
this.goumaishuliang = goumaishuliang;
}
/**
* id
*
* @return usersid id
*/
public Integer getUsersid() {
return this.usersid;
}
/**
* id
*
* @param usersid id
*/
public void setUsersid(Integer usersid) {
this.usersid = usersid;
}
/**
* shangpin
*
* @return shangpin shangpin
*/
public Shangpin getShangpin() {
return this.shangpin;
}
/**
* shangpin
*
* @param shangpin shangpin
*/
public void setShangpin(Shangpin shangpin) {
this.shangpin = shangpin;
}
/**
* users
*
* @return users users
*/
public Users getUsers() {
return this.users;
}
/**
* users
*
* @param users users
*/
public void setUsers(Users users) {
this.users = users;
}
}

@ -1,473 +0,0 @@
package com.entity;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName Gouwuche
* @Description mybatis
*/
public class GouwucheExample {
protected String orderByClause;
protected boolean distinct;
protected List<Criteria> oredCriteria;
public GouwucheExample() {
oredCriteria = new ArrayList<Criteria>();
}
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
public String getOrderByClause() {
return orderByClause;
}
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
public boolean isDistinct() {
return distinct;
}
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
return criteria;
}
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
protected abstract static class GeneratedCriteria {
protected List<Criterion> criteria;
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
public boolean isValid() {
return criteria.size() > 0;
}
public List<Criterion> getAllCriteria() {
return criteria;
}
public List<Criterion> getCriteria() {
return criteria;
}
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
}
criteria.add(new Criterion(condition));
}
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value));
}
protected void addCriterion(String condition, Object value1, Object value2, String property) {
if (value1 == null || value2 == null) {
throw new RuntimeException("Between values for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value1, value2));
}
public Criteria andIdIsNull() {
addCriterion("id is null");
return (Criteria) this;
}
public Criteria andIdIsNotNull() {
addCriterion("id is not null");
return (Criteria) this;
}
public Criteria andIdEqualTo(Integer value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(Integer value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Integer value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Integer value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Integer value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Integer> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andShangpinidIsNull() {
addCriterion("shangpinid is null");
return (Criteria) this;
}
public Criteria andShangpinidIsNotNull() {
addCriterion("shangpinid is not null");
return (Criteria) this;
}
public Criteria andShangpinidEqualTo(Integer value) {
addCriterion("shangpinid =", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidNotEqualTo(Integer value) {
addCriterion("shangpinid <>", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidGreaterThan(Integer value) {
addCriterion("shangpinid >", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidGreaterThanOrEqualTo(Integer value) {
addCriterion("shangpinid >=", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidLessThan(Integer value) {
addCriterion("shangpinid <", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidLessThanOrEqualTo(Integer value) {
addCriterion("shangpinid <=", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidLike(Integer value) {
addCriterion("shangpinid like", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidNotLike(Integer value) {
addCriterion("shangpinid not like", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidIn(List<Integer> values) {
addCriterion("shangpinid in", values, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidNotIn(List<Integer> values) {
addCriterion("shangpinid not in", values, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidBetween(Integer value1, Integer value2) {
addCriterion("shangpinid between", value1, value2, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidNotBetween(Integer value1, Integer value2) {
addCriterion("shangpinid not between", value1, value2, "shangpinid");
return (Criteria) this;
}
public Criteria andGoumaishuliangIsNull() {
addCriterion("goumaishuliang is null");
return (Criteria) this;
}
public Criteria andGoumaishuliangIsNotNull() {
addCriterion("goumaishuliang is not null");
return (Criteria) this;
}
public Criteria andGoumaishuliangEqualTo(Integer value) {
addCriterion("goumaishuliang =", value, "goumaishuliang");
return (Criteria) this;
}
public Criteria andGoumaishuliangNotEqualTo(Integer value) {
addCriterion("goumaishuliang <>", value, "goumaishuliang");
return (Criteria) this;
}
public Criteria andGoumaishuliangGreaterThan(Integer value) {
addCriterion("goumaishuliang >", value, "goumaishuliang");
return (Criteria) this;
}
public Criteria andGoumaishuliangGreaterThanOrEqualTo(Integer value) {
addCriterion("goumaishuliang >=", value, "goumaishuliang");
return (Criteria) this;
}
public Criteria andGoumaishuliangLessThan(Integer value) {
addCriterion("goumaishuliang <", value, "goumaishuliang");
return (Criteria) this;
}
public Criteria andGoumaishuliangLessThanOrEqualTo(Integer value) {
addCriterion("goumaishuliang <=", value, "goumaishuliang");
return (Criteria) this;
}
public Criteria andGoumaishuliangLike(Integer value) {
addCriterion("goumaishuliang like", value, "goumaishuliang");
return (Criteria) this;
}
public Criteria andGoumaishuliangNotLike(Integer value) {
addCriterion("goumaishuliang not like", value, "goumaishuliang");
return (Criteria) this;
}
public Criteria andGoumaishuliangIn(List<Integer> values) {
addCriterion("goumaishuliang in", values, "goumaishuliang");
return (Criteria) this;
}
public Criteria andGoumaishuliangNotIn(List<Integer> values) {
addCriterion("goumaishuliang not in", values, "goumaishuliang");
return (Criteria) this;
}
public Criteria andGoumaishuliangBetween(Integer value1, Integer value2) {
addCriterion("goumaishuliang between", value1, value2, "goumaishuliang");
return (Criteria) this;
}
public Criteria andGoumaishuliangNotBetween(Integer value1, Integer value2) {
addCriterion("goumaishuliang not between", value1, value2, "goumaishuliang");
return (Criteria) this;
}
public Criteria andUsersidIsNull() {
addCriterion("usersid is null");
return (Criteria) this;
}
public Criteria andUsersidIsNotNull() {
addCriterion("usersid is not null");
return (Criteria) this;
}
public Criteria andUsersidEqualTo(Integer value) {
addCriterion("usersid =", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidNotEqualTo(Integer value) {
addCriterion("usersid <>", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidGreaterThan(Integer value) {
addCriterion("usersid >", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidGreaterThanOrEqualTo(Integer value) {
addCriterion("usersid >=", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidLessThan(Integer value) {
addCriterion("usersid <", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidLessThanOrEqualTo(Integer value) {
addCriterion("usersid <=", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidLike(Integer value) {
addCriterion("usersid like", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidNotLike(Integer value) {
addCriterion("usersid not like", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidIn(List<Integer> values) {
addCriterion("usersid in", values, "usersid");
return (Criteria) this;
}
public Criteria andUsersidNotIn(List<Integer> values) {
addCriterion("usersid not in", values, "usersid");
return (Criteria) this;
}
public Criteria andUsersidBetween(Integer value1, Integer value2) {
addCriterion("usersid between", value1, value2, "usersid");
return (Criteria) this;
}
public Criteria andUsersidNotBetween(Integer value1, Integer value2) {
addCriterion("usersid not between", value1, value2, "usersid");
return (Criteria) this;
}
}
public static class Criteria extends GeneratedCriteria {
protected Criteria() {
super();
}
}
public static class Criterion {
private String condition;
private Object value;
private Object secondValue;
private boolean noValue;
private boolean singleValue;
private boolean betweenValue;
private boolean listValue;
private String typeHandler;
public String getCondition() {
return condition;
}
public Object getValue() {
return value;
}
public Object getSecondValue() {
return secondValue;
}
public boolean isNoValue() {
return noValue;
}
public boolean isSingleValue() {
return singleValue;
}
public boolean isBetweenValue() {
return betweenValue;
}
public boolean isListValue() {
return listValue;
}
public String getTypeHandler() {
return typeHandler;
}
protected Criterion(String condition) {
super();
this.condition = condition;
this.typeHandler = null;
this.noValue = true;
}
protected Criterion(String condition, Object value, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.typeHandler = typeHandler;
if (value instanceof List<?>) {
this.listValue = true;
} else {
this.singleValue = true;
}
}
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.secondValue = secondValue;
this.typeHandler = typeHandler;
this.betweenValue = true;
}
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}
}
}

@ -1,72 +0,0 @@
package com.entity;
/**
* @ClassName Lianjie
* @Description
*/
public class Lianjie {
//id列
private Integer id;
//名称
private String name;
//链接地址
private String url;
/**
* id
*
* @return id id
*/
public Integer getId() {
return this.id;
}
/**
* id
*
* @param id id
*/
public void setId(Integer id) {
this.id = id;
}
/**
*
*
* @return name
*/
public String getName() {
return this.name;
}
/**
*
*
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
*
*
* @return url
*/
public String getUrl() {
return this.url;
}
/**
*
*
* @param url
*/
public void setUrl(String url) {
this.url = url;
}
}

@ -1,404 +0,0 @@
package com.entity;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName Lianjie
* @Description mybatis
*/
public class LianjieExample {
protected String orderByClause;
protected boolean distinct;
protected List<Criteria> oredCriteria;
public LianjieExample() {
oredCriteria = new ArrayList<Criteria>();
}
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
public String getOrderByClause() {
return orderByClause;
}
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
public boolean isDistinct() {
return distinct;
}
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
return criteria;
}
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
protected abstract static class GeneratedCriteria {
protected List<Criterion> criteria;
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
public boolean isValid() {
return criteria.size() > 0;
}
public List<Criterion> getAllCriteria() {
return criteria;
}
public List<Criterion> getCriteria() {
return criteria;
}
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
}
criteria.add(new Criterion(condition));
}
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value));
}
protected void addCriterion(String condition, Object value1, Object value2, String property) {
if (value1 == null || value2 == null) {
throw new RuntimeException("Between values for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value1, value2));
}
public Criteria andIdIsNull() {
addCriterion("id is null");
return (Criteria) this;
}
public Criteria andIdIsNotNull() {
addCriterion("id is not null");
return (Criteria) this;
}
public Criteria andIdEqualTo(Integer value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(Integer value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Integer value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Integer value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Integer value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Integer> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andNameIsNull() {
addCriterion("name is null");
return (Criteria) this;
}
public Criteria andNameIsNotNull() {
addCriterion("name is not null");
return (Criteria) this;
}
public Criteria andNameEqualTo(String value) {
addCriterion("name =", value, "name");
return (Criteria) this;
}
public Criteria andNameNotEqualTo(String value) {
addCriterion("name <>", value, "name");
return (Criteria) this;
}
public Criteria andNameGreaterThan(String value) {
addCriterion("name >", value, "name");
return (Criteria) this;
}
public Criteria andNameGreaterThanOrEqualTo(String value) {
addCriterion("name >=", value, "name");
return (Criteria) this;
}
public Criteria andNameLessThan(String value) {
addCriterion("name <", value, "name");
return (Criteria) this;
}
public Criteria andNameLessThanOrEqualTo(String value) {
addCriterion("name <=", value, "name");
return (Criteria) this;
}
public Criteria andNameLike(String value) {
addCriterion("name like", value, "name");
return (Criteria) this;
}
public Criteria andNameNotLike(String value) {
addCriterion("name not like", value, "name");
return (Criteria) this;
}
public Criteria andNameIn(List<String> values) {
addCriterion("name in", values, "name");
return (Criteria) this;
}
public Criteria andNameNotIn(List<String> values) {
addCriterion("name not in", values, "name");
return (Criteria) this;
}
public Criteria andNameBetween(String value1, String value2) {
addCriterion("name between", value1, value2, "name");
return (Criteria) this;
}
public Criteria andNameNotBetween(String value1, String value2) {
addCriterion("name not between", value1, value2, "name");
return (Criteria) this;
}
public Criteria andUrlIsNull() {
addCriterion("url is null");
return (Criteria) this;
}
public Criteria andUrlIsNotNull() {
addCriterion("url is not null");
return (Criteria) this;
}
public Criteria andUrlEqualTo(String value) {
addCriterion("url =", value, "url");
return (Criteria) this;
}
public Criteria andUrlNotEqualTo(String value) {
addCriterion("url <>", value, "url");
return (Criteria) this;
}
public Criteria andUrlGreaterThan(String value) {
addCriterion("url >", value, "url");
return (Criteria) this;
}
public Criteria andUrlGreaterThanOrEqualTo(String value) {
addCriterion("url >=", value, "url");
return (Criteria) this;
}
public Criteria andUrlLessThan(String value) {
addCriterion("url <", value, "url");
return (Criteria) this;
}
public Criteria andUrlLessThanOrEqualTo(String value) {
addCriterion("url <=", value, "url");
return (Criteria) this;
}
public Criteria andUrlLike(String value) {
addCriterion("url like", value, "url");
return (Criteria) this;
}
public Criteria andUrlNotLike(String value) {
addCriterion("url not like", value, "url");
return (Criteria) this;
}
public Criteria andUrlIn(List<String> values) {
addCriterion("url in", values, "url");
return (Criteria) this;
}
public Criteria andUrlNotIn(List<String> values) {
addCriterion("url not in", values, "url");
return (Criteria) this;
}
public Criteria andUrlBetween(String value1, String value2) {
addCriterion("url between", value1, value2, "url");
return (Criteria) this;
}
public Criteria andUrlNotBetween(String value1, String value2) {
addCriterion("url not between", value1, value2, "url");
return (Criteria) this;
}
}
public static class Criteria extends GeneratedCriteria {
protected Criteria() {
super();
}
}
public static class Criterion {
private String condition;
private Object value;
private Object secondValue;
private boolean noValue;
private boolean singleValue;
private boolean betweenValue;
private boolean listValue;
private String typeHandler;
public String getCondition() {
return condition;
}
public Object getValue() {
return value;
}
public Object getSecondValue() {
return secondValue;
}
public boolean isNoValue() {
return noValue;
}
public boolean isSingleValue() {
return singleValue;
}
public boolean isBetweenValue() {
return betweenValue;
}
public boolean isListValue() {
return listValue;
}
public String getTypeHandler() {
return typeHandler;
}
protected Criterion(String condition) {
super();
this.condition = condition;
this.typeHandler = null;
this.noValue = true;
}
protected Criterion(String condition, Object value, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.typeHandler = typeHandler;
if (value instanceof List<?>) {
this.listValue = true;
} else {
this.singleValue = true;
}
}
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.secondValue = secondValue;
this.typeHandler = typeHandler;
this.betweenValue = true;
}
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}
}
}

@ -1,148 +0,0 @@
package com.entity;
/**
* @ClassName Liuyan
* @Description
*/
public class Liuyan {
//id列
private Integer id;
//标题
private String biaoti;
//内容
private String neirong;
//留言添加时间
private String addshijian;
//用户id
private Integer usersid;
//回复
private String huifu;
//父表用户表users
private Users users;
/**
* id
*
* @return id id
*/
public Integer getId() {
return this.id;
}
/**
* id
*
* @param id id
*/
public void setId(Integer id) {
this.id = id;
}
/**
*
*
* @return biaoti
*/
public String getBiaoti() {
return this.biaoti;
}
/**
*
*
* @param biaoti
*/
public void setBiaoti(String biaoti) {
this.biaoti = biaoti;
}
/**
*
*
* @return neirong
*/
public String getNeirong() {
return this.neirong;
}
/**
*
*
* @param neirong
*/
public void setNeirong(String neirong) {
this.neirong = neirong;
}
/**
*
*
* @return addshijian
*/
public String getAddshijian() {
return this.addshijian;
}
/**
*
*
* @param addshijian
*/
public void setAddshijian(String addshijian) {
this.addshijian = addshijian;
}
/**
* id
*
* @return usersid id
*/
public Integer getUsersid() {
return this.usersid;
}
/**
* id
*
* @param usersid id
*/
public void setUsersid(Integer usersid) {
this.usersid = usersid;
}
/**
*
*
* @return huifu
*/
public String getHuifu() {
return this.huifu;
}
/**
*
*
* @param huifu
*/
public void setHuifu(String huifu) {
this.huifu = huifu;
}
/**
* users
*
* @return users users
*/
public Users getUsers() {
return this.users;
}
/**
* users
*
* @param users users
*/
public void setUsers(Users users) {
this.users = users;
}
}

@ -1,611 +0,0 @@
package com.entity;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName Liuyan
* @Description mybatis
*/
public class LiuyanExample {
protected String orderByClause;
protected boolean distinct;
protected List<Criteria> oredCriteria;
public LiuyanExample() {
oredCriteria = new ArrayList<Criteria>();
}
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
public String getOrderByClause() {
return orderByClause;
}
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
public boolean isDistinct() {
return distinct;
}
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
return criteria;
}
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
protected abstract static class GeneratedCriteria {
protected List<Criterion> criteria;
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
public boolean isValid() {
return criteria.size() > 0;
}
public List<Criterion> getAllCriteria() {
return criteria;
}
public List<Criterion> getCriteria() {
return criteria;
}
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
}
criteria.add(new Criterion(condition));
}
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value));
}
protected void addCriterion(String condition, Object value1, Object value2, String property) {
if (value1 == null || value2 == null) {
throw new RuntimeException("Between values for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value1, value2));
}
public Criteria andIdIsNull() {
addCriterion("id is null");
return (Criteria) this;
}
public Criteria andIdIsNotNull() {
addCriterion("id is not null");
return (Criteria) this;
}
public Criteria andIdEqualTo(Integer value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(Integer value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Integer value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Integer value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Integer value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Integer> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andBiaotiIsNull() {
addCriterion("biaoti is null");
return (Criteria) this;
}
public Criteria andBiaotiIsNotNull() {
addCriterion("biaoti is not null");
return (Criteria) this;
}
public Criteria andBiaotiEqualTo(String value) {
addCriterion("biaoti =", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiNotEqualTo(String value) {
addCriterion("biaoti <>", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiGreaterThan(String value) {
addCriterion("biaoti >", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiGreaterThanOrEqualTo(String value) {
addCriterion("biaoti >=", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiLessThan(String value) {
addCriterion("biaoti <", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiLessThanOrEqualTo(String value) {
addCriterion("biaoti <=", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiLike(String value) {
addCriterion("biaoti like", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiNotLike(String value) {
addCriterion("biaoti not like", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiIn(List<String> values) {
addCriterion("biaoti in", values, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiNotIn(List<String> values) {
addCriterion("biaoti not in", values, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiBetween(String value1, String value2) {
addCriterion("biaoti between", value1, value2, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiNotBetween(String value1, String value2) {
addCriterion("biaoti not between", value1, value2, "biaoti");
return (Criteria) this;
}
public Criteria andNeirongIsNull() {
addCriterion("neirong is null");
return (Criteria) this;
}
public Criteria andNeirongIsNotNull() {
addCriterion("neirong is not null");
return (Criteria) this;
}
public Criteria andNeirongEqualTo(String value) {
addCriterion("neirong =", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongNotEqualTo(String value) {
addCriterion("neirong <>", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongGreaterThan(String value) {
addCriterion("neirong >", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongGreaterThanOrEqualTo(String value) {
addCriterion("neirong >=", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongLessThan(String value) {
addCriterion("neirong <", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongLessThanOrEqualTo(String value) {
addCriterion("neirong <=", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongLike(String value) {
addCriterion("neirong like", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongNotLike(String value) {
addCriterion("neirong not like", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongIn(List<String> values) {
addCriterion("neirong in", values, "neirong");
return (Criteria) this;
}
public Criteria andNeirongNotIn(List<String> values) {
addCriterion("neirong not in", values, "neirong");
return (Criteria) this;
}
public Criteria andNeirongBetween(String value1, String value2) {
addCriterion("neirong between", value1, value2, "neirong");
return (Criteria) this;
}
public Criteria andNeirongNotBetween(String value1, String value2) {
addCriterion("neirong not between", value1, value2, "neirong");
return (Criteria) this;
}
public Criteria andAddshijianIsNull() {
addCriterion("addshijian is null");
return (Criteria) this;
}
public Criteria andAddshijianIsNotNull() {
addCriterion("addshijian is not null");
return (Criteria) this;
}
public Criteria andAddshijianEqualTo(String value) {
addCriterion("addshijian =", value, "addshijian");
return (Criteria) this;
}
public Criteria andAddshijianNotEqualTo(String value) {
addCriterion("addshijian <>", value, "addshijian");
return (Criteria) this;
}
public Criteria andAddshijianGreaterThan(String value) {
addCriterion("addshijian >", value, "addshijian");
return (Criteria) this;
}
public Criteria andAddshijianGreaterThanOrEqualTo(String value) {
addCriterion("addshijian >=", value, "addshijian");
return (Criteria) this;
}
public Criteria andAddshijianLessThan(String value) {
addCriterion("addshijian <", value, "addshijian");
return (Criteria) this;
}
public Criteria andAddshijianLessThanOrEqualTo(String value) {
addCriterion("addshijian <=", value, "addshijian");
return (Criteria) this;
}
public Criteria andAddshijianLike(String value) {
addCriterion("addshijian like", value, "addshijian");
return (Criteria) this;
}
public Criteria andAddshijianNotLike(String value) {
addCriterion("addshijian not like", value, "addshijian");
return (Criteria) this;
}
public Criteria andAddshijianIn(List<String> values) {
addCriterion("addshijian in", values, "addshijian");
return (Criteria) this;
}
public Criteria andAddshijianNotIn(List<String> values) {
addCriterion("addshijian not in", values, "addshijian");
return (Criteria) this;
}
public Criteria andAddshijianBetween(String value1, String value2) {
addCriterion("addshijian between", value1, value2, "addshijian");
return (Criteria) this;
}
public Criteria andAddshijianNotBetween(String value1, String value2) {
addCriterion("addshijian not between", value1, value2, "addshijian");
return (Criteria) this;
}
public Criteria andUsersidIsNull() {
addCriterion("usersid is null");
return (Criteria) this;
}
public Criteria andUsersidIsNotNull() {
addCriterion("usersid is not null");
return (Criteria) this;
}
public Criteria andUsersidEqualTo(Integer value) {
addCriterion("usersid =", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidNotEqualTo(Integer value) {
addCriterion("usersid <>", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidGreaterThan(Integer value) {
addCriterion("usersid >", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidGreaterThanOrEqualTo(Integer value) {
addCriterion("usersid >=", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidLessThan(Integer value) {
addCriterion("usersid <", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidLessThanOrEqualTo(Integer value) {
addCriterion("usersid <=", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidLike(Integer value) {
addCriterion("usersid like", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidNotLike(Integer value) {
addCriterion("usersid not like", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidIn(List<Integer> values) {
addCriterion("usersid in", values, "usersid");
return (Criteria) this;
}
public Criteria andUsersidNotIn(List<Integer> values) {
addCriterion("usersid not in", values, "usersid");
return (Criteria) this;
}
public Criteria andUsersidBetween(Integer value1, Integer value2) {
addCriterion("usersid between", value1, value2, "usersid");
return (Criteria) this;
}
public Criteria andUsersidNotBetween(Integer value1, Integer value2) {
addCriterion("usersid not between", value1, value2, "usersid");
return (Criteria) this;
}
public Criteria andHuifuIsNull() {
addCriterion("huifu is null");
return (Criteria) this;
}
public Criteria andHuifuIsNotNull() {
addCriterion("huifu is not null");
return (Criteria) this;
}
public Criteria andHuifuEqualTo(String value) {
addCriterion("huifu =", value, "huifu");
return (Criteria) this;
}
public Criteria andHuifuNotEqualTo(String value) {
addCriterion("huifu <>", value, "huifu");
return (Criteria) this;
}
public Criteria andHuifuGreaterThan(String value) {
addCriterion("huifu >", value, "huifu");
return (Criteria) this;
}
public Criteria andHuifuGreaterThanOrEqualTo(String value) {
addCriterion("huifu >=", value, "huifu");
return (Criteria) this;
}
public Criteria andHuifuLessThan(String value) {
addCriterion("huifu <", value, "huifu");
return (Criteria) this;
}
public Criteria andHuifuLessThanOrEqualTo(String value) {
addCriterion("huifu <=", value, "huifu");
return (Criteria) this;
}
public Criteria andHuifuLike(String value) {
addCriterion("huifu like", value, "huifu");
return (Criteria) this;
}
public Criteria andHuifuNotLike(String value) {
addCriterion("huifu not like", value, "huifu");
return (Criteria) this;
}
public Criteria andHuifuIn(List<String> values) {
addCriterion("huifu in", values, "huifu");
return (Criteria) this;
}
public Criteria andHuifuNotIn(List<String> values) {
addCriterion("huifu not in", values, "huifu");
return (Criteria) this;
}
public Criteria andHuifuBetween(String value1, String value2) {
addCriterion("huifu between", value1, value2, "huifu");
return (Criteria) this;
}
public Criteria andHuifuNotBetween(String value1, String value2) {
addCriterion("huifu not between", value1, value2, "huifu");
return (Criteria) this;
}
}
public static class Criteria extends GeneratedCriteria {
protected Criteria() {
super();
}
}
public static class Criterion {
private String condition;
private Object value;
private Object secondValue;
private boolean noValue;
private boolean singleValue;
private boolean betweenValue;
private boolean listValue;
private String typeHandler;
public String getCondition() {
return condition;
}
public Object getValue() {
return value;
}
public Object getSecondValue() {
return secondValue;
}
public boolean isNoValue() {
return noValue;
}
public boolean isSingleValue() {
return singleValue;
}
public boolean isBetweenValue() {
return betweenValue;
}
public boolean isListValue() {
return listValue;
}
public String getTypeHandler() {
return typeHandler;
}
protected Criterion(String condition) {
super();
this.condition = condition;
this.typeHandler = null;
this.noValue = true;
}
protected Criterion(String condition, Object value, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.typeHandler = typeHandler;
if (value instanceof List<?>) {
this.listValue = true;
} else {
this.singleValue = true;
}
}
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.secondValue = secondValue;
this.typeHandler = typeHandler;
this.betweenValue = true;
}
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}
}
}

@ -1,72 +0,0 @@
package com.entity;
/**
* @ClassName Lunbo
* @Description
*/
public class Lunbo {
//id列
private Integer id;
//标题
private String biaoti;
//图片
private String image;
/**
* id
*
* @return id id
*/
public Integer getId() {
return this.id;
}
/**
* id
*
* @param id id
*/
public void setId(Integer id) {
this.id = id;
}
/**
*
*
* @return biaoti
*/
public String getBiaoti() {
return this.biaoti;
}
/**
*
*
* @param biaoti
*/
public void setBiaoti(String biaoti) {
this.biaoti = biaoti;
}
/**
*
*
* @return image
*/
public String getImage() {
return this.image;
}
/**
*
*
* @param image
*/
public void setImage(String image) {
this.image = image;
}
}

@ -1,404 +0,0 @@
package com.entity;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName Lunbo
* @Description mybatis
*/
public class LunboExample {
protected String orderByClause;
protected boolean distinct;
protected List<Criteria> oredCriteria;
public LunboExample() {
oredCriteria = new ArrayList<Criteria>();
}
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
public String getOrderByClause() {
return orderByClause;
}
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
public boolean isDistinct() {
return distinct;
}
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
return criteria;
}
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
protected abstract static class GeneratedCriteria {
protected List<Criterion> criteria;
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
public boolean isValid() {
return criteria.size() > 0;
}
public List<Criterion> getAllCriteria() {
return criteria;
}
public List<Criterion> getCriteria() {
return criteria;
}
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
}
criteria.add(new Criterion(condition));
}
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value));
}
protected void addCriterion(String condition, Object value1, Object value2, String property) {
if (value1 == null || value2 == null) {
throw new RuntimeException("Between values for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value1, value2));
}
public Criteria andIdIsNull() {
addCriterion("id is null");
return (Criteria) this;
}
public Criteria andIdIsNotNull() {
addCriterion("id is not null");
return (Criteria) this;
}
public Criteria andIdEqualTo(Integer value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(Integer value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Integer value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Integer value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Integer value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Integer> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andBiaotiIsNull() {
addCriterion("biaoti is null");
return (Criteria) this;
}
public Criteria andBiaotiIsNotNull() {
addCriterion("biaoti is not null");
return (Criteria) this;
}
public Criteria andBiaotiEqualTo(String value) {
addCriterion("biaoti =", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiNotEqualTo(String value) {
addCriterion("biaoti <>", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiGreaterThan(String value) {
addCriterion("biaoti >", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiGreaterThanOrEqualTo(String value) {
addCriterion("biaoti >=", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiLessThan(String value) {
addCriterion("biaoti <", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiLessThanOrEqualTo(String value) {
addCriterion("biaoti <=", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiLike(String value) {
addCriterion("biaoti like", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiNotLike(String value) {
addCriterion("biaoti not like", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiIn(List<String> values) {
addCriterion("biaoti in", values, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiNotIn(List<String> values) {
addCriterion("biaoti not in", values, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiBetween(String value1, String value2) {
addCriterion("biaoti between", value1, value2, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiNotBetween(String value1, String value2) {
addCriterion("biaoti not between", value1, value2, "biaoti");
return (Criteria) this;
}
public Criteria andImageIsNull() {
addCriterion("image is null");
return (Criteria) this;
}
public Criteria andImageIsNotNull() {
addCriterion("image is not null");
return (Criteria) this;
}
public Criteria andImageEqualTo(String value) {
addCriterion("image =", value, "image");
return (Criteria) this;
}
public Criteria andImageNotEqualTo(String value) {
addCriterion("image <>", value, "image");
return (Criteria) this;
}
public Criteria andImageGreaterThan(String value) {
addCriterion("image >", value, "image");
return (Criteria) this;
}
public Criteria andImageGreaterThanOrEqualTo(String value) {
addCriterion("image >=", value, "image");
return (Criteria) this;
}
public Criteria andImageLessThan(String value) {
addCriterion("image <", value, "image");
return (Criteria) this;
}
public Criteria andImageLessThanOrEqualTo(String value) {
addCriterion("image <=", value, "image");
return (Criteria) this;
}
public Criteria andImageLike(String value) {
addCriterion("image like", value, "image");
return (Criteria) this;
}
public Criteria andImageNotLike(String value) {
addCriterion("image not like", value, "image");
return (Criteria) this;
}
public Criteria andImageIn(List<String> values) {
addCriterion("image in", values, "image");
return (Criteria) this;
}
public Criteria andImageNotIn(List<String> values) {
addCriterion("image not in", values, "image");
return (Criteria) this;
}
public Criteria andImageBetween(String value1, String value2) {
addCriterion("image between", value1, value2, "image");
return (Criteria) this;
}
public Criteria andImageNotBetween(String value1, String value2) {
addCriterion("image not between", value1, value2, "image");
return (Criteria) this;
}
}
public static class Criteria extends GeneratedCriteria {
protected Criteria() {
super();
}
}
public static class Criterion {
private String condition;
private Object value;
private Object secondValue;
private boolean noValue;
private boolean singleValue;
private boolean betweenValue;
private boolean listValue;
private String typeHandler;
public String getCondition() {
return condition;
}
public Object getValue() {
return value;
}
public Object getSecondValue() {
return secondValue;
}
public boolean isNoValue() {
return noValue;
}
public boolean isSingleValue() {
return singleValue;
}
public boolean isBetweenValue() {
return betweenValue;
}
public boolean isListValue() {
return listValue;
}
public String getTypeHandler() {
return typeHandler;
}
protected Criterion(String condition) {
super();
this.condition = condition;
this.typeHandler = null;
this.noValue = true;
}
protected Criterion(String condition, Object value, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.typeHandler = typeHandler;
if (value instanceof List<?>) {
this.listValue = true;
} else {
this.singleValue = true;
}
}
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.secondValue = secondValue;
this.typeHandler = typeHandler;
this.betweenValue = true;
}
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}
}
}

@ -1,167 +0,0 @@
package com.entity;
/**
* @ClassName Pingjia
* @Description
*/
public class Pingjia {
//id列
private Integer id;
//评语
private String biaoti;
//分数范围1-5
private String fenshu;
//时间
private String shijian;
//零食id
private Integer shangpinid;
//用户id
private Integer usersid;
//父表零食表shangpin
private Shangpin shangpin;
//父表用户表users
private Users users;
/**
* id
*
* @return id id
*/
public Integer getId() {
return this.id;
}
/**
* id
*
* @param id id
*/
public void setId(Integer id) {
this.id = id;
}
/**
*
*
* @return biaoti
*/
public String getBiaoti() {
return this.biaoti;
}
/**
*
*
* @param biaoti
*/
public void setBiaoti(String biaoti) {
this.biaoti = biaoti;
}
/**
* 1-5
*
* @return fenshu 1-5
*/
public String getFenshu() {
return this.fenshu;
}
/**
* 1-5
*
* @param fenshu 1-5
*/
public void setFenshu(String fenshu) {
this.fenshu = fenshu;
}
/**
*
*
* @return shijian
*/
public String getShijian() {
return this.shijian;
}
/**
*
*
* @param shijian
*/
public void setShijian(String shijian) {
this.shijian = shijian;
}
/**
* id
*
* @return shangpinid id
*/
public Integer getShangpinid() {
return this.shangpinid;
}
/**
* id
*
* @param shangpinid id
*/
public void setShangpinid(Integer shangpinid) {
this.shangpinid = shangpinid;
}
/**
* id
*
* @return usersid id
*/
public Integer getUsersid() {
return this.usersid;
}
/**
* id
*
* @param usersid id
*/
public void setUsersid(Integer usersid) {
this.usersid = usersid;
}
/**
* shangpin
*
* @return shangpin shangpin
*/
public Shangpin getShangpin() {
return this.shangpin;
}
/**
* shangpin
*
* @param shangpin shangpin
*/
public void setShangpin(Shangpin shangpin) {
this.shangpin = shangpin;
}
/**
* users
*
* @return users users
*/
public Users getUsers() {
return this.users;
}
/**
* users
*
* @param users users
*/
public void setUsers(Users users) {
this.users = users;
}
}

@ -1,611 +0,0 @@
package com.entity;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName Pingjia
* @Description mybatis
*/
public class PingjiaExample {
protected String orderByClause;
protected boolean distinct;
protected List<Criteria> oredCriteria;
public PingjiaExample() {
oredCriteria = new ArrayList<Criteria>();
}
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
public String getOrderByClause() {
return orderByClause;
}
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
public boolean isDistinct() {
return distinct;
}
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
return criteria;
}
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
protected abstract static class GeneratedCriteria {
protected List<Criterion> criteria;
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
public boolean isValid() {
return criteria.size() > 0;
}
public List<Criterion> getAllCriteria() {
return criteria;
}
public List<Criterion> getCriteria() {
return criteria;
}
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
}
criteria.add(new Criterion(condition));
}
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value));
}
protected void addCriterion(String condition, Object value1, Object value2, String property) {
if (value1 == null || value2 == null) {
throw new RuntimeException("Between values for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value1, value2));
}
public Criteria andIdIsNull() {
addCriterion("id is null");
return (Criteria) this;
}
public Criteria andIdIsNotNull() {
addCriterion("id is not null");
return (Criteria) this;
}
public Criteria andIdEqualTo(Integer value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(Integer value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Integer value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Integer value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Integer value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Integer> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andBiaotiIsNull() {
addCriterion("biaoti is null");
return (Criteria) this;
}
public Criteria andBiaotiIsNotNull() {
addCriterion("biaoti is not null");
return (Criteria) this;
}
public Criteria andBiaotiEqualTo(String value) {
addCriterion("biaoti =", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiNotEqualTo(String value) {
addCriterion("biaoti <>", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiGreaterThan(String value) {
addCriterion("biaoti >", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiGreaterThanOrEqualTo(String value) {
addCriterion("biaoti >=", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiLessThan(String value) {
addCriterion("biaoti <", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiLessThanOrEqualTo(String value) {
addCriterion("biaoti <=", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiLike(String value) {
addCriterion("biaoti like", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiNotLike(String value) {
addCriterion("biaoti not like", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiIn(List<String> values) {
addCriterion("biaoti in", values, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiNotIn(List<String> values) {
addCriterion("biaoti not in", values, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiBetween(String value1, String value2) {
addCriterion("biaoti between", value1, value2, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiNotBetween(String value1, String value2) {
addCriterion("biaoti not between", value1, value2, "biaoti");
return (Criteria) this;
}
public Criteria andFenshuIsNull() {
addCriterion("fenshu is null");
return (Criteria) this;
}
public Criteria andFenshuIsNotNull() {
addCriterion("fenshu is not null");
return (Criteria) this;
}
public Criteria andFenshuEqualTo(String value) {
addCriterion("fenshu =", value, "fenshu");
return (Criteria) this;
}
public Criteria andFenshuNotEqualTo(String value) {
addCriterion("fenshu <>", value, "fenshu");
return (Criteria) this;
}
public Criteria andFenshuGreaterThan(String value) {
addCriterion("fenshu >", value, "fenshu");
return (Criteria) this;
}
public Criteria andFenshuGreaterThanOrEqualTo(String value) {
addCriterion("fenshu >=", value, "fenshu");
return (Criteria) this;
}
public Criteria andFenshuLessThan(String value) {
addCriterion("fenshu <", value, "fenshu");
return (Criteria) this;
}
public Criteria andFenshuLessThanOrEqualTo(String value) {
addCriterion("fenshu <=", value, "fenshu");
return (Criteria) this;
}
public Criteria andFenshuLike(String value) {
addCriterion("fenshu like", value, "fenshu");
return (Criteria) this;
}
public Criteria andFenshuNotLike(String value) {
addCriterion("fenshu not like", value, "fenshu");
return (Criteria) this;
}
public Criteria andFenshuIn(List<String> values) {
addCriterion("fenshu in", values, "fenshu");
return (Criteria) this;
}
public Criteria andFenshuNotIn(List<String> values) {
addCriterion("fenshu not in", values, "fenshu");
return (Criteria) this;
}
public Criteria andFenshuBetween(String value1, String value2) {
addCriterion("fenshu between", value1, value2, "fenshu");
return (Criteria) this;
}
public Criteria andFenshuNotBetween(String value1, String value2) {
addCriterion("fenshu not between", value1, value2, "fenshu");
return (Criteria) this;
}
public Criteria andShijianIsNull() {
addCriterion("shijian is null");
return (Criteria) this;
}
public Criteria andShijianIsNotNull() {
addCriterion("shijian is not null");
return (Criteria) this;
}
public Criteria andShijianEqualTo(String value) {
addCriterion("shijian =", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianNotEqualTo(String value) {
addCriterion("shijian <>", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianGreaterThan(String value) {
addCriterion("shijian >", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianGreaterThanOrEqualTo(String value) {
addCriterion("shijian >=", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianLessThan(String value) {
addCriterion("shijian <", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianLessThanOrEqualTo(String value) {
addCriterion("shijian <=", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianLike(String value) {
addCriterion("shijian like", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianNotLike(String value) {
addCriterion("shijian not like", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianIn(List<String> values) {
addCriterion("shijian in", values, "shijian");
return (Criteria) this;
}
public Criteria andShijianNotIn(List<String> values) {
addCriterion("shijian not in", values, "shijian");
return (Criteria) this;
}
public Criteria andShijianBetween(String value1, String value2) {
addCriterion("shijian between", value1, value2, "shijian");
return (Criteria) this;
}
public Criteria andShijianNotBetween(String value1, String value2) {
addCriterion("shijian not between", value1, value2, "shijian");
return (Criteria) this;
}
public Criteria andShangpinidIsNull() {
addCriterion("shangpinid is null");
return (Criteria) this;
}
public Criteria andShangpinidIsNotNull() {
addCriterion("shangpinid is not null");
return (Criteria) this;
}
public Criteria andShangpinidEqualTo(Integer value) {
addCriterion("shangpinid =", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidNotEqualTo(Integer value) {
addCriterion("shangpinid <>", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidGreaterThan(Integer value) {
addCriterion("shangpinid >", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidGreaterThanOrEqualTo(Integer value) {
addCriterion("shangpinid >=", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidLessThan(Integer value) {
addCriterion("shangpinid <", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidLessThanOrEqualTo(Integer value) {
addCriterion("shangpinid <=", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidLike(Integer value) {
addCriterion("shangpinid like", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidNotLike(Integer value) {
addCriterion("shangpinid not like", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidIn(List<Integer> values) {
addCriterion("shangpinid in", values, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidNotIn(List<Integer> values) {
addCriterion("shangpinid not in", values, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidBetween(Integer value1, Integer value2) {
addCriterion("shangpinid between", value1, value2, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidNotBetween(Integer value1, Integer value2) {
addCriterion("shangpinid not between", value1, value2, "shangpinid");
return (Criteria) this;
}
public Criteria andUsersidIsNull() {
addCriterion("usersid is null");
return (Criteria) this;
}
public Criteria andUsersidIsNotNull() {
addCriterion("usersid is not null");
return (Criteria) this;
}
public Criteria andUsersidEqualTo(Integer value) {
addCriterion("usersid =", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidNotEqualTo(Integer value) {
addCriterion("usersid <>", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidGreaterThan(Integer value) {
addCriterion("usersid >", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidGreaterThanOrEqualTo(Integer value) {
addCriterion("usersid >=", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidLessThan(Integer value) {
addCriterion("usersid <", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidLessThanOrEqualTo(Integer value) {
addCriterion("usersid <=", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidLike(Integer value) {
addCriterion("usersid like", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidNotLike(Integer value) {
addCriterion("usersid not like", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidIn(List<Integer> values) {
addCriterion("usersid in", values, "usersid");
return (Criteria) this;
}
public Criteria andUsersidNotIn(List<Integer> values) {
addCriterion("usersid not in", values, "usersid");
return (Criteria) this;
}
public Criteria andUsersidBetween(Integer value1, Integer value2) {
addCriterion("usersid between", value1, value2, "usersid");
return (Criteria) this;
}
public Criteria andUsersidNotBetween(Integer value1, Integer value2) {
addCriterion("usersid not between", value1, value2, "usersid");
return (Criteria) this;
}
}
public static class Criteria extends GeneratedCriteria {
protected Criteria() {
super();
}
}
public static class Criterion {
private String condition;
private Object value;
private Object secondValue;
private boolean noValue;
private boolean singleValue;
private boolean betweenValue;
private boolean listValue;
private String typeHandler;
public String getCondition() {
return condition;
}
public Object getValue() {
return value;
}
public Object getSecondValue() {
return secondValue;
}
public boolean isNoValue() {
return noValue;
}
public boolean isSingleValue() {
return singleValue;
}
public boolean isBetweenValue() {
return betweenValue;
}
public boolean isListValue() {
return listValue;
}
public String getTypeHandler() {
return typeHandler;
}
protected Criterion(String condition) {
super();
this.condition = condition;
this.typeHandler = null;
this.noValue = true;
}
protected Criterion(String condition, Object value, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.typeHandler = typeHandler;
if (value instanceof List<?>) {
this.listValue = true;
} else {
this.singleValue = true;
}
}
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.secondValue = secondValue;
this.typeHandler = typeHandler;
this.betweenValue = true;
}
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}
}
}

@ -1,53 +0,0 @@
package com.entity;
/**
* @ClassName Pinlei
* @Description
*/
public class Pinlei {
//id列
private Integer id;
//名称
private String mingcheng;
/**
* id
*
* @return id id
*/
public Integer getId() {
return this.id;
}
/**
* id
*
* @param id id
*/
public void setId(Integer id) {
this.id = id;
}
/**
*
*
* @return mingcheng
*/
public String getMingcheng() {
return this.mingcheng;
}
/**
*
*
* @param mingcheng
*/
public void setMingcheng(String mingcheng) {
this.mingcheng = mingcheng;
}
}

@ -1,335 +0,0 @@
package com.entity;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName Pinlei
* @Description mybatis
*/
public class PinleiExample {
protected String orderByClause;
protected boolean distinct;
protected List<Criteria> oredCriteria;
public PinleiExample() {
oredCriteria = new ArrayList<Criteria>();
}
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
public String getOrderByClause() {
return orderByClause;
}
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
public boolean isDistinct() {
return distinct;
}
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
return criteria;
}
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
protected abstract static class GeneratedCriteria {
protected List<Criterion> criteria;
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
public boolean isValid() {
return criteria.size() > 0;
}
public List<Criterion> getAllCriteria() {
return criteria;
}
public List<Criterion> getCriteria() {
return criteria;
}
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
}
criteria.add(new Criterion(condition));
}
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value));
}
protected void addCriterion(String condition, Object value1, Object value2, String property) {
if (value1 == null || value2 == null) {
throw new RuntimeException("Between values for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value1, value2));
}
public Criteria andIdIsNull() {
addCriterion("id is null");
return (Criteria) this;
}
public Criteria andIdIsNotNull() {
addCriterion("id is not null");
return (Criteria) this;
}
public Criteria andIdEqualTo(Integer value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(Integer value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Integer value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Integer value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Integer value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Integer> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andMingchengIsNull() {
addCriterion("mingcheng is null");
return (Criteria) this;
}
public Criteria andMingchengIsNotNull() {
addCriterion("mingcheng is not null");
return (Criteria) this;
}
public Criteria andMingchengEqualTo(String value) {
addCriterion("mingcheng =", value, "mingcheng");
return (Criteria) this;
}
public Criteria andMingchengNotEqualTo(String value) {
addCriterion("mingcheng <>", value, "mingcheng");
return (Criteria) this;
}
public Criteria andMingchengGreaterThan(String value) {
addCriterion("mingcheng >", value, "mingcheng");
return (Criteria) this;
}
public Criteria andMingchengGreaterThanOrEqualTo(String value) {
addCriterion("mingcheng >=", value, "mingcheng");
return (Criteria) this;
}
public Criteria andMingchengLessThan(String value) {
addCriterion("mingcheng <", value, "mingcheng");
return (Criteria) this;
}
public Criteria andMingchengLessThanOrEqualTo(String value) {
addCriterion("mingcheng <=", value, "mingcheng");
return (Criteria) this;
}
public Criteria andMingchengLike(String value) {
addCriterion("mingcheng like", value, "mingcheng");
return (Criteria) this;
}
public Criteria andMingchengNotLike(String value) {
addCriterion("mingcheng not like", value, "mingcheng");
return (Criteria) this;
}
public Criteria andMingchengIn(List<String> values) {
addCriterion("mingcheng in", values, "mingcheng");
return (Criteria) this;
}
public Criteria andMingchengNotIn(List<String> values) {
addCriterion("mingcheng not in", values, "mingcheng");
return (Criteria) this;
}
public Criteria andMingchengBetween(String value1, String value2) {
addCriterion("mingcheng between", value1, value2, "mingcheng");
return (Criteria) this;
}
public Criteria andMingchengNotBetween(String value1, String value2) {
addCriterion("mingcheng not between", value1, value2, "mingcheng");
return (Criteria) this;
}
}
public static class Criteria extends GeneratedCriteria {
protected Criteria() {
super();
}
}
public static class Criterion {
private String condition;
private Object value;
private Object secondValue;
private boolean noValue;
private boolean singleValue;
private boolean betweenValue;
private boolean listValue;
private String typeHandler;
public String getCondition() {
return condition;
}
public Object getValue() {
return value;
}
public Object getSecondValue() {
return secondValue;
}
public boolean isNoValue() {
return noValue;
}
public boolean isSingleValue() {
return singleValue;
}
public boolean isBetweenValue() {
return betweenValue;
}
public boolean isListValue() {
return listValue;
}
public String getTypeHandler() {
return typeHandler;
}
protected Criterion(String condition) {
super();
this.condition = condition;
this.typeHandler = null;
this.noValue = true;
}
protected Criterion(String condition, Object value, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.typeHandler = typeHandler;
if (value instanceof List<?>) {
this.listValue = true;
} else {
this.singleValue = true;
}
}
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.secondValue = secondValue;
this.typeHandler = typeHandler;
this.betweenValue = true;
}
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}
}
}

@ -1,262 +0,0 @@
package com.entity;
/**
* @ClassName Shangpin
* @Description
*/
public class Shangpin {
//id列
private Integer id;
//名称
private String mingcheng;
//编号
private String bianhao;
//分类id
private Integer pinleiid;
//内容介绍
private String neirong;
//图片
private String image;
//原价
private Integer yuanshijiage;
//现价
private Integer jiage;
//单位
private String danwei;
//是否特价
private String shenhe;
//库存数量
private Integer kucunshuliang;
//销售数量
private Integer xiaoshoushuliang;
//父表分类表pinlei
private Pinlei pinlei;
/**
* id
*
* @return id id
*/
public Integer getId() {
return this.id;
}
/**
* id
*
* @param id id
*/
public void setId(Integer id) {
this.id = id;
}
/**
*
*
* @return mingcheng
*/
public String getMingcheng() {
return this.mingcheng;
}
/**
*
*
* @param mingcheng
*/
public void setMingcheng(String mingcheng) {
this.mingcheng = mingcheng;
}
/**
*
*
* @return bianhao
*/
public String getBianhao() {
return this.bianhao;
}
/**
*
*
* @param bianhao
*/
public void setBianhao(String bianhao) {
this.bianhao = bianhao;
}
/**
* id
*
* @return pinleiid id
*/
public Integer getPinleiid() {
return this.pinleiid;
}
/**
* id
*
* @param pinleiid id
*/
public void setPinleiid(Integer pinleiid) {
this.pinleiid = pinleiid;
}
/**
*
*
* @return neirong
*/
public String getNeirong() {
return this.neirong;
}
/**
*
*
* @param neirong
*/
public void setNeirong(String neirong) {
this.neirong = neirong;
}
/**
*
*
* @return image
*/
public String getImage() {
return this.image;
}
/**
*
*
* @param image
*/
public void setImage(String image) {
this.image = image;
}
/**
*
*
* @return yuanshijiage
*/
public Integer getYuanshijiage() {
return this.yuanshijiage;
}
/**
*
*
* @param yuanshijiage
*/
public void setYuanshijiage(Integer yuanshijiage) {
this.yuanshijiage = yuanshijiage;
}
/**
*
*
* @return jiage
*/
public Integer getJiage() {
return this.jiage;
}
/**
*
*
* @param jiage
*/
public void setJiage(Integer jiage) {
this.jiage = jiage;
}
/**
*
*
* @return danwei
*/
public String getDanwei() {
return this.danwei;
}
/**
*
*
* @param danwei
*/
public void setDanwei(String danwei) {
this.danwei = danwei;
}
/**
*
*
* @return shenhe
*/
public String getShenhe() {
return this.shenhe;
}
/**
*
*
* @param shenhe
*/
public void setShenhe(String shenhe) {
this.shenhe = shenhe;
}
/**
*
*
* @return kucunshuliang
*/
public Integer getKucunshuliang() {
return this.kucunshuliang;
}
/**
*
*
* @param kucunshuliang
*/
public void setKucunshuliang(Integer kucunshuliang) {
this.kucunshuliang = kucunshuliang;
}
/**
*
*
* @return xiaoshoushuliang
*/
public Integer getXiaoshoushuliang() {
return this.xiaoshoushuliang;
}
/**
*
*
* @param xiaoshoushuliang
*/
public void setXiaoshoushuliang(Integer xiaoshoushuliang) {
this.xiaoshoushuliang = xiaoshoushuliang;
}
/**
* pinlei
*
* @return pinlei pinlei
*/
public Pinlei getPinlei() {
return this.pinlei;
}
/**
* pinlei
*
* @param pinlei pinlei
*/
public void setPinlei(Pinlei pinlei) {
this.pinlei = pinlei;
}
}

File diff suppressed because it is too large Load Diff

@ -1,186 +0,0 @@
package com.entity;
/**
* @ClassName Shenqing
* @Description
*/
public class Shenqing {
//id列
private Integer id;
//姓名
private String xingming;
//电话
private String dianhua;
//说明
private String neirong;
//时间
private String shijian;
//备注
private String beizhu;
//是否审核
private String shenhe;
//用户id
private Integer usersid;
//父表用户表users
private Users users;
/**
* id
*
* @return id id
*/
public Integer getId() {
return this.id;
}
/**
* id
*
* @param id id
*/
public void setId(Integer id) {
this.id = id;
}
/**
*
*
* @return xingming
*/
public String getXingming() {
return this.xingming;
}
/**
*
*
* @param xingming
*/
public void setXingming(String xingming) {
this.xingming = xingming;
}
/**
*
*
* @return dianhua
*/
public String getDianhua() {
return this.dianhua;
}
/**
*
*
* @param dianhua
*/
public void setDianhua(String dianhua) {
this.dianhua = dianhua;
}
/**
*
*
* @return neirong
*/
public String getNeirong() {
return this.neirong;
}
/**
*
*
* @param neirong
*/
public void setNeirong(String neirong) {
this.neirong = neirong;
}
/**
*
*
* @return shijian
*/
public String getShijian() {
return this.shijian;
}
/**
*
*
* @param shijian
*/
public void setShijian(String shijian) {
this.shijian = shijian;
}
/**
*
*
* @return beizhu
*/
public String getBeizhu() {
return this.beizhu;
}
/**
*
*
* @param beizhu
*/
public void setBeizhu(String beizhu) {
this.beizhu = beizhu;
}
/**
*
*
* @return shenhe
*/
public String getShenhe() {
return this.shenhe;
}
/**
*
*
* @param shenhe
*/
public void setShenhe(String shenhe) {
this.shenhe = shenhe;
}
/**
* id
*
* @return usersid id
*/
public Integer getUsersid() {
return this.usersid;
}
/**
* id
*
* @param usersid id
*/
public void setUsersid(Integer usersid) {
this.usersid = usersid;
}
/**
* users
*
* @return users users
*/
public Users getUsers() {
return this.users;
}
/**
* users
*
* @param users users
*/
public void setUsers(Users users) {
this.users = users;
}
}

@ -1,749 +0,0 @@
package com.entity;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName Shenqing
* @Description mybatis
*/
public class ShenqingExample {
protected String orderByClause;
protected boolean distinct;
protected List<Criteria> oredCriteria;
public ShenqingExample() {
oredCriteria = new ArrayList<Criteria>();
}
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
public String getOrderByClause() {
return orderByClause;
}
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
public boolean isDistinct() {
return distinct;
}
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
return criteria;
}
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
protected abstract static class GeneratedCriteria {
protected List<Criterion> criteria;
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
public boolean isValid() {
return criteria.size() > 0;
}
public List<Criterion> getAllCriteria() {
return criteria;
}
public List<Criterion> getCriteria() {
return criteria;
}
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
}
criteria.add(new Criterion(condition));
}
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value));
}
protected void addCriterion(String condition, Object value1, Object value2, String property) {
if (value1 == null || value2 == null) {
throw new RuntimeException("Between values for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value1, value2));
}
public Criteria andIdIsNull() {
addCriterion("id is null");
return (Criteria) this;
}
public Criteria andIdIsNotNull() {
addCriterion("id is not null");
return (Criteria) this;
}
public Criteria andIdEqualTo(Integer value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(Integer value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Integer value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Integer value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Integer value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Integer> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andXingmingIsNull() {
addCriterion("xingming is null");
return (Criteria) this;
}
public Criteria andXingmingIsNotNull() {
addCriterion("xingming is not null");
return (Criteria) this;
}
public Criteria andXingmingEqualTo(String value) {
addCriterion("xingming =", value, "xingming");
return (Criteria) this;
}
public Criteria andXingmingNotEqualTo(String value) {
addCriterion("xingming <>", value, "xingming");
return (Criteria) this;
}
public Criteria andXingmingGreaterThan(String value) {
addCriterion("xingming >", value, "xingming");
return (Criteria) this;
}
public Criteria andXingmingGreaterThanOrEqualTo(String value) {
addCriterion("xingming >=", value, "xingming");
return (Criteria) this;
}
public Criteria andXingmingLessThan(String value) {
addCriterion("xingming <", value, "xingming");
return (Criteria) this;
}
public Criteria andXingmingLessThanOrEqualTo(String value) {
addCriterion("xingming <=", value, "xingming");
return (Criteria) this;
}
public Criteria andXingmingLike(String value) {
addCriterion("xingming like", value, "xingming");
return (Criteria) this;
}
public Criteria andXingmingNotLike(String value) {
addCriterion("xingming not like", value, "xingming");
return (Criteria) this;
}
public Criteria andXingmingIn(List<String> values) {
addCriterion("xingming in", values, "xingming");
return (Criteria) this;
}
public Criteria andXingmingNotIn(List<String> values) {
addCriterion("xingming not in", values, "xingming");
return (Criteria) this;
}
public Criteria andXingmingBetween(String value1, String value2) {
addCriterion("xingming between", value1, value2, "xingming");
return (Criteria) this;
}
public Criteria andXingmingNotBetween(String value1, String value2) {
addCriterion("xingming not between", value1, value2, "xingming");
return (Criteria) this;
}
public Criteria andDianhuaIsNull() {
addCriterion("dianhua is null");
return (Criteria) this;
}
public Criteria andDianhuaIsNotNull() {
addCriterion("dianhua is not null");
return (Criteria) this;
}
public Criteria andDianhuaEqualTo(String value) {
addCriterion("dianhua =", value, "dianhua");
return (Criteria) this;
}
public Criteria andDianhuaNotEqualTo(String value) {
addCriterion("dianhua <>", value, "dianhua");
return (Criteria) this;
}
public Criteria andDianhuaGreaterThan(String value) {
addCriterion("dianhua >", value, "dianhua");
return (Criteria) this;
}
public Criteria andDianhuaGreaterThanOrEqualTo(String value) {
addCriterion("dianhua >=", value, "dianhua");
return (Criteria) this;
}
public Criteria andDianhuaLessThan(String value) {
addCriterion("dianhua <", value, "dianhua");
return (Criteria) this;
}
public Criteria andDianhuaLessThanOrEqualTo(String value) {
addCriterion("dianhua <=", value, "dianhua");
return (Criteria) this;
}
public Criteria andDianhuaLike(String value) {
addCriterion("dianhua like", value, "dianhua");
return (Criteria) this;
}
public Criteria andDianhuaNotLike(String value) {
addCriterion("dianhua not like", value, "dianhua");
return (Criteria) this;
}
public Criteria andDianhuaIn(List<String> values) {
addCriterion("dianhua in", values, "dianhua");
return (Criteria) this;
}
public Criteria andDianhuaNotIn(List<String> values) {
addCriterion("dianhua not in", values, "dianhua");
return (Criteria) this;
}
public Criteria andDianhuaBetween(String value1, String value2) {
addCriterion("dianhua between", value1, value2, "dianhua");
return (Criteria) this;
}
public Criteria andDianhuaNotBetween(String value1, String value2) {
addCriterion("dianhua not between", value1, value2, "dianhua");
return (Criteria) this;
}
public Criteria andNeirongIsNull() {
addCriterion("neirong is null");
return (Criteria) this;
}
public Criteria andNeirongIsNotNull() {
addCriterion("neirong is not null");
return (Criteria) this;
}
public Criteria andNeirongEqualTo(String value) {
addCriterion("neirong =", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongNotEqualTo(String value) {
addCriterion("neirong <>", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongGreaterThan(String value) {
addCriterion("neirong >", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongGreaterThanOrEqualTo(String value) {
addCriterion("neirong >=", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongLessThan(String value) {
addCriterion("neirong <", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongLessThanOrEqualTo(String value) {
addCriterion("neirong <=", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongLike(String value) {
addCriterion("neirong like", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongNotLike(String value) {
addCriterion("neirong not like", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongIn(List<String> values) {
addCriterion("neirong in", values, "neirong");
return (Criteria) this;
}
public Criteria andNeirongNotIn(List<String> values) {
addCriterion("neirong not in", values, "neirong");
return (Criteria) this;
}
public Criteria andNeirongBetween(String value1, String value2) {
addCriterion("neirong between", value1, value2, "neirong");
return (Criteria) this;
}
public Criteria andNeirongNotBetween(String value1, String value2) {
addCriterion("neirong not between", value1, value2, "neirong");
return (Criteria) this;
}
public Criteria andShijianIsNull() {
addCriterion("shijian is null");
return (Criteria) this;
}
public Criteria andShijianIsNotNull() {
addCriterion("shijian is not null");
return (Criteria) this;
}
public Criteria andShijianEqualTo(String value) {
addCriterion("shijian =", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianNotEqualTo(String value) {
addCriterion("shijian <>", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianGreaterThan(String value) {
addCriterion("shijian >", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianGreaterThanOrEqualTo(String value) {
addCriterion("shijian >=", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianLessThan(String value) {
addCriterion("shijian <", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianLessThanOrEqualTo(String value) {
addCriterion("shijian <=", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianLike(String value) {
addCriterion("shijian like", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianNotLike(String value) {
addCriterion("shijian not like", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianIn(List<String> values) {
addCriterion("shijian in", values, "shijian");
return (Criteria) this;
}
public Criteria andShijianNotIn(List<String> values) {
addCriterion("shijian not in", values, "shijian");
return (Criteria) this;
}
public Criteria andShijianBetween(String value1, String value2) {
addCriterion("shijian between", value1, value2, "shijian");
return (Criteria) this;
}
public Criteria andShijianNotBetween(String value1, String value2) {
addCriterion("shijian not between", value1, value2, "shijian");
return (Criteria) this;
}
public Criteria andBeizhuIsNull() {
addCriterion("beizhu is null");
return (Criteria) this;
}
public Criteria andBeizhuIsNotNull() {
addCriterion("beizhu is not null");
return (Criteria) this;
}
public Criteria andBeizhuEqualTo(String value) {
addCriterion("beizhu =", value, "beizhu");
return (Criteria) this;
}
public Criteria andBeizhuNotEqualTo(String value) {
addCriterion("beizhu <>", value, "beizhu");
return (Criteria) this;
}
public Criteria andBeizhuGreaterThan(String value) {
addCriterion("beizhu >", value, "beizhu");
return (Criteria) this;
}
public Criteria andBeizhuGreaterThanOrEqualTo(String value) {
addCriterion("beizhu >=", value, "beizhu");
return (Criteria) this;
}
public Criteria andBeizhuLessThan(String value) {
addCriterion("beizhu <", value, "beizhu");
return (Criteria) this;
}
public Criteria andBeizhuLessThanOrEqualTo(String value) {
addCriterion("beizhu <=", value, "beizhu");
return (Criteria) this;
}
public Criteria andBeizhuLike(String value) {
addCriterion("beizhu like", value, "beizhu");
return (Criteria) this;
}
public Criteria andBeizhuNotLike(String value) {
addCriterion("beizhu not like", value, "beizhu");
return (Criteria) this;
}
public Criteria andBeizhuIn(List<String> values) {
addCriterion("beizhu in", values, "beizhu");
return (Criteria) this;
}
public Criteria andBeizhuNotIn(List<String> values) {
addCriterion("beizhu not in", values, "beizhu");
return (Criteria) this;
}
public Criteria andBeizhuBetween(String value1, String value2) {
addCriterion("beizhu between", value1, value2, "beizhu");
return (Criteria) this;
}
public Criteria andBeizhuNotBetween(String value1, String value2) {
addCriterion("beizhu not between", value1, value2, "beizhu");
return (Criteria) this;
}
public Criteria andShenheIsNull() {
addCriterion("shenhe is null");
return (Criteria) this;
}
public Criteria andShenheIsNotNull() {
addCriterion("shenhe is not null");
return (Criteria) this;
}
public Criteria andShenheEqualTo(String value) {
addCriterion("shenhe =", value, "shenhe");
return (Criteria) this;
}
public Criteria andShenheNotEqualTo(String value) {
addCriterion("shenhe <>", value, "shenhe");
return (Criteria) this;
}
public Criteria andShenheGreaterThan(String value) {
addCriterion("shenhe >", value, "shenhe");
return (Criteria) this;
}
public Criteria andShenheGreaterThanOrEqualTo(String value) {
addCriterion("shenhe >=", value, "shenhe");
return (Criteria) this;
}
public Criteria andShenheLessThan(String value) {
addCriterion("shenhe <", value, "shenhe");
return (Criteria) this;
}
public Criteria andShenheLessThanOrEqualTo(String value) {
addCriterion("shenhe <=", value, "shenhe");
return (Criteria) this;
}
public Criteria andShenheLike(String value) {
addCriterion("shenhe like", value, "shenhe");
return (Criteria) this;
}
public Criteria andShenheNotLike(String value) {
addCriterion("shenhe not like", value, "shenhe");
return (Criteria) this;
}
public Criteria andShenheIn(List<String> values) {
addCriterion("shenhe in", values, "shenhe");
return (Criteria) this;
}
public Criteria andShenheNotIn(List<String> values) {
addCriterion("shenhe not in", values, "shenhe");
return (Criteria) this;
}
public Criteria andShenheBetween(String value1, String value2) {
addCriterion("shenhe between", value1, value2, "shenhe");
return (Criteria) this;
}
public Criteria andShenheNotBetween(String value1, String value2) {
addCriterion("shenhe not between", value1, value2, "shenhe");
return (Criteria) this;
}
public Criteria andUsersidIsNull() {
addCriterion("usersid is null");
return (Criteria) this;
}
public Criteria andUsersidIsNotNull() {
addCriterion("usersid is not null");
return (Criteria) this;
}
public Criteria andUsersidEqualTo(Integer value) {
addCriterion("usersid =", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidNotEqualTo(Integer value) {
addCriterion("usersid <>", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidGreaterThan(Integer value) {
addCriterion("usersid >", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidGreaterThanOrEqualTo(Integer value) {
addCriterion("usersid >=", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidLessThan(Integer value) {
addCriterion("usersid <", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidLessThanOrEqualTo(Integer value) {
addCriterion("usersid <=", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidLike(Integer value) {
addCriterion("usersid like", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidNotLike(Integer value) {
addCriterion("usersid not like", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidIn(List<Integer> values) {
addCriterion("usersid in", values, "usersid");
return (Criteria) this;
}
public Criteria andUsersidNotIn(List<Integer> values) {
addCriterion("usersid not in", values, "usersid");
return (Criteria) this;
}
public Criteria andUsersidBetween(Integer value1, Integer value2) {
addCriterion("usersid between", value1, value2, "usersid");
return (Criteria) this;
}
public Criteria andUsersidNotBetween(Integer value1, Integer value2) {
addCriterion("usersid not between", value1, value2, "usersid");
return (Criteria) this;
}
}
public static class Criteria extends GeneratedCriteria {
protected Criteria() {
super();
}
}
public static class Criterion {
private String condition;
private Object value;
private Object secondValue;
private boolean noValue;
private boolean singleValue;
private boolean betweenValue;
private boolean listValue;
private String typeHandler;
public String getCondition() {
return condition;
}
public Object getValue() {
return value;
}
public Object getSecondValue() {
return secondValue;
}
public boolean isNoValue() {
return noValue;
}
public boolean isSingleValue() {
return singleValue;
}
public boolean isBetweenValue() {
return betweenValue;
}
public boolean isListValue() {
return listValue;
}
public String getTypeHandler() {
return typeHandler;
}
protected Criterion(String condition) {
super();
this.condition = condition;
this.typeHandler = null;
this.noValue = true;
}
protected Criterion(String condition, Object value, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.typeHandler = typeHandler;
if (value instanceof List<?>) {
this.listValue = true;
} else {
this.singleValue = true;
}
}
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.secondValue = secondValue;
this.typeHandler = typeHandler;
this.betweenValue = true;
}
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}
}
}

@ -1,129 +0,0 @@
package com.entity;
/**
* @ClassName Shoucang
* @Description
*/
public class Shoucang {
//id列
private Integer id;
//时间
private String shijian;
//零食id
private Integer shangpinid;
//用户id
private Integer usersid;
//父表零食表shangpin
private Shangpin shangpin;
//父表用户表users
private Users users;
/**
* id
*
* @return id id
*/
public Integer getId() {
return this.id;
}
/**
* id
*
* @param id id
*/
public void setId(Integer id) {
this.id = id;
}
/**
*
*
* @return shijian
*/
public String getShijian() {
return this.shijian;
}
/**
*
*
* @param shijian
*/
public void setShijian(String shijian) {
this.shijian = shijian;
}
/**
* id
*
* @return shangpinid id
*/
public Integer getShangpinid() {
return this.shangpinid;
}
/**
* id
*
* @param shangpinid id
*/
public void setShangpinid(Integer shangpinid) {
this.shangpinid = shangpinid;
}
/**
* id
*
* @return usersid id
*/
public Integer getUsersid() {
return this.usersid;
}
/**
* id
*
* @param usersid id
*/
public void setUsersid(Integer usersid) {
this.usersid = usersid;
}
/**
* shangpin
*
* @return shangpin shangpin
*/
public Shangpin getShangpin() {
return this.shangpin;
}
/**
* shangpin
*
* @param shangpin shangpin
*/
public void setShangpin(Shangpin shangpin) {
this.shangpin = shangpin;
}
/**
* users
*
* @return users users
*/
public Users getUsers() {
return this.users;
}
/**
* users
*
* @param users users
*/
public void setUsers(Users users) {
this.users = users;
}
}

@ -1,473 +0,0 @@
package com.entity;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName Shoucang
* @Description mybatis
*/
public class ShoucangExample {
protected String orderByClause;
protected boolean distinct;
protected List<Criteria> oredCriteria;
public ShoucangExample() {
oredCriteria = new ArrayList<Criteria>();
}
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
public String getOrderByClause() {
return orderByClause;
}
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
public boolean isDistinct() {
return distinct;
}
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
return criteria;
}
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
protected abstract static class GeneratedCriteria {
protected List<Criterion> criteria;
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
public boolean isValid() {
return criteria.size() > 0;
}
public List<Criterion> getAllCriteria() {
return criteria;
}
public List<Criterion> getCriteria() {
return criteria;
}
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
}
criteria.add(new Criterion(condition));
}
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value));
}
protected void addCriterion(String condition, Object value1, Object value2, String property) {
if (value1 == null || value2 == null) {
throw new RuntimeException("Between values for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value1, value2));
}
public Criteria andIdIsNull() {
addCriterion("id is null");
return (Criteria) this;
}
public Criteria andIdIsNotNull() {
addCriterion("id is not null");
return (Criteria) this;
}
public Criteria andIdEqualTo(Integer value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(Integer value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Integer value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Integer value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Integer value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Integer> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andShijianIsNull() {
addCriterion("shijian is null");
return (Criteria) this;
}
public Criteria andShijianIsNotNull() {
addCriterion("shijian is not null");
return (Criteria) this;
}
public Criteria andShijianEqualTo(String value) {
addCriterion("shijian =", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianNotEqualTo(String value) {
addCriterion("shijian <>", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianGreaterThan(String value) {
addCriterion("shijian >", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianGreaterThanOrEqualTo(String value) {
addCriterion("shijian >=", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianLessThan(String value) {
addCriterion("shijian <", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianLessThanOrEqualTo(String value) {
addCriterion("shijian <=", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianLike(String value) {
addCriterion("shijian like", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianNotLike(String value) {
addCriterion("shijian not like", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianIn(List<String> values) {
addCriterion("shijian in", values, "shijian");
return (Criteria) this;
}
public Criteria andShijianNotIn(List<String> values) {
addCriterion("shijian not in", values, "shijian");
return (Criteria) this;
}
public Criteria andShijianBetween(String value1, String value2) {
addCriterion("shijian between", value1, value2, "shijian");
return (Criteria) this;
}
public Criteria andShijianNotBetween(String value1, String value2) {
addCriterion("shijian not between", value1, value2, "shijian");
return (Criteria) this;
}
public Criteria andShangpinidIsNull() {
addCriterion("shangpinid is null");
return (Criteria) this;
}
public Criteria andShangpinidIsNotNull() {
addCriterion("shangpinid is not null");
return (Criteria) this;
}
public Criteria andShangpinidEqualTo(Integer value) {
addCriterion("shangpinid =", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidNotEqualTo(Integer value) {
addCriterion("shangpinid <>", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidGreaterThan(Integer value) {
addCriterion("shangpinid >", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidGreaterThanOrEqualTo(Integer value) {
addCriterion("shangpinid >=", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidLessThan(Integer value) {
addCriterion("shangpinid <", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidLessThanOrEqualTo(Integer value) {
addCriterion("shangpinid <=", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidLike(Integer value) {
addCriterion("shangpinid like", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidNotLike(Integer value) {
addCriterion("shangpinid not like", value, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidIn(List<Integer> values) {
addCriterion("shangpinid in", values, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidNotIn(List<Integer> values) {
addCriterion("shangpinid not in", values, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidBetween(Integer value1, Integer value2) {
addCriterion("shangpinid between", value1, value2, "shangpinid");
return (Criteria) this;
}
public Criteria andShangpinidNotBetween(Integer value1, Integer value2) {
addCriterion("shangpinid not between", value1, value2, "shangpinid");
return (Criteria) this;
}
public Criteria andUsersidIsNull() {
addCriterion("usersid is null");
return (Criteria) this;
}
public Criteria andUsersidIsNotNull() {
addCriterion("usersid is not null");
return (Criteria) this;
}
public Criteria andUsersidEqualTo(Integer value) {
addCriterion("usersid =", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidNotEqualTo(Integer value) {
addCriterion("usersid <>", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidGreaterThan(Integer value) {
addCriterion("usersid >", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidGreaterThanOrEqualTo(Integer value) {
addCriterion("usersid >=", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidLessThan(Integer value) {
addCriterion("usersid <", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidLessThanOrEqualTo(Integer value) {
addCriterion("usersid <=", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidLike(Integer value) {
addCriterion("usersid like", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidNotLike(Integer value) {
addCriterion("usersid not like", value, "usersid");
return (Criteria) this;
}
public Criteria andUsersidIn(List<Integer> values) {
addCriterion("usersid in", values, "usersid");
return (Criteria) this;
}
public Criteria andUsersidNotIn(List<Integer> values) {
addCriterion("usersid not in", values, "usersid");
return (Criteria) this;
}
public Criteria andUsersidBetween(Integer value1, Integer value2) {
addCriterion("usersid between", value1, value2, "usersid");
return (Criteria) this;
}
public Criteria andUsersidNotBetween(Integer value1, Integer value2) {
addCriterion("usersid not between", value1, value2, "usersid");
return (Criteria) this;
}
}
public static class Criteria extends GeneratedCriteria {
protected Criteria() {
super();
}
}
public static class Criterion {
private String condition;
private Object value;
private Object secondValue;
private boolean noValue;
private boolean singleValue;
private boolean betweenValue;
private boolean listValue;
private String typeHandler;
public String getCondition() {
return condition;
}
public Object getValue() {
return value;
}
public Object getSecondValue() {
return secondValue;
}
public boolean isNoValue() {
return noValue;
}
public boolean isSingleValue() {
return singleValue;
}
public boolean isBetweenValue() {
return betweenValue;
}
public boolean isListValue() {
return listValue;
}
public String getTypeHandler() {
return typeHandler;
}
protected Criterion(String condition) {
super();
this.condition = condition;
this.typeHandler = null;
this.noValue = true;
}
protected Criterion(String condition, Object value, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.typeHandler = typeHandler;
if (value instanceof List<?>) {
this.listValue = true;
} else {
this.singleValue = true;
}
}
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.secondValue = secondValue;
this.typeHandler = typeHandler;
this.betweenValue = true;
}
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}
}
}

@ -1,224 +0,0 @@
package com.entity;
/**
* @ClassName Users
* @Description
*/
public class Users {
//id列
private Integer id;
//用户名称
private String loginname;
//密码
private String loginpw;
//类型
private String type;
//类型名称
private String typename;
//姓名
private String xingming;
//性别
private String xingbie;
//年龄
private String nianling;
//地址
private String address;
//电话
private String dianhua;
//审核
private String shenhe;
/**
* id
*
* @return id id
*/
public Integer getId() {
return this.id;
}
/**
* id
*
* @param id id
*/
public void setId(Integer id) {
this.id = id;
}
/**
*
*
* @return loginname
*/
public String getLoginname() {
return this.loginname;
}
/**
*
*
* @param loginname
*/
public void setLoginname(String loginname) {
this.loginname = loginname;
}
/**
*
*
* @return loginpw
*/
public String getLoginpw() {
return this.loginpw;
}
/**
*
*
* @param loginpw
*/
public void setLoginpw(String loginpw) {
this.loginpw = loginpw;
}
/**
*
*
* @return type
*/
public String getType() {
return this.type;
}
/**
*
*
* @param type
*/
public void setType(String type) {
this.type = type;
}
/**
*
*
* @return typename
*/
public String getTypename() {
return this.typename;
}
/**
*
*
* @param typename
*/
public void setTypename(String typename) {
this.typename = typename;
}
/**
*
*
* @return xingming
*/
public String getXingming() {
return this.xingming;
}
/**
*
*
* @param xingming
*/
public void setXingming(String xingming) {
this.xingming = xingming;
}
/**
*
*
* @return xingbie
*/
public String getXingbie() {
return this.xingbie;
}
/**
*
*
* @param xingbie
*/
public void setXingbie(String xingbie) {
this.xingbie = xingbie;
}
/**
*
*
* @return nianling
*/
public String getNianling() {
return this.nianling;
}
/**
*
*
* @param nianling
*/
public void setNianling(String nianling) {
this.nianling = nianling;
}
/**
*
*
* @return address
*/
public String getAddress() {
return this.address;
}
/**
*
*
* @param address
*/
public void setAddress(String address) {
this.address = address;
}
/**
*
*
* @return dianhua
*/
public String getDianhua() {
return this.dianhua;
}
/**
*
*
* @param dianhua
*/
public void setDianhua(String dianhua) {
this.dianhua = dianhua;
}
/**
*
*
* @return shenhe
*/
public String getShenhe() {
return this.shenhe;
}
/**
*
*
* @param shenhe
*/
public void setShenhe(String shenhe) {
this.shenhe = shenhe;
}
}

@ -1,956 +0,0 @@
package com.entity;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName Users
* @Description mybatis
*/
public class UsersExample {
protected String orderByClause;
protected boolean distinct;
protected List<Criteria> oredCriteria;
public UsersExample() {
oredCriteria = new ArrayList<Criteria>();
}
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
public String getOrderByClause() {
return orderByClause;
}
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
public boolean isDistinct() {
return distinct;
}
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
return criteria;
}
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
protected abstract static class GeneratedCriteria {
protected List<Criterion> criteria;
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
public boolean isValid() {
return criteria.size() > 0;
}
public List<Criterion> getAllCriteria() {
return criteria;
}
public List<Criterion> getCriteria() {
return criteria;
}
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
}
criteria.add(new Criterion(condition));
}
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value));
}
protected void addCriterion(String condition, Object value1, Object value2, String property) {
if (value1 == null || value2 == null) {
throw new RuntimeException("Between values for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value1, value2));
}
public Criteria andIdIsNull() {
addCriterion("id is null");
return (Criteria) this;
}
public Criteria andIdIsNotNull() {
addCriterion("id is not null");
return (Criteria) this;
}
public Criteria andIdEqualTo(Integer value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(Integer value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Integer value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Integer value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Integer value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Integer> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andLoginnameIsNull() {
addCriterion("loginname is null");
return (Criteria) this;
}
public Criteria andLoginnameIsNotNull() {
addCriterion("loginname is not null");
return (Criteria) this;
}
public Criteria andLoginnameEqualTo(String value) {
addCriterion("loginname =", value, "loginname");
return (Criteria) this;
}
public Criteria andLoginnameNotEqualTo(String value) {
addCriterion("loginname <>", value, "loginname");
return (Criteria) this;
}
public Criteria andLoginnameGreaterThan(String value) {
addCriterion("loginname >", value, "loginname");
return (Criteria) this;
}
public Criteria andLoginnameGreaterThanOrEqualTo(String value) {
addCriterion("loginname >=", value, "loginname");
return (Criteria) this;
}
public Criteria andLoginnameLessThan(String value) {
addCriterion("loginname <", value, "loginname");
return (Criteria) this;
}
public Criteria andLoginnameLessThanOrEqualTo(String value) {
addCriterion("loginname <=", value, "loginname");
return (Criteria) this;
}
public Criteria andLoginnameLike(String value) {
addCriterion("loginname like", value, "loginname");
return (Criteria) this;
}
public Criteria andLoginnameNotLike(String value) {
addCriterion("loginname not like", value, "loginname");
return (Criteria) this;
}
public Criteria andLoginnameIn(List<String> values) {
addCriterion("loginname in", values, "loginname");
return (Criteria) this;
}
public Criteria andLoginnameNotIn(List<String> values) {
addCriterion("loginname not in", values, "loginname");
return (Criteria) this;
}
public Criteria andLoginnameBetween(String value1, String value2) {
addCriterion("loginname between", value1, value2, "loginname");
return (Criteria) this;
}
public Criteria andLoginnameNotBetween(String value1, String value2) {
addCriterion("loginname not between", value1, value2, "loginname");
return (Criteria) this;
}
public Criteria andLoginpwIsNull() {
addCriterion("loginpw is null");
return (Criteria) this;
}
public Criteria andLoginpwIsNotNull() {
addCriterion("loginpw is not null");
return (Criteria) this;
}
public Criteria andLoginpwEqualTo(String value) {
addCriterion("loginpw =", value, "loginpw");
return (Criteria) this;
}
public Criteria andLoginpwNotEqualTo(String value) {
addCriterion("loginpw <>", value, "loginpw");
return (Criteria) this;
}
public Criteria andLoginpwGreaterThan(String value) {
addCriterion("loginpw >", value, "loginpw");
return (Criteria) this;
}
public Criteria andLoginpwGreaterThanOrEqualTo(String value) {
addCriterion("loginpw >=", value, "loginpw");
return (Criteria) this;
}
public Criteria andLoginpwLessThan(String value) {
addCriterion("loginpw <", value, "loginpw");
return (Criteria) this;
}
public Criteria andLoginpwLessThanOrEqualTo(String value) {
addCriterion("loginpw <=", value, "loginpw");
return (Criteria) this;
}
public Criteria andLoginpwLike(String value) {
addCriterion("loginpw like", value, "loginpw");
return (Criteria) this;
}
public Criteria andLoginpwNotLike(String value) {
addCriterion("loginpw not like", value, "loginpw");
return (Criteria) this;
}
public Criteria andLoginpwIn(List<String> values) {
addCriterion("loginpw in", values, "loginpw");
return (Criteria) this;
}
public Criteria andLoginpwNotIn(List<String> values) {
addCriterion("loginpw not in", values, "loginpw");
return (Criteria) this;
}
public Criteria andLoginpwBetween(String value1, String value2) {
addCriterion("loginpw between", value1, value2, "loginpw");
return (Criteria) this;
}
public Criteria andLoginpwNotBetween(String value1, String value2) {
addCriterion("loginpw not between", value1, value2, "loginpw");
return (Criteria) this;
}
public Criteria andTypeIsNull() {
addCriterion("type is null");
return (Criteria) this;
}
public Criteria andTypeIsNotNull() {
addCriterion("type is not null");
return (Criteria) this;
}
public Criteria andTypeEqualTo(String value) {
addCriterion("type =", value, "type");
return (Criteria) this;
}
public Criteria andTypeNotEqualTo(String value) {
addCriterion("type <>", value, "type");
return (Criteria) this;
}
public Criteria andTypeGreaterThan(String value) {
addCriterion("type >", value, "type");
return (Criteria) this;
}
public Criteria andTypeGreaterThanOrEqualTo(String value) {
addCriterion("type >=", value, "type");
return (Criteria) this;
}
public Criteria andTypeLessThan(String value) {
addCriterion("type <", value, "type");
return (Criteria) this;
}
public Criteria andTypeLessThanOrEqualTo(String value) {
addCriterion("type <=", value, "type");
return (Criteria) this;
}
public Criteria andTypeLike(String value) {
addCriterion("type like", value, "type");
return (Criteria) this;
}
public Criteria andTypeNotLike(String value) {
addCriterion("type not like", value, "type");
return (Criteria) this;
}
public Criteria andTypeIn(List<String> values) {
addCriterion("type in", values, "type");
return (Criteria) this;
}
public Criteria andTypeNotIn(List<String> values) {
addCriterion("type not in", values, "type");
return (Criteria) this;
}
public Criteria andTypeBetween(String value1, String value2) {
addCriterion("type between", value1, value2, "type");
return (Criteria) this;
}
public Criteria andTypeNotBetween(String value1, String value2) {
addCriterion("type not between", value1, value2, "type");
return (Criteria) this;
}
public Criteria andTypenameIsNull() {
addCriterion("typename is null");
return (Criteria) this;
}
public Criteria andTypenameIsNotNull() {
addCriterion("typename is not null");
return (Criteria) this;
}
public Criteria andTypenameEqualTo(String value) {
addCriterion("typename =", value, "typename");
return (Criteria) this;
}
public Criteria andTypenameNotEqualTo(String value) {
addCriterion("typename <>", value, "typename");
return (Criteria) this;
}
public Criteria andTypenameGreaterThan(String value) {
addCriterion("typename >", value, "typename");
return (Criteria) this;
}
public Criteria andTypenameGreaterThanOrEqualTo(String value) {
addCriterion("typename >=", value, "typename");
return (Criteria) this;
}
public Criteria andTypenameLessThan(String value) {
addCriterion("typename <", value, "typename");
return (Criteria) this;
}
public Criteria andTypenameLessThanOrEqualTo(String value) {
addCriterion("typename <=", value, "typename");
return (Criteria) this;
}
public Criteria andTypenameLike(String value) {
addCriterion("typename like", value, "typename");
return (Criteria) this;
}
public Criteria andTypenameNotLike(String value) {
addCriterion("typename not like", value, "typename");
return (Criteria) this;
}
public Criteria andTypenameIn(List<String> values) {
addCriterion("typename in", values, "typename");
return (Criteria) this;
}
public Criteria andTypenameNotIn(List<String> values) {
addCriterion("typename not in", values, "typename");
return (Criteria) this;
}
public Criteria andTypenameBetween(String value1, String value2) {
addCriterion("typename between", value1, value2, "typename");
return (Criteria) this;
}
public Criteria andTypenameNotBetween(String value1, String value2) {
addCriterion("typename not between", value1, value2, "typename");
return (Criteria) this;
}
public Criteria andXingmingIsNull() {
addCriterion("xingming is null");
return (Criteria) this;
}
public Criteria andXingmingIsNotNull() {
addCriterion("xingming is not null");
return (Criteria) this;
}
public Criteria andXingmingEqualTo(String value) {
addCriterion("xingming =", value, "xingming");
return (Criteria) this;
}
public Criteria andXingmingNotEqualTo(String value) {
addCriterion("xingming <>", value, "xingming");
return (Criteria) this;
}
public Criteria andXingmingGreaterThan(String value) {
addCriterion("xingming >", value, "xingming");
return (Criteria) this;
}
public Criteria andXingmingGreaterThanOrEqualTo(String value) {
addCriterion("xingming >=", value, "xingming");
return (Criteria) this;
}
public Criteria andXingmingLessThan(String value) {
addCriterion("xingming <", value, "xingming");
return (Criteria) this;
}
public Criteria andXingmingLessThanOrEqualTo(String value) {
addCriterion("xingming <=", value, "xingming");
return (Criteria) this;
}
public Criteria andXingmingLike(String value) {
addCriterion("xingming like", value, "xingming");
return (Criteria) this;
}
public Criteria andXingmingNotLike(String value) {
addCriterion("xingming not like", value, "xingming");
return (Criteria) this;
}
public Criteria andXingmingIn(List<String> values) {
addCriterion("xingming in", values, "xingming");
return (Criteria) this;
}
public Criteria andXingmingNotIn(List<String> values) {
addCriterion("xingming not in", values, "xingming");
return (Criteria) this;
}
public Criteria andXingmingBetween(String value1, String value2) {
addCriterion("xingming between", value1, value2, "xingming");
return (Criteria) this;
}
public Criteria andXingmingNotBetween(String value1, String value2) {
addCriterion("xingming not between", value1, value2, "xingming");
return (Criteria) this;
}
public Criteria andXingbieIsNull() {
addCriterion("xingbie is null");
return (Criteria) this;
}
public Criteria andXingbieIsNotNull() {
addCriterion("xingbie is not null");
return (Criteria) this;
}
public Criteria andXingbieEqualTo(String value) {
addCriterion("xingbie =", value, "xingbie");
return (Criteria) this;
}
public Criteria andXingbieNotEqualTo(String value) {
addCriterion("xingbie <>", value, "xingbie");
return (Criteria) this;
}
public Criteria andXingbieGreaterThan(String value) {
addCriterion("xingbie >", value, "xingbie");
return (Criteria) this;
}
public Criteria andXingbieGreaterThanOrEqualTo(String value) {
addCriterion("xingbie >=", value, "xingbie");
return (Criteria) this;
}
public Criteria andXingbieLessThan(String value) {
addCriterion("xingbie <", value, "xingbie");
return (Criteria) this;
}
public Criteria andXingbieLessThanOrEqualTo(String value) {
addCriterion("xingbie <=", value, "xingbie");
return (Criteria) this;
}
public Criteria andXingbieLike(String value) {
addCriterion("xingbie like", value, "xingbie");
return (Criteria) this;
}
public Criteria andXingbieNotLike(String value) {
addCriterion("xingbie not like", value, "xingbie");
return (Criteria) this;
}
public Criteria andXingbieIn(List<String> values) {
addCriterion("xingbie in", values, "xingbie");
return (Criteria) this;
}
public Criteria andXingbieNotIn(List<String> values) {
addCriterion("xingbie not in", values, "xingbie");
return (Criteria) this;
}
public Criteria andXingbieBetween(String value1, String value2) {
addCriterion("xingbie between", value1, value2, "xingbie");
return (Criteria) this;
}
public Criteria andXingbieNotBetween(String value1, String value2) {
addCriterion("xingbie not between", value1, value2, "xingbie");
return (Criteria) this;
}
public Criteria andNianlingIsNull() {
addCriterion("nianling is null");
return (Criteria) this;
}
public Criteria andNianlingIsNotNull() {
addCriterion("nianling is not null");
return (Criteria) this;
}
public Criteria andNianlingEqualTo(String value) {
addCriterion("nianling =", value, "nianling");
return (Criteria) this;
}
public Criteria andNianlingNotEqualTo(String value) {
addCriterion("nianling <>", value, "nianling");
return (Criteria) this;
}
public Criteria andNianlingGreaterThan(String value) {
addCriterion("nianling >", value, "nianling");
return (Criteria) this;
}
public Criteria andNianlingGreaterThanOrEqualTo(String value) {
addCriterion("nianling >=", value, "nianling");
return (Criteria) this;
}
public Criteria andNianlingLessThan(String value) {
addCriterion("nianling <", value, "nianling");
return (Criteria) this;
}
public Criteria andNianlingLessThanOrEqualTo(String value) {
addCriterion("nianling <=", value, "nianling");
return (Criteria) this;
}
public Criteria andNianlingLike(String value) {
addCriterion("nianling like", value, "nianling");
return (Criteria) this;
}
public Criteria andNianlingNotLike(String value) {
addCriterion("nianling not like", value, "nianling");
return (Criteria) this;
}
public Criteria andNianlingIn(List<String> values) {
addCriterion("nianling in", values, "nianling");
return (Criteria) this;
}
public Criteria andNianlingNotIn(List<String> values) {
addCriterion("nianling not in", values, "nianling");
return (Criteria) this;
}
public Criteria andNianlingBetween(String value1, String value2) {
addCriterion("nianling between", value1, value2, "nianling");
return (Criteria) this;
}
public Criteria andNianlingNotBetween(String value1, String value2) {
addCriterion("nianling not between", value1, value2, "nianling");
return (Criteria) this;
}
public Criteria andAddressIsNull() {
addCriterion("address is null");
return (Criteria) this;
}
public Criteria andAddressIsNotNull() {
addCriterion("address is not null");
return (Criteria) this;
}
public Criteria andAddressEqualTo(String value) {
addCriterion("address =", value, "address");
return (Criteria) this;
}
public Criteria andAddressNotEqualTo(String value) {
addCriterion("address <>", value, "address");
return (Criteria) this;
}
public Criteria andAddressGreaterThan(String value) {
addCriterion("address >", value, "address");
return (Criteria) this;
}
public Criteria andAddressGreaterThanOrEqualTo(String value) {
addCriterion("address >=", value, "address");
return (Criteria) this;
}
public Criteria andAddressLessThan(String value) {
addCriterion("address <", value, "address");
return (Criteria) this;
}
public Criteria andAddressLessThanOrEqualTo(String value) {
addCriterion("address <=", value, "address");
return (Criteria) this;
}
public Criteria andAddressLike(String value) {
addCriterion("address like", value, "address");
return (Criteria) this;
}
public Criteria andAddressNotLike(String value) {
addCriterion("address not like", value, "address");
return (Criteria) this;
}
public Criteria andAddressIn(List<String> values) {
addCriterion("address in", values, "address");
return (Criteria) this;
}
public Criteria andAddressNotIn(List<String> values) {
addCriterion("address not in", values, "address");
return (Criteria) this;
}
public Criteria andAddressBetween(String value1, String value2) {
addCriterion("address between", value1, value2, "address");
return (Criteria) this;
}
public Criteria andAddressNotBetween(String value1, String value2) {
addCriterion("address not between", value1, value2, "address");
return (Criteria) this;
}
public Criteria andDianhuaIsNull() {
addCriterion("dianhua is null");
return (Criteria) this;
}
public Criteria andDianhuaIsNotNull() {
addCriterion("dianhua is not null");
return (Criteria) this;
}
public Criteria andDianhuaEqualTo(String value) {
addCriterion("dianhua =", value, "dianhua");
return (Criteria) this;
}
public Criteria andDianhuaNotEqualTo(String value) {
addCriterion("dianhua <>", value, "dianhua");
return (Criteria) this;
}
public Criteria andDianhuaGreaterThan(String value) {
addCriterion("dianhua >", value, "dianhua");
return (Criteria) this;
}
public Criteria andDianhuaGreaterThanOrEqualTo(String value) {
addCriterion("dianhua >=", value, "dianhua");
return (Criteria) this;
}
public Criteria andDianhuaLessThan(String value) {
addCriterion("dianhua <", value, "dianhua");
return (Criteria) this;
}
public Criteria andDianhuaLessThanOrEqualTo(String value) {
addCriterion("dianhua <=", value, "dianhua");
return (Criteria) this;
}
public Criteria andDianhuaLike(String value) {
addCriterion("dianhua like", value, "dianhua");
return (Criteria) this;
}
public Criteria andDianhuaNotLike(String value) {
addCriterion("dianhua not like", value, "dianhua");
return (Criteria) this;
}
public Criteria andDianhuaIn(List<String> values) {
addCriterion("dianhua in", values, "dianhua");
return (Criteria) this;
}
public Criteria andDianhuaNotIn(List<String> values) {
addCriterion("dianhua not in", values, "dianhua");
return (Criteria) this;
}
public Criteria andDianhuaBetween(String value1, String value2) {
addCriterion("dianhua between", value1, value2, "dianhua");
return (Criteria) this;
}
public Criteria andDianhuaNotBetween(String value1, String value2) {
addCriterion("dianhua not between", value1, value2, "dianhua");
return (Criteria) this;
}
public Criteria andShenheIsNull() {
addCriterion("shenhe is null");
return (Criteria) this;
}
public Criteria andShenheIsNotNull() {
addCriterion("shenhe is not null");
return (Criteria) this;
}
public Criteria andShenheEqualTo(String value) {
addCriterion("shenhe =", value, "shenhe");
return (Criteria) this;
}
public Criteria andShenheNotEqualTo(String value) {
addCriterion("shenhe <>", value, "shenhe");
return (Criteria) this;
}
public Criteria andShenheGreaterThan(String value) {
addCriterion("shenhe >", value, "shenhe");
return (Criteria) this;
}
public Criteria andShenheGreaterThanOrEqualTo(String value) {
addCriterion("shenhe >=", value, "shenhe");
return (Criteria) this;
}
public Criteria andShenheLessThan(String value) {
addCriterion("shenhe <", value, "shenhe");
return (Criteria) this;
}
public Criteria andShenheLessThanOrEqualTo(String value) {
addCriterion("shenhe <=", value, "shenhe");
return (Criteria) this;
}
public Criteria andShenheLike(String value) {
addCriterion("shenhe like", value, "shenhe");
return (Criteria) this;
}
public Criteria andShenheNotLike(String value) {
addCriterion("shenhe not like", value, "shenhe");
return (Criteria) this;
}
public Criteria andShenheIn(List<String> values) {
addCriterion("shenhe in", values, "shenhe");
return (Criteria) this;
}
public Criteria andShenheNotIn(List<String> values) {
addCriterion("shenhe not in", values, "shenhe");
return (Criteria) this;
}
public Criteria andShenheBetween(String value1, String value2) {
addCriterion("shenhe between", value1, value2, "shenhe");
return (Criteria) this;
}
public Criteria andShenheNotBetween(String value1, String value2) {
addCriterion("shenhe not between", value1, value2, "shenhe");
return (Criteria) this;
}
}
public static class Criteria extends GeneratedCriteria {
protected Criteria() {
super();
}
}
public static class Criterion {
private String condition;
private Object value;
private Object secondValue;
private boolean noValue;
private boolean singleValue;
private boolean betweenValue;
private boolean listValue;
private String typeHandler;
public String getCondition() {
return condition;
}
public Object getValue() {
return value;
}
public Object getSecondValue() {
return secondValue;
}
public boolean isNoValue() {
return noValue;
}
public boolean isSingleValue() {
return singleValue;
}
public boolean isBetweenValue() {
return betweenValue;
}
public boolean isListValue() {
return listValue;
}
public String getTypeHandler() {
return typeHandler;
}
protected Criterion(String condition) {
super();
this.condition = condition;
this.typeHandler = null;
this.noValue = true;
}
protected Criterion(String condition, Object value, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.typeHandler = typeHandler;
if (value instanceof List<?>) {
this.listValue = true;
} else {
this.singleValue = true;
}
}
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.secondValue = secondValue;
this.typeHandler = typeHandler;
this.betweenValue = true;
}
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}
}
}

@ -1,110 +0,0 @@
package com.entity;
/**
* @ClassName Xinwen
* @Description
*/
public class Xinwen {
//id列
private Integer id;
//标题
private String biaoti;
//内容
private String neirong;
//图片
private String tupian;
//时间
private String shijian;
/**
* id
*
* @return id id
*/
public Integer getId() {
return this.id;
}
/**
* id
*
* @param id id
*/
public void setId(Integer id) {
this.id = id;
}
/**
*
*
* @return biaoti
*/
public String getBiaoti() {
return this.biaoti;
}
/**
*
*
* @param biaoti
*/
public void setBiaoti(String biaoti) {
this.biaoti = biaoti;
}
/**
*
*
* @return neirong
*/
public String getNeirong() {
return this.neirong;
}
/**
*
*
* @param neirong
*/
public void setNeirong(String neirong) {
this.neirong = neirong;
}
/**
*
*
* @return tupian
*/
public String getTupian() {
return this.tupian;
}
/**
*
*
* @param tupian
*/
public void setTupian(String tupian) {
this.tupian = tupian;
}
/**
*
*
* @return shijian
*/
public String getShijian() {
return this.shijian;
}
/**
*
*
* @param shijian
*/
public void setShijian(String shijian) {
this.shijian = shijian;
}
}

@ -1,542 +0,0 @@
package com.entity;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName Xinwen
* @Description mybatis
*/
public class XinwenExample {
protected String orderByClause;
protected boolean distinct;
protected List<Criteria> oredCriteria;
public XinwenExample() {
oredCriteria = new ArrayList<Criteria>();
}
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
public String getOrderByClause() {
return orderByClause;
}
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
public boolean isDistinct() {
return distinct;
}
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
return criteria;
}
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
protected abstract static class GeneratedCriteria {
protected List<Criterion> criteria;
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
public boolean isValid() {
return criteria.size() > 0;
}
public List<Criterion> getAllCriteria() {
return criteria;
}
public List<Criterion> getCriteria() {
return criteria;
}
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
}
criteria.add(new Criterion(condition));
}
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value));
}
protected void addCriterion(String condition, Object value1, Object value2, String property) {
if (value1 == null || value2 == null) {
throw new RuntimeException("Between values for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value1, value2));
}
public Criteria andIdIsNull() {
addCriterion("id is null");
return (Criteria) this;
}
public Criteria andIdIsNotNull() {
addCriterion("id is not null");
return (Criteria) this;
}
public Criteria andIdEqualTo(Integer value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(Integer value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Integer value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Integer value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Integer value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Integer> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andBiaotiIsNull() {
addCriterion("biaoti is null");
return (Criteria) this;
}
public Criteria andBiaotiIsNotNull() {
addCriterion("biaoti is not null");
return (Criteria) this;
}
public Criteria andBiaotiEqualTo(String value) {
addCriterion("biaoti =", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiNotEqualTo(String value) {
addCriterion("biaoti <>", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiGreaterThan(String value) {
addCriterion("biaoti >", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiGreaterThanOrEqualTo(String value) {
addCriterion("biaoti >=", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiLessThan(String value) {
addCriterion("biaoti <", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiLessThanOrEqualTo(String value) {
addCriterion("biaoti <=", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiLike(String value) {
addCriterion("biaoti like", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiNotLike(String value) {
addCriterion("biaoti not like", value, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiIn(List<String> values) {
addCriterion("biaoti in", values, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiNotIn(List<String> values) {
addCriterion("biaoti not in", values, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiBetween(String value1, String value2) {
addCriterion("biaoti between", value1, value2, "biaoti");
return (Criteria) this;
}
public Criteria andBiaotiNotBetween(String value1, String value2) {
addCriterion("biaoti not between", value1, value2, "biaoti");
return (Criteria) this;
}
public Criteria andNeirongIsNull() {
addCriterion("neirong is null");
return (Criteria) this;
}
public Criteria andNeirongIsNotNull() {
addCriterion("neirong is not null");
return (Criteria) this;
}
public Criteria andNeirongEqualTo(String value) {
addCriterion("neirong =", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongNotEqualTo(String value) {
addCriterion("neirong <>", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongGreaterThan(String value) {
addCriterion("neirong >", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongGreaterThanOrEqualTo(String value) {
addCriterion("neirong >=", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongLessThan(String value) {
addCriterion("neirong <", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongLessThanOrEqualTo(String value) {
addCriterion("neirong <=", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongLike(String value) {
addCriterion("neirong like", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongNotLike(String value) {
addCriterion("neirong not like", value, "neirong");
return (Criteria) this;
}
public Criteria andNeirongIn(List<String> values) {
addCriterion("neirong in", values, "neirong");
return (Criteria) this;
}
public Criteria andNeirongNotIn(List<String> values) {
addCriterion("neirong not in", values, "neirong");
return (Criteria) this;
}
public Criteria andNeirongBetween(String value1, String value2) {
addCriterion("neirong between", value1, value2, "neirong");
return (Criteria) this;
}
public Criteria andNeirongNotBetween(String value1, String value2) {
addCriterion("neirong not between", value1, value2, "neirong");
return (Criteria) this;
}
public Criteria andTupianIsNull() {
addCriterion("tupian is null");
return (Criteria) this;
}
public Criteria andTupianIsNotNull() {
addCriterion("tupian is not null");
return (Criteria) this;
}
public Criteria andTupianEqualTo(String value) {
addCriterion("tupian =", value, "tupian");
return (Criteria) this;
}
public Criteria andTupianNotEqualTo(String value) {
addCriterion("tupian <>", value, "tupian");
return (Criteria) this;
}
public Criteria andTupianGreaterThan(String value) {
addCriterion("tupian >", value, "tupian");
return (Criteria) this;
}
public Criteria andTupianGreaterThanOrEqualTo(String value) {
addCriterion("tupian >=", value, "tupian");
return (Criteria) this;
}
public Criteria andTupianLessThan(String value) {
addCriterion("tupian <", value, "tupian");
return (Criteria) this;
}
public Criteria andTupianLessThanOrEqualTo(String value) {
addCriterion("tupian <=", value, "tupian");
return (Criteria) this;
}
public Criteria andTupianLike(String value) {
addCriterion("tupian like", value, "tupian");
return (Criteria) this;
}
public Criteria andTupianNotLike(String value) {
addCriterion("tupian not like", value, "tupian");
return (Criteria) this;
}
public Criteria andTupianIn(List<String> values) {
addCriterion("tupian in", values, "tupian");
return (Criteria) this;
}
public Criteria andTupianNotIn(List<String> values) {
addCriterion("tupian not in", values, "tupian");
return (Criteria) this;
}
public Criteria andTupianBetween(String value1, String value2) {
addCriterion("tupian between", value1, value2, "tupian");
return (Criteria) this;
}
public Criteria andTupianNotBetween(String value1, String value2) {
addCriterion("tupian not between", value1, value2, "tupian");
return (Criteria) this;
}
public Criteria andShijianIsNull() {
addCriterion("shijian is null");
return (Criteria) this;
}
public Criteria andShijianIsNotNull() {
addCriterion("shijian is not null");
return (Criteria) this;
}
public Criteria andShijianEqualTo(String value) {
addCriterion("shijian =", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianNotEqualTo(String value) {
addCriterion("shijian <>", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianGreaterThan(String value) {
addCriterion("shijian >", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianGreaterThanOrEqualTo(String value) {
addCriterion("shijian >=", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianLessThan(String value) {
addCriterion("shijian <", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianLessThanOrEqualTo(String value) {
addCriterion("shijian <=", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianLike(String value) {
addCriterion("shijian like", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianNotLike(String value) {
addCriterion("shijian not like", value, "shijian");
return (Criteria) this;
}
public Criteria andShijianIn(List<String> values) {
addCriterion("shijian in", values, "shijian");
return (Criteria) this;
}
public Criteria andShijianNotIn(List<String> values) {
addCriterion("shijian not in", values, "shijian");
return (Criteria) this;
}
public Criteria andShijianBetween(String value1, String value2) {
addCriterion("shijian between", value1, value2, "shijian");
return (Criteria) this;
}
public Criteria andShijianNotBetween(String value1, String value2) {
addCriterion("shijian not between", value1, value2, "shijian");
return (Criteria) this;
}
}
public static class Criteria extends GeneratedCriteria {
protected Criteria() {
super();
}
}
public static class Criterion {
private String condition;
private Object value;
private Object secondValue;
private boolean noValue;
private boolean singleValue;
private boolean betweenValue;
private boolean listValue;
private String typeHandler;
public String getCondition() {
return condition;
}
public Object getValue() {
return value;
}
public Object getSecondValue() {
return secondValue;
}
public boolean isNoValue() {
return noValue;
}
public boolean isSingleValue() {
return singleValue;
}
public boolean isBetweenValue() {
return betweenValue;
}
public boolean isListValue() {
return listValue;
}
public String getTypeHandler() {
return typeHandler;
}
protected Criterion(String condition) {
super();
this.condition = condition;
this.typeHandler = null;
this.noValue = true;
}
protected Criterion(String condition, Object value, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.typeHandler = typeHandler;
if (value instanceof List<?>) {
this.listValue = true;
} else {
this.singleValue = true;
}
}
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.secondValue = secondValue;
this.typeHandler = typeHandler;
this.betweenValue = true;
}
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}
}
}

@ -1,53 +0,0 @@
package com.entity;
/**
* @ClassName Zhifufangshi
* @Description
*/
public class Zhifufangshi {
//id列
private Integer id;
//支付方式
private String mingcheng;
/**
* id
*
* @return id id
*/
public Integer getId() {
return this.id;
}
/**
* id
*
* @param id id
*/
public void setId(Integer id) {
this.id = id;
}
/**
*
*
* @return mingcheng
*/
public String getMingcheng() {
return this.mingcheng;
}
/**
*
*
* @param mingcheng
*/
public void setMingcheng(String mingcheng) {
this.mingcheng = mingcheng;
}
}

@ -1,335 +0,0 @@
package com.entity;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName Zhifufangshi
* @Description mybatis
*/
public class ZhifufangshiExample {
protected String orderByClause;
protected boolean distinct;
protected List<Criteria> oredCriteria;
public ZhifufangshiExample() {
oredCriteria = new ArrayList<Criteria>();
}
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
public String getOrderByClause() {
return orderByClause;
}
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
public boolean isDistinct() {
return distinct;
}
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
return criteria;
}
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
protected abstract static class GeneratedCriteria {
protected List<Criterion> criteria;
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
public boolean isValid() {
return criteria.size() > 0;
}
public List<Criterion> getAllCriteria() {
return criteria;
}
public List<Criterion> getCriteria() {
return criteria;
}
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
}
criteria.add(new Criterion(condition));
}
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value));
}
protected void addCriterion(String condition, Object value1, Object value2, String property) {
if (value1 == null || value2 == null) {
throw new RuntimeException("Between values for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value1, value2));
}
public Criteria andIdIsNull() {
addCriterion("id is null");
return (Criteria) this;
}
public Criteria andIdIsNotNull() {
addCriterion("id is not null");
return (Criteria) this;
}
public Criteria andIdEqualTo(Integer value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(Integer value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Integer value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Integer value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Integer value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Integer> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andMingchengIsNull() {
addCriterion("mingcheng is null");
return (Criteria) this;
}
public Criteria andMingchengIsNotNull() {
addCriterion("mingcheng is not null");
return (Criteria) this;
}
public Criteria andMingchengEqualTo(String value) {
addCriterion("mingcheng =", value, "mingcheng");
return (Criteria) this;
}
public Criteria andMingchengNotEqualTo(String value) {
addCriterion("mingcheng <>", value, "mingcheng");
return (Criteria) this;
}
public Criteria andMingchengGreaterThan(String value) {
addCriterion("mingcheng >", value, "mingcheng");
return (Criteria) this;
}
public Criteria andMingchengGreaterThanOrEqualTo(String value) {
addCriterion("mingcheng >=", value, "mingcheng");
return (Criteria) this;
}
public Criteria andMingchengLessThan(String value) {
addCriterion("mingcheng <", value, "mingcheng");
return (Criteria) this;
}
public Criteria andMingchengLessThanOrEqualTo(String value) {
addCriterion("mingcheng <=", value, "mingcheng");
return (Criteria) this;
}
public Criteria andMingchengLike(String value) {
addCriterion("mingcheng like", value, "mingcheng");
return (Criteria) this;
}
public Criteria andMingchengNotLike(String value) {
addCriterion("mingcheng not like", value, "mingcheng");
return (Criteria) this;
}
public Criteria andMingchengIn(List<String> values) {
addCriterion("mingcheng in", values, "mingcheng");
return (Criteria) this;
}
public Criteria andMingchengNotIn(List<String> values) {
addCriterion("mingcheng not in", values, "mingcheng");
return (Criteria) this;
}
public Criteria andMingchengBetween(String value1, String value2) {
addCriterion("mingcheng between", value1, value2, "mingcheng");
return (Criteria) this;
}
public Criteria andMingchengNotBetween(String value1, String value2) {
addCriterion("mingcheng not between", value1, value2, "mingcheng");
return (Criteria) this;
}
}
public static class Criteria extends GeneratedCriteria {
protected Criteria() {
super();
}
}
public static class Criterion {
private String condition;
private Object value;
private Object secondValue;
private boolean noValue;
private boolean singleValue;
private boolean betweenValue;
private boolean listValue;
private String typeHandler;
public String getCondition() {
return condition;
}
public Object getValue() {
return value;
}
public Object getSecondValue() {
return secondValue;
}
public boolean isNoValue() {
return noValue;
}
public boolean isSingleValue() {
return singleValue;
}
public boolean isBetweenValue() {
return betweenValue;
}
public boolean isListValue() {
return listValue;
}
public String getTypeHandler() {
return typeHandler;
}
protected Criterion(String condition) {
super();
this.condition = condition;
this.typeHandler = null;
this.noValue = true;
}
protected Criterion(String condition, Object value, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.typeHandler = typeHandler;
if (value instanceof List<?>) {
this.listValue = true;
} else {
this.singleValue = true;
}
}
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.secondValue = secondValue;
this.typeHandler = typeHandler;
this.betweenValue = true;
}
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}
}
}

@ -1,81 +0,0 @@
package com.interceptor;
import com.alibaba.fastjson.JSONObject;
import com.annotation.IgnoreAuth;
import com.util.ApiResponse;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;
/**
* @ClassName AuthorizationInterceptor
* @Description
*/
@Slf4j
@Component
public class AuthorizationInterceptor implements HandlerInterceptor {
public static final String LOGIN_TOKEN_KEY = "Token";
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//支持跨域请求
response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE");
response.setHeader("Access-Control-Max-Age", "3600");
response.setHeader("Access-Control-Allow-Credentials", "true");
response.setHeader("Access-Control-Allow-Headers", "x-requested-with,request-source,Token, Origin,imgType, Content-Type, cache-control,postman-token,Cookie, Accept,authorization");
response.setHeader("Access-Control-Allow-Origin", request.getHeader("Origin"));
// 跨域时会首先发送一个OPTIONS请求这里我们给OPTIONS请求直接返回正常状态
if (request.getMethod().equals(RequestMethod.OPTIONS.name())) {
response.setStatus(HttpStatus.OK.value());
return false;
}
IgnoreAuth annotation;
if (handler instanceof HandlerMethod) {
annotation = ((HandlerMethod) handler).getMethodAnnotation(IgnoreAuth.class);
} else {
return true;
}
/**
*
*/
if(annotation!=null) {
return true;
}
//从header中获取token
String headerToken = request.getHeader(LOGIN_TOKEN_KEY);
String token="";
if(null != request.getSession().getAttribute("token")){
token=request.getSession().getAttribute("token").toString();
}
if(StringUtils.isNotBlank(headerToken) && StringUtils.isNotBlank(token) && headerToken.equals(token)){
return true;
}
PrintWriter writer = null;
response.setCharacterEncoding("UTF-8");
response.setContentType("application/json; charset=utf-8");
try {
writer = response.getWriter();
writer.print(JSONObject.toJSONString(ApiResponse.failed(401,"登录信息失效,请重新登录")));
} finally {
if(writer != null){
writer.close();
}
}
return false;
}
}

@ -1,44 +0,0 @@
package com.service;
import com.entity.Dingdan;
import com.util.PageData;
import com.util.PageWrap;
import java.util.List;
/**
* @ClassName DingdanService
* @Description
*/
public interface DingdanService {
//保存或更新订单表数据
Integer saveOrUpdate(Dingdan instance);
//查询所有订单表数据
List<Dingdan> findAll();
//根据条件(字符类型模糊)查询订单表数据
List<Dingdan> find(Dingdan instance);
//根据条件(字符类型完全匹配)查询订单表数据
List<Dingdan> findByEqualTo(Dingdan instance);
//根据条件(字符类型模糊)查询查询第一条订单表数据
Dingdan findOne(Dingdan instance);
//根据条件(字符类型完全匹配)查询查询第一条订单表数据
Dingdan findOneByEqualTo(Dingdan instance);
//根据id列查询订单表数据
Dingdan findById(Integer id);
//根据id列删除订单表数据
int deleteById(Integer id);
//根据条件(字符类型模糊)分页查询订单表数据
PageData<Dingdan> findPage(PageWrap<Dingdan> pageWrap);
//根据条件(字符类型完全匹配)分页查询订单表数据
PageData<Dingdan> findPageByEqualTo(PageWrap<Dingdan> pageWrap);
}

@ -1,44 +0,0 @@
package com.service;
import com.entity.Dingdanxiang;
import com.util.PageData;
import com.util.PageWrap;
import java.util.List;
/**
* @ClassName DingdanxiangService
* @Description
*/
public interface DingdanxiangService {
//保存或更新订单项表数据
Integer saveOrUpdate(Dingdanxiang instance);
//查询所有订单项表数据
List<Dingdanxiang> findAll();
//根据条件(字符类型模糊)查询订单项表数据
List<Dingdanxiang> find(Dingdanxiang instance);
//根据条件(字符类型完全匹配)查询订单项表数据
List<Dingdanxiang> findByEqualTo(Dingdanxiang instance);
//根据条件(字符类型模糊)查询查询第一条订单项表数据
Dingdanxiang findOne(Dingdanxiang instance);
//根据条件(字符类型完全匹配)查询查询第一条订单项表数据
Dingdanxiang findOneByEqualTo(Dingdanxiang instance);
//根据id列查询订单项表数据
Dingdanxiang findById(Integer id);
//根据id列删除订单项表数据
int deleteById(Integer id);
//根据条件(字符类型模糊)分页查询订单项表数据
PageData<Dingdanxiang> findPage(PageWrap<Dingdanxiang> pageWrap);
//根据条件(字符类型完全匹配)分页查询订单项表数据
PageData<Dingdanxiang> findPageByEqualTo(PageWrap<Dingdanxiang> pageWrap);
}

@ -1,44 +0,0 @@
package com.service;
import com.entity.Dx;
import com.util.PageData;
import com.util.PageWrap;
import java.util.List;
/**
* @ClassName DxService
* @Description
*/
public interface DxService {
//保存或更新信息介绍表数据
Integer saveOrUpdate(Dx instance);
//查询所有信息介绍表数据
List<Dx> findAll();
//根据条件(字符类型模糊)查询信息介绍表数据
List<Dx> find(Dx instance);
//根据条件(字符类型完全匹配)查询信息介绍表数据
List<Dx> findByEqualTo(Dx instance);
//根据条件(字符类型模糊)查询查询第一条信息介绍表数据
Dx findOne(Dx instance);
//根据条件(字符类型完全匹配)查询查询第一条信息介绍表数据
Dx findOneByEqualTo(Dx instance);
//根据id列查询信息介绍表数据
Dx findById(Integer id);
//根据id列删除信息介绍表数据
int deleteById(Integer id);
//根据条件(字符类型模糊)分页查询信息介绍表数据
PageData<Dx> findPage(PageWrap<Dx> pageWrap);
//根据条件(字符类型完全匹配)分页查询信息介绍表数据
PageData<Dx> findPageByEqualTo(PageWrap<Dx> pageWrap);
}

@ -1,44 +0,0 @@
package com.service;
import com.entity.Gonggao;
import com.util.PageData;
import com.util.PageWrap;
import java.util.List;
/**
* @ClassName GonggaoService
* @Description
*/
public interface GonggaoService {
//保存或更新公告表数据
Integer saveOrUpdate(Gonggao instance);
//查询所有公告表数据
List<Gonggao> findAll();
//根据条件(字符类型模糊)查询公告表数据
List<Gonggao> find(Gonggao instance);
//根据条件(字符类型完全匹配)查询公告表数据
List<Gonggao> findByEqualTo(Gonggao instance);
//根据条件(字符类型模糊)查询查询第一条公告表数据
Gonggao findOne(Gonggao instance);
//根据条件(字符类型完全匹配)查询查询第一条公告表数据
Gonggao findOneByEqualTo(Gonggao instance);
//根据id列查询公告表数据
Gonggao findById(Integer id);
//根据id列删除公告表数据
int deleteById(Integer id);
//根据条件(字符类型模糊)分页查询公告表数据
PageData<Gonggao> findPage(PageWrap<Gonggao> pageWrap);
//根据条件(字符类型完全匹配)分页查询公告表数据
PageData<Gonggao> findPageByEqualTo(PageWrap<Gonggao> pageWrap);
}

@ -1,44 +0,0 @@
package com.service;
import com.entity.Gouwuche;
import com.util.PageData;
import com.util.PageWrap;
import java.util.List;
/**
* @ClassName GouwucheService
* @Description
*/
public interface GouwucheService {
//保存或更新购物车表数据
Integer saveOrUpdate(Gouwuche instance);
//查询所有购物车表数据
List<Gouwuche> findAll();
//根据条件(字符类型模糊)查询购物车表数据
List<Gouwuche> find(Gouwuche instance);
//根据条件(字符类型完全匹配)查询购物车表数据
List<Gouwuche> findByEqualTo(Gouwuche instance);
//根据条件(字符类型模糊)查询查询第一条购物车表数据
Gouwuche findOne(Gouwuche instance);
//根据条件(字符类型完全匹配)查询查询第一条购物车表数据
Gouwuche findOneByEqualTo(Gouwuche instance);
//根据id列查询购物车表数据
Gouwuche findById(Integer id);
//根据id列删除购物车表数据
int deleteById(Integer id);
//根据条件(字符类型模糊)分页查询购物车表数据
PageData<Gouwuche> findPage(PageWrap<Gouwuche> pageWrap);
//根据条件(字符类型完全匹配)分页查询购物车表数据
PageData<Gouwuche> findPageByEqualTo(PageWrap<Gouwuche> pageWrap);
}

@ -1,44 +0,0 @@
package com.service;
import com.entity.Lianjie;
import com.util.PageData;
import com.util.PageWrap;
import java.util.List;
/**
* @ClassName LianjieService
* @Description
*/
public interface LianjieService {
//保存或更新友情链接表数据
Integer saveOrUpdate(Lianjie instance);
//查询所有友情链接表数据
List<Lianjie> findAll();
//根据条件(字符类型模糊)查询友情链接表数据
List<Lianjie> find(Lianjie instance);
//根据条件(字符类型完全匹配)查询友情链接表数据
List<Lianjie> findByEqualTo(Lianjie instance);
//根据条件(字符类型模糊)查询查询第一条友情链接表数据
Lianjie findOne(Lianjie instance);
//根据条件(字符类型完全匹配)查询查询第一条友情链接表数据
Lianjie findOneByEqualTo(Lianjie instance);
//根据id列查询友情链接表数据
Lianjie findById(Integer id);
//根据id列删除友情链接表数据
int deleteById(Integer id);
//根据条件(字符类型模糊)分页查询友情链接表数据
PageData<Lianjie> findPage(PageWrap<Lianjie> pageWrap);
//根据条件(字符类型完全匹配)分页查询友情链接表数据
PageData<Lianjie> findPageByEqualTo(PageWrap<Lianjie> pageWrap);
}

@ -1,44 +0,0 @@
package com.service;
import com.entity.Liuyan;
import com.util.PageData;
import com.util.PageWrap;
import java.util.List;
/**
* @ClassName LiuyanService
* @Description
*/
public interface LiuyanService {
//保存或更新留言反馈表数据
Integer saveOrUpdate(Liuyan instance);
//查询所有留言反馈表数据
List<Liuyan> findAll();
//根据条件(字符类型模糊)查询留言反馈表数据
List<Liuyan> find(Liuyan instance);
//根据条件(字符类型完全匹配)查询留言反馈表数据
List<Liuyan> findByEqualTo(Liuyan instance);
//根据条件(字符类型模糊)查询查询第一条留言反馈表数据
Liuyan findOne(Liuyan instance);
//根据条件(字符类型完全匹配)查询查询第一条留言反馈表数据
Liuyan findOneByEqualTo(Liuyan instance);
//根据id列查询留言反馈表数据
Liuyan findById(Integer id);
//根据id列删除留言反馈表数据
int deleteById(Integer id);
//根据条件(字符类型模糊)分页查询留言反馈表数据
PageData<Liuyan> findPage(PageWrap<Liuyan> pageWrap);
//根据条件(字符类型完全匹配)分页查询留言反馈表数据
PageData<Liuyan> findPageByEqualTo(PageWrap<Liuyan> pageWrap);
}

@ -1,44 +0,0 @@
package com.service;
import com.entity.Lunbo;
import com.util.PageData;
import com.util.PageWrap;
import java.util.List;
/**
* @ClassName LunboService
* @Description
*/
public interface LunboService {
//保存或更新轮播图表数据
Integer saveOrUpdate(Lunbo instance);
//查询所有轮播图表数据
List<Lunbo> findAll();
//根据条件(字符类型模糊)查询轮播图表数据
List<Lunbo> find(Lunbo instance);
//根据条件(字符类型完全匹配)查询轮播图表数据
List<Lunbo> findByEqualTo(Lunbo instance);
//根据条件(字符类型模糊)查询查询第一条轮播图表数据
Lunbo findOne(Lunbo instance);
//根据条件(字符类型完全匹配)查询查询第一条轮播图表数据
Lunbo findOneByEqualTo(Lunbo instance);
//根据id列查询轮播图表数据
Lunbo findById(Integer id);
//根据id列删除轮播图表数据
int deleteById(Integer id);
//根据条件(字符类型模糊)分页查询轮播图表数据
PageData<Lunbo> findPage(PageWrap<Lunbo> pageWrap);
//根据条件(字符类型完全匹配)分页查询轮播图表数据
PageData<Lunbo> findPageByEqualTo(PageWrap<Lunbo> pageWrap);
}

@ -1,44 +0,0 @@
package com.service;
import com.entity.Pingjia;
import com.util.PageData;
import com.util.PageWrap;
import java.util.List;
/**
* @ClassName PingjiaService
* @Description
*/
public interface PingjiaService {
//保存或更新评论表数据
Integer saveOrUpdate(Pingjia instance);
//查询所有评论表数据
List<Pingjia> findAll();
//根据条件(字符类型模糊)查询评论表数据
List<Pingjia> find(Pingjia instance);
//根据条件(字符类型完全匹配)查询评论表数据
List<Pingjia> findByEqualTo(Pingjia instance);
//根据条件(字符类型模糊)查询查询第一条评论表数据
Pingjia findOne(Pingjia instance);
//根据条件(字符类型完全匹配)查询查询第一条评论表数据
Pingjia findOneByEqualTo(Pingjia instance);
//根据id列查询评论表数据
Pingjia findById(Integer id);
//根据id列删除评论表数据
int deleteById(Integer id);
//根据条件(字符类型模糊)分页查询评论表数据
PageData<Pingjia> findPage(PageWrap<Pingjia> pageWrap);
//根据条件(字符类型完全匹配)分页查询评论表数据
PageData<Pingjia> findPageByEqualTo(PageWrap<Pingjia> pageWrap);
}

@ -1,44 +0,0 @@
package com.service;
import com.entity.Pinlei;
import com.util.PageData;
import com.util.PageWrap;
import java.util.List;
/**
* @ClassName PinleiService
* @Description
*/
public interface PinleiService {
//保存或更新分类表数据
Integer saveOrUpdate(Pinlei instance);
//查询所有分类表数据
List<Pinlei> findAll();
//根据条件(字符类型模糊)查询分类表数据
List<Pinlei> find(Pinlei instance);
//根据条件(字符类型完全匹配)查询分类表数据
List<Pinlei> findByEqualTo(Pinlei instance);
//根据条件(字符类型模糊)查询查询第一条分类表数据
Pinlei findOne(Pinlei instance);
//根据条件(字符类型完全匹配)查询查询第一条分类表数据
Pinlei findOneByEqualTo(Pinlei instance);
//根据id列查询分类表数据
Pinlei findById(Integer id);
//根据id列删除分类表数据
int deleteById(Integer id);
//根据条件(字符类型模糊)分页查询分类表数据
PageData<Pinlei> findPage(PageWrap<Pinlei> pageWrap);
//根据条件(字符类型完全匹配)分页查询分类表数据
PageData<Pinlei> findPageByEqualTo(PageWrap<Pinlei> pageWrap);
}

@ -1,44 +0,0 @@
package com.service;
import com.entity.Shangpin;
import com.util.PageData;
import com.util.PageWrap;
import java.util.List;
/**
* @ClassName ShangpinService
* @Description
*/
public interface ShangpinService {
//保存或更新零食表数据
Integer saveOrUpdate(Shangpin instance);
//查询所有零食表数据
List<Shangpin> findAll();
//根据条件(字符类型模糊)查询零食表数据
List<Shangpin> find(Shangpin instance);
//根据条件(字符类型完全匹配)查询零食表数据
List<Shangpin> findByEqualTo(Shangpin instance);
//根据条件(字符类型模糊)查询查询第一条零食表数据
Shangpin findOne(Shangpin instance);
//根据条件(字符类型完全匹配)查询查询第一条零食表数据
Shangpin findOneByEqualTo(Shangpin instance);
//根据id列查询零食表数据
Shangpin findById(Integer id);
//根据id列删除零食表数据
int deleteById(Integer id);
//根据条件(字符类型模糊)分页查询零食表数据
PageData<Shangpin> findPage(PageWrap<Shangpin> pageWrap);
//根据条件(字符类型完全匹配)分页查询零食表数据
PageData<Shangpin> findPageByEqualTo(PageWrap<Shangpin> pageWrap);
}

@ -1,44 +0,0 @@
package com.service;
import com.entity.Shenqing;
import com.util.PageData;
import com.util.PageWrap;
import java.util.List;
/**
* @ClassName ShenqingService
* @Description
*/
public interface ShenqingService {
//保存或更新售后申请表数据
Integer saveOrUpdate(Shenqing instance);
//查询所有售后申请表数据
List<Shenqing> findAll();
//根据条件(字符类型模糊)查询售后申请表数据
List<Shenqing> find(Shenqing instance);
//根据条件(字符类型完全匹配)查询售后申请表数据
List<Shenqing> findByEqualTo(Shenqing instance);
//根据条件(字符类型模糊)查询查询第一条售后申请表数据
Shenqing findOne(Shenqing instance);
//根据条件(字符类型完全匹配)查询查询第一条售后申请表数据
Shenqing findOneByEqualTo(Shenqing instance);
//根据id列查询售后申请表数据
Shenqing findById(Integer id);
//根据id列删除售后申请表数据
int deleteById(Integer id);
//根据条件(字符类型模糊)分页查询售后申请表数据
PageData<Shenqing> findPage(PageWrap<Shenqing> pageWrap);
//根据条件(字符类型完全匹配)分页查询售后申请表数据
PageData<Shenqing> findPageByEqualTo(PageWrap<Shenqing> pageWrap);
}

@ -1,44 +0,0 @@
package com.service;
import com.entity.Shoucang;
import com.util.PageData;
import com.util.PageWrap;
import java.util.List;
/**
* @ClassName ShoucangService
* @Description
*/
public interface ShoucangService {
//保存或更新收藏表数据
Integer saveOrUpdate(Shoucang instance);
//查询所有收藏表数据
List<Shoucang> findAll();
//根据条件(字符类型模糊)查询收藏表数据
List<Shoucang> find(Shoucang instance);
//根据条件(字符类型完全匹配)查询收藏表数据
List<Shoucang> findByEqualTo(Shoucang instance);
//根据条件(字符类型模糊)查询查询第一条收藏表数据
Shoucang findOne(Shoucang instance);
//根据条件(字符类型完全匹配)查询查询第一条收藏表数据
Shoucang findOneByEqualTo(Shoucang instance);
//根据id列查询收藏表数据
Shoucang findById(Integer id);
//根据id列删除收藏表数据
int deleteById(Integer id);
//根据条件(字符类型模糊)分页查询收藏表数据
PageData<Shoucang> findPage(PageWrap<Shoucang> pageWrap);
//根据条件(字符类型完全匹配)分页查询收藏表数据
PageData<Shoucang> findPageByEqualTo(PageWrap<Shoucang> pageWrap);
}

@ -1,44 +0,0 @@
package com.service;
import com.entity.Users;
import com.util.PageData;
import com.util.PageWrap;
import java.util.List;
/**
* @ClassName UsersService
* @Description
*/
public interface UsersService {
//保存或更新用户表数据
Integer saveOrUpdate(Users instance);
//查询所有用户表数据
List<Users> findAll();
//根据条件(字符类型模糊)查询用户表数据
List<Users> find(Users instance);
//根据条件(字符类型完全匹配)查询用户表数据
List<Users> findByEqualTo(Users instance);
//根据条件(字符类型模糊)查询查询第一条用户表数据
Users findOne(Users instance);
//根据条件(字符类型完全匹配)查询查询第一条用户表数据
Users findOneByEqualTo(Users instance);
//根据id列查询用户表数据
Users findById(Integer id);
//根据id列删除用户表数据
int deleteById(Integer id);
//根据条件(字符类型模糊)分页查询用户表数据
PageData<Users> findPage(PageWrap<Users> pageWrap);
//根据条件(字符类型完全匹配)分页查询用户表数据
PageData<Users> findPageByEqualTo(PageWrap<Users> pageWrap);
}

@ -1,44 +0,0 @@
package com.service;
import com.entity.Xinwen;
import com.util.PageData;
import com.util.PageWrap;
import java.util.List;
/**
* @ClassName XinwenService
* @Description
*/
public interface XinwenService {
//保存或更新新闻表数据
Integer saveOrUpdate(Xinwen instance);
//查询所有新闻表数据
List<Xinwen> findAll();
//根据条件(字符类型模糊)查询新闻表数据
List<Xinwen> find(Xinwen instance);
//根据条件(字符类型完全匹配)查询新闻表数据
List<Xinwen> findByEqualTo(Xinwen instance);
//根据条件(字符类型模糊)查询查询第一条新闻表数据
Xinwen findOne(Xinwen instance);
//根据条件(字符类型完全匹配)查询查询第一条新闻表数据
Xinwen findOneByEqualTo(Xinwen instance);
//根据id列查询新闻表数据
Xinwen findById(Integer id);
//根据id列删除新闻表数据
int deleteById(Integer id);
//根据条件(字符类型模糊)分页查询新闻表数据
PageData<Xinwen> findPage(PageWrap<Xinwen> pageWrap);
//根据条件(字符类型完全匹配)分页查询新闻表数据
PageData<Xinwen> findPageByEqualTo(PageWrap<Xinwen> pageWrap);
}

@ -1,44 +0,0 @@
package com.service;
import com.entity.Zhifufangshi;
import com.util.PageData;
import com.util.PageWrap;
import java.util.List;
/**
* @ClassName ZhifufangshiService
* @Description
*/
public interface ZhifufangshiService {
//保存或更新支付方式表数据
Integer saveOrUpdate(Zhifufangshi instance);
//查询所有支付方式表数据
List<Zhifufangshi> findAll();
//根据条件(字符类型模糊)查询支付方式表数据
List<Zhifufangshi> find(Zhifufangshi instance);
//根据条件(字符类型完全匹配)查询支付方式表数据
List<Zhifufangshi> findByEqualTo(Zhifufangshi instance);
//根据条件(字符类型模糊)查询查询第一条支付方式表数据
Zhifufangshi findOne(Zhifufangshi instance);
//根据条件(字符类型完全匹配)查询查询第一条支付方式表数据
Zhifufangshi findOneByEqualTo(Zhifufangshi instance);
//根据id列查询支付方式表数据
Zhifufangshi findById(Integer id);
//根据id列删除支付方式表数据
int deleteById(Integer id);
//根据条件(字符类型模糊)分页查询支付方式表数据
PageData<Zhifufangshi> findPage(PageWrap<Zhifufangshi> pageWrap);
//根据条件(字符类型完全匹配)分页查询支付方式表数据
PageData<Zhifufangshi> findPageByEqualTo(PageWrap<Zhifufangshi> pageWrap);
}

@ -1,276 +0,0 @@
package com.service.impl;
import com.dao.*;
import com.entity.*;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.service.*;
import com.util.ExampleBuilder;
import com.util.PageData;
import com.util.PageWrap;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* @ClassName DingdanServiceImpl
* @Description
*/
@Service
public class DingdanServiceImpl implements DingdanService {
@Autowired
private DingdanMapper dingdanMapper;
@Autowired
private ZhifufangshiMapper zhifufangshiMapper;
@Autowired
private UsersMapper usersMapper;
//保存或更新订单表dingdan
@Override
public Integer saveOrUpdate(Dingdan instance) {
if(null != instance.getId() && instance.getId() > 0) {
dingdanMapper.updateByPrimaryKeySelective(instance);
}else {
dingdanMapper.insertSelective(instance);
}
return instance.getId();
}
//查询订单表dingdan
@Override
public List<Dingdan> findAll() {
List<Dingdan> list = dingdanMapper.selectByExample(null);
for (Dingdan info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型模糊匹配)查询订单表dingdan
@Override
public List<Dingdan> find(Dingdan instance) {
DingdanExample dingdanExample = getDingdanExampleByLike(instance);
dingdanExample.setOrderByClause(" id desc");
List<Dingdan> list = dingdanMapper.selectByExample(dingdanExample);
for (Dingdan info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型完全匹配)查询订单表dingdan
@Override
public List<Dingdan> findByEqualTo(Dingdan instance) {
DingdanExample dingdanExample = getDingdanExampleByEqualTo(instance);
dingdanExample.setOrderByClause(" id desc");
List<Dingdan> list = dingdanMapper.selectByExample(dingdanExample);
for (Dingdan info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型模糊匹配)查询订单表dingdan最后一条数据
@Override
public Dingdan findOne(Dingdan instance) {
List<Dingdan> list = find(instance);
if (list.size() > 0) {
return list.get(0);
}
return null;
}
//根据条件(字符类型完全匹配)查询订单表dingdan最后一条数据
@Override
public Dingdan findOneByEqualTo(Dingdan instance) {
List<Dingdan> list = findByEqualTo(instance);
if (list.size() > 0) {
return list.get(0);
}
return null;
}
//根据id列查询订单表dingdan数据
@Override
public Dingdan findById(Integer id) {
Dingdan info = dingdanMapper.selectByPrimaryKey(id);
setFatherInfo(info);
return info;
}
//根据主键id列删除订单表dingdan数据
@Override
public int deleteById(Integer id) {
return dingdanMapper.deleteByPrimaryKey(id);
}
//根据条件(字符类型模糊匹配)分页查询订单表dingdan数据
@Override
public PageData<Dingdan> findPage(PageWrap<Dingdan> pageWrap) {
PageHelper.startPage(pageWrap.getPageNum(), pageWrap.getPageSize());
DingdanExample dingdanExample = getDingdanExampleByLike(pageWrap.getModel());
dingdanExample.setOrderByClause(pageWrap.getOrderByClause());
List<Dingdan> list = dingdanMapper.selectByExample(dingdanExample);
for (Dingdan info:list) {
setFatherInfo(info);
}
return PageData.from(new PageInfo<>(list));
}
//根据条件(字符类型完全匹配)分页查询订单表dingdan数据
@Override
public PageData<Dingdan> findPageByEqualTo(PageWrap<Dingdan> pageWrap) {
PageHelper.startPage(pageWrap.getPageNum(), pageWrap.getPageSize());
DingdanExample dingdanExample = getDingdanExampleByEqualTo(pageWrap.getModel());
dingdanExample.setOrderByClause(pageWrap.getOrderByClause());
List<Dingdan> list = dingdanMapper.selectByExample(dingdanExample);
for (Dingdan info:list) {
setFatherInfo(info);
}
return PageData.from(new PageInfo<>(list));
}
//父表信息
private void setFatherInfo(Dingdan info){
if (null != info){
Zhifufangshi zhifufangshi= zhifufangshiMapper.selectByPrimaryKey(info.getZhifufangshiid());
info.setZhifufangshi(zhifufangshi);
Users users= usersMapper.selectByPrimaryKey(info.getUsersid());
info.setUsers(users);
}
}
//字符类型模糊查询条件构造器
private DingdanExample getDingdanExampleByLike(Dingdan instance) {
DingdanExample dingdanExample = new DingdanExample();
DingdanExample.Criteria criteria = dingdanExample.createCriteria();
//订单id完全匹配
if (null != instance.getId()) {
criteria.andIdEqualTo(instance.getId());
}
//编号bianhao模糊匹配
if (null != instance.getBianhao() && !instance.getBianhao().equals("")) {
criteria.andBianhaoLike("%" + instance.getBianhao() + "%");
}
//订单金额jine完全匹配
if (null != instance.getJine()) {
criteria.andJineEqualTo(instance.getJine());
}
//是否支付zhifushenhe模糊匹配
if (null != instance.getZhifushenhe() && !instance.getZhifushenhe().equals("")) {
criteria.andZhifushenheLike("%" + instance.getZhifushenhe() + "%");
}
//是否发货fahuoshenhe模糊匹配
if (null != instance.getFahuoshenhe() && !instance.getFahuoshenhe().equals("")) {
criteria.andFahuoshenheLike("%" + instance.getFahuoshenhe() + "%");
}
//是否收货shouhuoshenhe模糊匹配
if (null != instance.getShouhuoshenhe() && !instance.getShouhuoshenhe().equals("")) {
criteria.andShouhuoshenheLike("%" + instance.getShouhuoshenhe() + "%");
}
//支付方式zhifufangshiid完全匹配
if (null != instance.getZhifufangshiid()) {
criteria.andZhifufangshiidEqualTo(instance.getZhifufangshiid());
}
//姓名xingming模糊匹配
if (null != instance.getXingming() && !instance.getXingming().equals("")) {
criteria.andXingmingLike("%" + instance.getXingming() + "%");
}
//电话dianhua模糊匹配
if (null != instance.getDianhua() && !instance.getDianhua().equals("")) {
criteria.andDianhuaLike("%" + instance.getDianhua() + "%");
}
//送货地址dizhi模糊匹配
if (null != instance.getDizhi() && !instance.getDizhi().equals("")) {
criteria.andDizhiLike("%" + instance.getDizhi() + "%");
}
//时间shijian模糊匹配
if (null != instance.getShijian() && !instance.getShijian().equals("")) {
criteria.andShijianLike("%" + instance.getShijian() + "%");
}
//物流信息wuliu模糊匹配
if (null != instance.getWuliu() && !instance.getWuliu().equals("")) {
criteria.andWuliuLike("%" + instance.getWuliu() + "%");
}
//备注beizhu模糊匹配
if (null != instance.getBeizhu() && !instance.getBeizhu().equals("")) {
criteria.andBeizhuLike("%" + instance.getBeizhu() + "%");
}
//用户idusersid完全匹配
if (null != instance.getUsersid()) {
criteria.andUsersidEqualTo(instance.getUsersid());
}
return dingdanExample;
}
//字符类型完全相等查询条件构造器
private DingdanExample getDingdanExampleByEqualTo(Dingdan instance) {
DingdanExample dingdanExample = new DingdanExample();
DingdanExample.Criteria criteria = dingdanExample.createCriteria();
//订单id完全匹配
if (null != instance.getId()) {
criteria.andIdEqualTo(instance.getId());
}
//编号bianhao完全匹配
if (null != instance.getBianhao() && !instance.getBianhao().equals("")) {
criteria.andBianhaoEqualTo(instance.getBianhao());
}
//订单金额jine完全匹配
if (null != instance.getJine()) {
criteria.andJineEqualTo(instance.getJine());
}
//是否支付zhifushenhe完全匹配
if (null != instance.getZhifushenhe() && !instance.getZhifushenhe().equals("")) {
criteria.andZhifushenheEqualTo(instance.getZhifushenhe());
}
//是否发货fahuoshenhe完全匹配
if (null != instance.getFahuoshenhe() && !instance.getFahuoshenhe().equals("")) {
criteria.andFahuoshenheEqualTo(instance.getFahuoshenhe());
}
//是否收货shouhuoshenhe完全匹配
if (null != instance.getShouhuoshenhe() && !instance.getShouhuoshenhe().equals("")) {
criteria.andShouhuoshenheEqualTo(instance.getShouhuoshenhe());
}
//支付方式zhifufangshiid完全匹配
if (null != instance.getZhifufangshiid()) {
criteria.andZhifufangshiidEqualTo(instance.getZhifufangshiid());
}
//姓名xingming完全匹配
if (null != instance.getXingming() && !instance.getXingming().equals("")) {
criteria.andXingmingEqualTo(instance.getXingming());
}
//电话dianhua完全匹配
if (null != instance.getDianhua() && !instance.getDianhua().equals("")) {
criteria.andDianhuaEqualTo(instance.getDianhua());
}
//送货地址dizhi完全匹配
if (null != instance.getDizhi() && !instance.getDizhi().equals("")) {
criteria.andDizhiEqualTo(instance.getDizhi());
}
//时间shijian完全匹配
if (null != instance.getShijian() && !instance.getShijian().equals("")) {
criteria.andShijianEqualTo(instance.getShijian());
}
//物流信息wuliu完全匹配
if (null != instance.getWuliu() && !instance.getWuliu().equals("")) {
criteria.andWuliuEqualTo(instance.getWuliu());
}
//备注beizhu完全匹配
if (null != instance.getBeizhu() && !instance.getBeizhu().equals("")) {
criteria.andBeizhuEqualTo(instance.getBeizhu());
}
//用户idusersid完全匹配
if (null != instance.getUsersid()) {
criteria.andUsersidEqualTo(instance.getUsersid());
}
return dingdanExample;
}
}

@ -1,208 +0,0 @@
package com.service.impl;
import com.dao.*;
import com.entity.*;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.service.*;
import com.util.ExampleBuilder;
import com.util.PageData;
import com.util.PageWrap;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* @ClassName DingdanxiangServiceImpl
* @Description
*/
@Service
public class DingdanxiangServiceImpl implements DingdanxiangService {
@Autowired
private DingdanxiangMapper dingdanxiangMapper;
@Autowired
private DingdanMapper dingdanMapper;
@Autowired
private ShangpinMapper shangpinMapper;
@Autowired
private UsersMapper usersMapper;
//保存或更新订单项表dingdanxiang
@Override
public Integer saveOrUpdate(Dingdanxiang instance) {
if(null != instance.getId() && instance.getId() > 0) {
dingdanxiangMapper.updateByPrimaryKeySelective(instance);
}else {
dingdanxiangMapper.insertSelective(instance);
}
return instance.getId();
}
//查询订单项表dingdanxiang
@Override
public List<Dingdanxiang> findAll() {
List<Dingdanxiang> list = dingdanxiangMapper.selectByExample(null);
for (Dingdanxiang info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型模糊匹配)查询订单项表dingdanxiang
@Override
public List<Dingdanxiang> find(Dingdanxiang instance) {
DingdanxiangExample dingdanxiangExample = getDingdanxiangExampleByLike(instance);
dingdanxiangExample.setOrderByClause(" id desc");
List<Dingdanxiang> list = dingdanxiangMapper.selectByExample(dingdanxiangExample);
for (Dingdanxiang info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型完全匹配)查询订单项表dingdanxiang
@Override
public List<Dingdanxiang> findByEqualTo(Dingdanxiang instance) {
DingdanxiangExample dingdanxiangExample = getDingdanxiangExampleByEqualTo(instance);
dingdanxiangExample.setOrderByClause(" id desc");
List<Dingdanxiang> list = dingdanxiangMapper.selectByExample(dingdanxiangExample);
for (Dingdanxiang info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型模糊匹配)查询订单项表dingdanxiang最后一条数据
@Override
public Dingdanxiang findOne(Dingdanxiang instance) {
List<Dingdanxiang> list = find(instance);
if (list.size() > 0) {
return list.get(0);
}
return null;
}
//根据条件(字符类型完全匹配)查询订单项表dingdanxiang最后一条数据
@Override
public Dingdanxiang findOneByEqualTo(Dingdanxiang instance) {
List<Dingdanxiang> list = findByEqualTo(instance);
if (list.size() > 0) {
return list.get(0);
}
return null;
}
//根据id列查询订单项表dingdanxiang数据
@Override
public Dingdanxiang findById(Integer id) {
Dingdanxiang info = dingdanxiangMapper.selectByPrimaryKey(id);
setFatherInfo(info);
return info;
}
//根据主键id列删除订单项表dingdanxiang数据
@Override
public int deleteById(Integer id) {
return dingdanxiangMapper.deleteByPrimaryKey(id);
}
//根据条件(字符类型模糊匹配)分页查询订单项表dingdanxiang数据
@Override
public PageData<Dingdanxiang> findPage(PageWrap<Dingdanxiang> pageWrap) {
PageHelper.startPage(pageWrap.getPageNum(), pageWrap.getPageSize());
DingdanxiangExample dingdanxiangExample = getDingdanxiangExampleByLike(pageWrap.getModel());
dingdanxiangExample.setOrderByClause(pageWrap.getOrderByClause());
List<Dingdanxiang> list = dingdanxiangMapper.selectByExample(dingdanxiangExample);
for (Dingdanxiang info:list) {
setFatherInfo(info);
}
return PageData.from(new PageInfo<>(list));
}
//根据条件(字符类型完全匹配)分页查询订单项表dingdanxiang数据
@Override
public PageData<Dingdanxiang> findPageByEqualTo(PageWrap<Dingdanxiang> pageWrap) {
PageHelper.startPage(pageWrap.getPageNum(), pageWrap.getPageSize());
DingdanxiangExample dingdanxiangExample = getDingdanxiangExampleByEqualTo(pageWrap.getModel());
dingdanxiangExample.setOrderByClause(pageWrap.getOrderByClause());
List<Dingdanxiang> list = dingdanxiangMapper.selectByExample(dingdanxiangExample);
for (Dingdanxiang info:list) {
setFatherInfo(info);
}
return PageData.from(new PageInfo<>(list));
}
//父表信息
private void setFatherInfo(Dingdanxiang info){
if (null != info){
Dingdan dingdan= dingdanMapper.selectByPrimaryKey(info.getDingdanid());
info.setDingdan(dingdan);
Shangpin shangpin= shangpinMapper.selectByPrimaryKey(info.getShangpinid());
info.setShangpin(shangpin);
Users users= usersMapper.selectByPrimaryKey(info.getUsersid());
info.setUsers(users);
}
}
//字符类型模糊查询条件构造器
private DingdanxiangExample getDingdanxiangExampleByLike(Dingdanxiang instance) {
DingdanxiangExample dingdanxiangExample = new DingdanxiangExample();
DingdanxiangExample.Criteria criteria = dingdanxiangExample.createCriteria();
//订单项id完全匹配
if (null != instance.getId()) {
criteria.andIdEqualTo(instance.getId());
}
//订单iddingdanid完全匹配
if (null != instance.getDingdanid()) {
criteria.andDingdanidEqualTo(instance.getDingdanid());
}
//商品idshangpinid完全匹配
if (null != instance.getShangpinid()) {
criteria.andShangpinidEqualTo(instance.getShangpinid());
}
//商品数量goumaishuliang完全匹配
if (null != instance.getGoumaishuliang()) {
criteria.andGoumaishuliangEqualTo(instance.getGoumaishuliang());
}
//用户idusersid完全匹配
if (null != instance.getUsersid()) {
criteria.andUsersidEqualTo(instance.getUsersid());
}
return dingdanxiangExample;
}
//字符类型完全相等查询条件构造器
private DingdanxiangExample getDingdanxiangExampleByEqualTo(Dingdanxiang instance) {
DingdanxiangExample dingdanxiangExample = new DingdanxiangExample();
DingdanxiangExample.Criteria criteria = dingdanxiangExample.createCriteria();
//订单项id完全匹配
if (null != instance.getId()) {
criteria.andIdEqualTo(instance.getId());
}
//订单iddingdanid完全匹配
if (null != instance.getDingdanid()) {
criteria.andDingdanidEqualTo(instance.getDingdanid());
}
//商品idshangpinid完全匹配
if (null != instance.getShangpinid()) {
criteria.andShangpinidEqualTo(instance.getShangpinid());
}
//商品数量goumaishuliang完全匹配
if (null != instance.getGoumaishuliang()) {
criteria.andGoumaishuliangEqualTo(instance.getGoumaishuliang());
}
//用户idusersid完全匹配
if (null != instance.getUsersid()) {
criteria.andUsersidEqualTo(instance.getUsersid());
}
return dingdanxiangExample;
}
}

@ -1,188 +0,0 @@
package com.service.impl;
import com.dao.*;
import com.entity.*;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.service.*;
import com.util.ExampleBuilder;
import com.util.PageData;
import com.util.PageWrap;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* @ClassName DxServiceImpl
* @Description
*/
@Service
public class DxServiceImpl implements DxService {
@Autowired
private DxMapper dxMapper;
//保存或更新信息介绍表dx
@Override
public Integer saveOrUpdate(Dx instance) {
if(null != instance.getId() && instance.getId() > 0) {
dxMapper.updateByPrimaryKeySelective(instance);
}else {
dxMapper.insertSelective(instance);
}
return instance.getId();
}
//查询信息介绍表dx
@Override
public List<Dx> findAll() {
List<Dx> list = dxMapper.selectByExample(null);
for (Dx info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型模糊匹配)查询信息介绍表dx
@Override
public List<Dx> find(Dx instance) {
DxExample dxExample = getDxExampleByLike(instance);
dxExample.setOrderByClause(" id desc");
List<Dx> list = dxMapper.selectByExample(dxExample);
for (Dx info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型完全匹配)查询信息介绍表dx
@Override
public List<Dx> findByEqualTo(Dx instance) {
DxExample dxExample = getDxExampleByEqualTo(instance);
dxExample.setOrderByClause(" id desc");
List<Dx> list = dxMapper.selectByExample(dxExample);
for (Dx info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型模糊匹配)查询信息介绍表dx最后一条数据
@Override
public Dx findOne(Dx instance) {
List<Dx> list = find(instance);
if (list.size() > 0) {
return list.get(0);
}
return null;
}
//根据条件(字符类型完全匹配)查询信息介绍表dx最后一条数据
@Override
public Dx findOneByEqualTo(Dx instance) {
List<Dx> list = findByEqualTo(instance);
if (list.size() > 0) {
return list.get(0);
}
return null;
}
//根据id列查询信息介绍表dx数据
@Override
public Dx findById(Integer id) {
Dx info = dxMapper.selectByPrimaryKey(id);
setFatherInfo(info);
return info;
}
//根据主键id列删除信息介绍表dx数据
@Override
public int deleteById(Integer id) {
return dxMapper.deleteByPrimaryKey(id);
}
//根据条件(字符类型模糊匹配)分页查询信息介绍表dx数据
@Override
public PageData<Dx> findPage(PageWrap<Dx> pageWrap) {
PageHelper.startPage(pageWrap.getPageNum(), pageWrap.getPageSize());
DxExample dxExample = getDxExampleByLike(pageWrap.getModel());
dxExample.setOrderByClause(pageWrap.getOrderByClause());
List<Dx> list = dxMapper.selectByExample(dxExample);
for (Dx info:list) {
setFatherInfo(info);
}
return PageData.from(new PageInfo<>(list));
}
//根据条件(字符类型完全匹配)分页查询信息介绍表dx数据
@Override
public PageData<Dx> findPageByEqualTo(PageWrap<Dx> pageWrap) {
PageHelper.startPage(pageWrap.getPageNum(), pageWrap.getPageSize());
DxExample dxExample = getDxExampleByEqualTo(pageWrap.getModel());
dxExample.setOrderByClause(pageWrap.getOrderByClause());
List<Dx> list = dxMapper.selectByExample(dxExample);
for (Dx info:list) {
setFatherInfo(info);
}
return PageData.from(new PageInfo<>(list));
}
//父表信息
private void setFatherInfo(Dx info){
if (null != info){
}
}
//字符类型模糊查询条件构造器
private DxExample getDxExampleByLike(Dx instance) {
DxExample dxExample = new DxExample();
DxExample.Criteria criteria = dxExample.createCriteria();
//信息介绍id完全匹配
if (null != instance.getId()) {
criteria.andIdEqualTo(instance.getId());
}
//类别leibie模糊匹配
if (null != instance.getLeibie() && !instance.getLeibie().equals("")) {
criteria.andLeibieLike("%" + instance.getLeibie() + "%");
}
//内容content模糊匹配
if (null != instance.getContent() && !instance.getContent().equals("")) {
criteria.andContentLike("%" + instance.getContent() + "%");
}
//时间addtime模糊匹配
if (null != instance.getAddtime() && !instance.getAddtime().equals("")) {
criteria.andAddtimeLike("%" + instance.getAddtime() + "%");
}
return dxExample;
}
//字符类型完全相等查询条件构造器
private DxExample getDxExampleByEqualTo(Dx instance) {
DxExample dxExample = new DxExample();
DxExample.Criteria criteria = dxExample.createCriteria();
//信息介绍id完全匹配
if (null != instance.getId()) {
criteria.andIdEqualTo(instance.getId());
}
//类别leibie完全匹配
if (null != instance.getLeibie() && !instance.getLeibie().equals("")) {
criteria.andLeibieEqualTo(instance.getLeibie());
}
//内容content完全匹配
if (null != instance.getContent() && !instance.getContent().equals("")) {
criteria.andContentEqualTo(instance.getContent());
}
//时间addtime完全匹配
if (null != instance.getAddtime() && !instance.getAddtime().equals("")) {
criteria.andAddtimeEqualTo(instance.getAddtime());
}
return dxExample;
}
}

@ -1,196 +0,0 @@
package com.service.impl;
import com.dao.*;
import com.entity.*;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.service.*;
import com.util.ExampleBuilder;
import com.util.PageData;
import com.util.PageWrap;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* @ClassName GonggaoServiceImpl
* @Description
*/
@Service
public class GonggaoServiceImpl implements GonggaoService {
@Autowired
private GonggaoMapper gonggaoMapper;
//保存或更新公告表gonggao
@Override
public Integer saveOrUpdate(Gonggao instance) {
if(null != instance.getId() && instance.getId() > 0) {
gonggaoMapper.updateByPrimaryKeySelective(instance);
}else {
gonggaoMapper.insertSelective(instance);
}
return instance.getId();
}
//查询公告表gonggao
@Override
public List<Gonggao> findAll() {
List<Gonggao> list = gonggaoMapper.selectByExample(null);
for (Gonggao info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型模糊匹配)查询公告表gonggao
@Override
public List<Gonggao> find(Gonggao instance) {
GonggaoExample gonggaoExample = getGonggaoExampleByLike(instance);
gonggaoExample.setOrderByClause(" id desc");
List<Gonggao> list = gonggaoMapper.selectByExample(gonggaoExample);
for (Gonggao info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型完全匹配)查询公告表gonggao
@Override
public List<Gonggao> findByEqualTo(Gonggao instance) {
GonggaoExample gonggaoExample = getGonggaoExampleByEqualTo(instance);
gonggaoExample.setOrderByClause(" id desc");
List<Gonggao> list = gonggaoMapper.selectByExample(gonggaoExample);
for (Gonggao info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型模糊匹配)查询公告表gonggao最后一条数据
@Override
public Gonggao findOne(Gonggao instance) {
List<Gonggao> list = find(instance);
if (list.size() > 0) {
return list.get(0);
}
return null;
}
//根据条件(字符类型完全匹配)查询公告表gonggao最后一条数据
@Override
public Gonggao findOneByEqualTo(Gonggao instance) {
List<Gonggao> list = findByEqualTo(instance);
if (list.size() > 0) {
return list.get(0);
}
return null;
}
//根据id列查询公告表gonggao数据
@Override
public Gonggao findById(Integer id) {
Gonggao info = gonggaoMapper.selectByPrimaryKey(id);
setFatherInfo(info);
return info;
}
//根据主键id列删除公告表gonggao数据
@Override
public int deleteById(Integer id) {
return gonggaoMapper.deleteByPrimaryKey(id);
}
//根据条件(字符类型模糊匹配)分页查询公告表gonggao数据
@Override
public PageData<Gonggao> findPage(PageWrap<Gonggao> pageWrap) {
PageHelper.startPage(pageWrap.getPageNum(), pageWrap.getPageSize());
GonggaoExample gonggaoExample = getGonggaoExampleByLike(pageWrap.getModel());
gonggaoExample.setOrderByClause(pageWrap.getOrderByClause());
List<Gonggao> list = gonggaoMapper.selectByExample(gonggaoExample);
for (Gonggao info:list) {
setFatherInfo(info);
}
return PageData.from(new PageInfo<>(list));
}
//根据条件(字符类型完全匹配)分页查询公告表gonggao数据
@Override
public PageData<Gonggao> findPageByEqualTo(PageWrap<Gonggao> pageWrap) {
PageHelper.startPage(pageWrap.getPageNum(), pageWrap.getPageSize());
GonggaoExample gonggaoExample = getGonggaoExampleByEqualTo(pageWrap.getModel());
gonggaoExample.setOrderByClause(pageWrap.getOrderByClause());
List<Gonggao> list = gonggaoMapper.selectByExample(gonggaoExample);
for (Gonggao info:list) {
setFatherInfo(info);
}
return PageData.from(new PageInfo<>(list));
}
//父表信息
private void setFatherInfo(Gonggao info){
if (null != info){
}
}
//字符类型模糊查询条件构造器
private GonggaoExample getGonggaoExampleByLike(Gonggao instance) {
GonggaoExample gonggaoExample = new GonggaoExample();
GonggaoExample.Criteria criteria = gonggaoExample.createCriteria();
//公告id完全匹配
if (null != instance.getId()) {
criteria.andIdEqualTo(instance.getId());
}
//标题biaoti模糊匹配
if (null != instance.getBiaoti() && !instance.getBiaoti().equals("")) {
criteria.andBiaotiLike("%" + instance.getBiaoti() + "%");
}
//内容neirong模糊匹配
if (null != instance.getNeirong() && !instance.getNeirong().equals("")) {
criteria.andNeirongLike("%" + instance.getNeirong() + "%");
}
//图片tupian模糊匹配
if (null != instance.getTupian() && !instance.getTupian().equals("")) {
criteria.andTupianLike("%" + instance.getTupian() + "%");
}
//时间shijian模糊匹配
if (null != instance.getShijian() && !instance.getShijian().equals("")) {
criteria.andShijianLike("%" + instance.getShijian() + "%");
}
return gonggaoExample;
}
//字符类型完全相等查询条件构造器
private GonggaoExample getGonggaoExampleByEqualTo(Gonggao instance) {
GonggaoExample gonggaoExample = new GonggaoExample();
GonggaoExample.Criteria criteria = gonggaoExample.createCriteria();
//公告id完全匹配
if (null != instance.getId()) {
criteria.andIdEqualTo(instance.getId());
}
//标题biaoti完全匹配
if (null != instance.getBiaoti() && !instance.getBiaoti().equals("")) {
criteria.andBiaotiEqualTo(instance.getBiaoti());
}
//内容neirong完全匹配
if (null != instance.getNeirong() && !instance.getNeirong().equals("")) {
criteria.andNeirongEqualTo(instance.getNeirong());
}
//图片tupian完全匹配
if (null != instance.getTupian() && !instance.getTupian().equals("")) {
criteria.andTupianEqualTo(instance.getTupian());
}
//时间shijian完全匹配
if (null != instance.getShijian() && !instance.getShijian().equals("")) {
criteria.andShijianEqualTo(instance.getShijian());
}
return gonggaoExample;
}
}

@ -1,196 +0,0 @@
package com.service.impl;
import com.dao.*;
import com.entity.*;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.service.*;
import com.util.ExampleBuilder;
import com.util.PageData;
import com.util.PageWrap;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* @ClassName GouwucheServiceImpl
* @Description
*/
@Service
public class GouwucheServiceImpl implements GouwucheService {
@Autowired
private GouwucheMapper gouwucheMapper;
@Autowired
private ShangpinMapper shangpinMapper;
@Autowired
private UsersMapper usersMapper;
//保存或更新购物车表gouwuche
@Override
public Integer saveOrUpdate(Gouwuche instance) {
if(null != instance.getId() && instance.getId() > 0) {
gouwucheMapper.updateByPrimaryKeySelective(instance);
}else {
gouwucheMapper.insertSelective(instance);
}
return instance.getId();
}
//查询购物车表gouwuche
@Override
public List<Gouwuche> findAll() {
List<Gouwuche> list = gouwucheMapper.selectByExample(null);
for (Gouwuche info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型模糊匹配)查询购物车表gouwuche
@Override
public List<Gouwuche> find(Gouwuche instance) {
GouwucheExample gouwucheExample = getGouwucheExampleByLike(instance);
gouwucheExample.setOrderByClause(" id desc");
List<Gouwuche> list = gouwucheMapper.selectByExample(gouwucheExample);
for (Gouwuche info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型完全匹配)查询购物车表gouwuche
@Override
public List<Gouwuche> findByEqualTo(Gouwuche instance) {
GouwucheExample gouwucheExample = getGouwucheExampleByEqualTo(instance);
gouwucheExample.setOrderByClause(" id desc");
List<Gouwuche> list = gouwucheMapper.selectByExample(gouwucheExample);
for (Gouwuche info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型模糊匹配)查询购物车表gouwuche最后一条数据
@Override
public Gouwuche findOne(Gouwuche instance) {
List<Gouwuche> list = find(instance);
if (list.size() > 0) {
return list.get(0);
}
return null;
}
//根据条件(字符类型完全匹配)查询购物车表gouwuche最后一条数据
@Override
public Gouwuche findOneByEqualTo(Gouwuche instance) {
List<Gouwuche> list = findByEqualTo(instance);
if (list.size() > 0) {
return list.get(0);
}
return null;
}
//根据id列查询购物车表gouwuche数据
@Override
public Gouwuche findById(Integer id) {
Gouwuche info = gouwucheMapper.selectByPrimaryKey(id);
setFatherInfo(info);
return info;
}
//根据主键id列删除购物车表gouwuche数据
@Override
public int deleteById(Integer id) {
return gouwucheMapper.deleteByPrimaryKey(id);
}
//根据条件(字符类型模糊匹配)分页查询购物车表gouwuche数据
@Override
public PageData<Gouwuche> findPage(PageWrap<Gouwuche> pageWrap) {
PageHelper.startPage(pageWrap.getPageNum(), pageWrap.getPageSize());
GouwucheExample gouwucheExample = getGouwucheExampleByLike(pageWrap.getModel());
gouwucheExample.setOrderByClause(pageWrap.getOrderByClause());
List<Gouwuche> list = gouwucheMapper.selectByExample(gouwucheExample);
for (Gouwuche info:list) {
setFatherInfo(info);
}
return PageData.from(new PageInfo<>(list));
}
//根据条件(字符类型完全匹配)分页查询购物车表gouwuche数据
@Override
public PageData<Gouwuche> findPageByEqualTo(PageWrap<Gouwuche> pageWrap) {
PageHelper.startPage(pageWrap.getPageNum(), pageWrap.getPageSize());
GouwucheExample gouwucheExample = getGouwucheExampleByEqualTo(pageWrap.getModel());
gouwucheExample.setOrderByClause(pageWrap.getOrderByClause());
List<Gouwuche> list = gouwucheMapper.selectByExample(gouwucheExample);
for (Gouwuche info:list) {
setFatherInfo(info);
}
return PageData.from(new PageInfo<>(list));
}
//父表信息
private void setFatherInfo(Gouwuche info){
if (null != info){
Shangpin shangpin= shangpinMapper.selectByPrimaryKey(info.getShangpinid());
info.setShangpin(shangpin);
Users users= usersMapper.selectByPrimaryKey(info.getUsersid());
info.setUsers(users);
}
}
//字符类型模糊查询条件构造器
private GouwucheExample getGouwucheExampleByLike(Gouwuche instance) {
GouwucheExample gouwucheExample = new GouwucheExample();
GouwucheExample.Criteria criteria = gouwucheExample.createCriteria();
//购物车id完全匹配
if (null != instance.getId()) {
criteria.andIdEqualTo(instance.getId());
}
//商品idshangpinid完全匹配
if (null != instance.getShangpinid()) {
criteria.andShangpinidEqualTo(instance.getShangpinid());
}
//商品数量goumaishuliang完全匹配
if (null != instance.getGoumaishuliang()) {
criteria.andGoumaishuliangEqualTo(instance.getGoumaishuliang());
}
//用户idusersid完全匹配
if (null != instance.getUsersid()) {
criteria.andUsersidEqualTo(instance.getUsersid());
}
return gouwucheExample;
}
//字符类型完全相等查询条件构造器
private GouwucheExample getGouwucheExampleByEqualTo(Gouwuche instance) {
GouwucheExample gouwucheExample = new GouwucheExample();
GouwucheExample.Criteria criteria = gouwucheExample.createCriteria();
//购物车id完全匹配
if (null != instance.getId()) {
criteria.andIdEqualTo(instance.getId());
}
//商品idshangpinid完全匹配
if (null != instance.getShangpinid()) {
criteria.andShangpinidEqualTo(instance.getShangpinid());
}
//商品数量goumaishuliang完全匹配
if (null != instance.getGoumaishuliang()) {
criteria.andGoumaishuliangEqualTo(instance.getGoumaishuliang());
}
//用户idusersid完全匹配
if (null != instance.getUsersid()) {
criteria.andUsersidEqualTo(instance.getUsersid());
}
return gouwucheExample;
}
}

@ -1,180 +0,0 @@
package com.service.impl;
import com.dao.*;
import com.entity.*;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.service.*;
import com.util.ExampleBuilder;
import com.util.PageData;
import com.util.PageWrap;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* @ClassName LianjieServiceImpl
* @Description
*/
@Service
public class LianjieServiceImpl implements LianjieService {
@Autowired
private LianjieMapper lianjieMapper;
//保存或更新友情链接表lianjie
@Override
public Integer saveOrUpdate(Lianjie instance) {
if(null != instance.getId() && instance.getId() > 0) {
lianjieMapper.updateByPrimaryKeySelective(instance);
}else {
lianjieMapper.insertSelective(instance);
}
return instance.getId();
}
//查询友情链接表lianjie
@Override
public List<Lianjie> findAll() {
List<Lianjie> list = lianjieMapper.selectByExample(null);
for (Lianjie info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型模糊匹配)查询友情链接表lianjie
@Override
public List<Lianjie> find(Lianjie instance) {
LianjieExample lianjieExample = getLianjieExampleByLike(instance);
lianjieExample.setOrderByClause(" id desc");
List<Lianjie> list = lianjieMapper.selectByExample(lianjieExample);
for (Lianjie info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型完全匹配)查询友情链接表lianjie
@Override
public List<Lianjie> findByEqualTo(Lianjie instance) {
LianjieExample lianjieExample = getLianjieExampleByEqualTo(instance);
lianjieExample.setOrderByClause(" id desc");
List<Lianjie> list = lianjieMapper.selectByExample(lianjieExample);
for (Lianjie info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型模糊匹配)查询友情链接表lianjie最后一条数据
@Override
public Lianjie findOne(Lianjie instance) {
List<Lianjie> list = find(instance);
if (list.size() > 0) {
return list.get(0);
}
return null;
}
//根据条件(字符类型完全匹配)查询友情链接表lianjie最后一条数据
@Override
public Lianjie findOneByEqualTo(Lianjie instance) {
List<Lianjie> list = findByEqualTo(instance);
if (list.size() > 0) {
return list.get(0);
}
return null;
}
//根据id列查询友情链接表lianjie数据
@Override
public Lianjie findById(Integer id) {
Lianjie info = lianjieMapper.selectByPrimaryKey(id);
setFatherInfo(info);
return info;
}
//根据主键id列删除友情链接表lianjie数据
@Override
public int deleteById(Integer id) {
return lianjieMapper.deleteByPrimaryKey(id);
}
//根据条件(字符类型模糊匹配)分页查询友情链接表lianjie数据
@Override
public PageData<Lianjie> findPage(PageWrap<Lianjie> pageWrap) {
PageHelper.startPage(pageWrap.getPageNum(), pageWrap.getPageSize());
LianjieExample lianjieExample = getLianjieExampleByLike(pageWrap.getModel());
lianjieExample.setOrderByClause(pageWrap.getOrderByClause());
List<Lianjie> list = lianjieMapper.selectByExample(lianjieExample);
for (Lianjie info:list) {
setFatherInfo(info);
}
return PageData.from(new PageInfo<>(list));
}
//根据条件(字符类型完全匹配)分页查询友情链接表lianjie数据
@Override
public PageData<Lianjie> findPageByEqualTo(PageWrap<Lianjie> pageWrap) {
PageHelper.startPage(pageWrap.getPageNum(), pageWrap.getPageSize());
LianjieExample lianjieExample = getLianjieExampleByEqualTo(pageWrap.getModel());
lianjieExample.setOrderByClause(pageWrap.getOrderByClause());
List<Lianjie> list = lianjieMapper.selectByExample(lianjieExample);
for (Lianjie info:list) {
setFatherInfo(info);
}
return PageData.from(new PageInfo<>(list));
}
//父表信息
private void setFatherInfo(Lianjie info){
if (null != info){
}
}
//字符类型模糊查询条件构造器
private LianjieExample getLianjieExampleByLike(Lianjie instance) {
LianjieExample lianjieExample = new LianjieExample();
LianjieExample.Criteria criteria = lianjieExample.createCriteria();
//友情链接id完全匹配
if (null != instance.getId()) {
criteria.andIdEqualTo(instance.getId());
}
//名称name模糊匹配
if (null != instance.getName() && !instance.getName().equals("")) {
criteria.andNameLike("%" + instance.getName() + "%");
}
//链接地址url模糊匹配
if (null != instance.getUrl() && !instance.getUrl().equals("")) {
criteria.andUrlLike("%" + instance.getUrl() + "%");
}
return lianjieExample;
}
//字符类型完全相等查询条件构造器
private LianjieExample getLianjieExampleByEqualTo(Lianjie instance) {
LianjieExample lianjieExample = new LianjieExample();
LianjieExample.Criteria criteria = lianjieExample.createCriteria();
//友情链接id完全匹配
if (null != instance.getId()) {
criteria.andIdEqualTo(instance.getId());
}
//名称name完全匹配
if (null != instance.getName() && !instance.getName().equals("")) {
criteria.andNameEqualTo(instance.getName());
}
//链接地址url完全匹配
if (null != instance.getUrl() && !instance.getUrl().equals("")) {
criteria.andUrlEqualTo(instance.getUrl());
}
return lianjieExample;
}
}

@ -1,208 +0,0 @@
package com.service.impl;
import com.dao.*;
import com.entity.*;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.service.*;
import com.util.ExampleBuilder;
import com.util.PageData;
import com.util.PageWrap;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* @ClassName LiuyanServiceImpl
* @Description
*/
@Service
public class LiuyanServiceImpl implements LiuyanService {
@Autowired
private LiuyanMapper liuyanMapper;
@Autowired
private UsersMapper usersMapper;
//保存或更新留言反馈表liuyan
@Override
public Integer saveOrUpdate(Liuyan instance) {
if(null != instance.getId() && instance.getId() > 0) {
liuyanMapper.updateByPrimaryKeySelective(instance);
}else {
liuyanMapper.insertSelective(instance);
}
return instance.getId();
}
//查询留言反馈表liuyan
@Override
public List<Liuyan> findAll() {
List<Liuyan> list = liuyanMapper.selectByExample(null);
for (Liuyan info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型模糊匹配)查询留言反馈表liuyan
@Override
public List<Liuyan> find(Liuyan instance) {
LiuyanExample liuyanExample = getLiuyanExampleByLike(instance);
liuyanExample.setOrderByClause(" id desc");
List<Liuyan> list = liuyanMapper.selectByExample(liuyanExample);
for (Liuyan info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型完全匹配)查询留言反馈表liuyan
@Override
public List<Liuyan> findByEqualTo(Liuyan instance) {
LiuyanExample liuyanExample = getLiuyanExampleByEqualTo(instance);
liuyanExample.setOrderByClause(" id desc");
List<Liuyan> list = liuyanMapper.selectByExample(liuyanExample);
for (Liuyan info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型模糊匹配)查询留言反馈表liuyan最后一条数据
@Override
public Liuyan findOne(Liuyan instance) {
List<Liuyan> list = find(instance);
if (list.size() > 0) {
return list.get(0);
}
return null;
}
//根据条件(字符类型完全匹配)查询留言反馈表liuyan最后一条数据
@Override
public Liuyan findOneByEqualTo(Liuyan instance) {
List<Liuyan> list = findByEqualTo(instance);
if (list.size() > 0) {
return list.get(0);
}
return null;
}
//根据id列查询留言反馈表liuyan数据
@Override
public Liuyan findById(Integer id) {
Liuyan info = liuyanMapper.selectByPrimaryKey(id);
setFatherInfo(info);
return info;
}
//根据主键id列删除留言反馈表liuyan数据
@Override
public int deleteById(Integer id) {
return liuyanMapper.deleteByPrimaryKey(id);
}
//根据条件(字符类型模糊匹配)分页查询留言反馈表liuyan数据
@Override
public PageData<Liuyan> findPage(PageWrap<Liuyan> pageWrap) {
PageHelper.startPage(pageWrap.getPageNum(), pageWrap.getPageSize());
LiuyanExample liuyanExample = getLiuyanExampleByLike(pageWrap.getModel());
liuyanExample.setOrderByClause(pageWrap.getOrderByClause());
List<Liuyan> list = liuyanMapper.selectByExample(liuyanExample);
for (Liuyan info:list) {
setFatherInfo(info);
}
return PageData.from(new PageInfo<>(list));
}
//根据条件(字符类型完全匹配)分页查询留言反馈表liuyan数据
@Override
public PageData<Liuyan> findPageByEqualTo(PageWrap<Liuyan> pageWrap) {
PageHelper.startPage(pageWrap.getPageNum(), pageWrap.getPageSize());
LiuyanExample liuyanExample = getLiuyanExampleByEqualTo(pageWrap.getModel());
liuyanExample.setOrderByClause(pageWrap.getOrderByClause());
List<Liuyan> list = liuyanMapper.selectByExample(liuyanExample);
for (Liuyan info:list) {
setFatherInfo(info);
}
return PageData.from(new PageInfo<>(list));
}
//父表信息
private void setFatherInfo(Liuyan info){
if (null != info){
Users users= usersMapper.selectByPrimaryKey(info.getUsersid());
info.setUsers(users);
}
}
//字符类型模糊查询条件构造器
private LiuyanExample getLiuyanExampleByLike(Liuyan instance) {
LiuyanExample liuyanExample = new LiuyanExample();
LiuyanExample.Criteria criteria = liuyanExample.createCriteria();
//留言反馈id完全匹配
if (null != instance.getId()) {
criteria.andIdEqualTo(instance.getId());
}
//标题biaoti模糊匹配
if (null != instance.getBiaoti() && !instance.getBiaoti().equals("")) {
criteria.andBiaotiLike("%" + instance.getBiaoti() + "%");
}
//内容neirong模糊匹配
if (null != instance.getNeirong() && !instance.getNeirong().equals("")) {
criteria.andNeirongLike("%" + instance.getNeirong() + "%");
}
//留言添加时间addshijian模糊匹配
if (null != instance.getAddshijian() && !instance.getAddshijian().equals("")) {
criteria.andAddshijianLike("%" + instance.getAddshijian() + "%");
}
//用户idusersid完全匹配
if (null != instance.getUsersid()) {
criteria.andUsersidEqualTo(instance.getUsersid());
}
//回复huifu模糊匹配
if (null != instance.getHuifu() && !instance.getHuifu().equals("")) {
criteria.andHuifuLike("%" + instance.getHuifu() + "%");
}
return liuyanExample;
}
//字符类型完全相等查询条件构造器
private LiuyanExample getLiuyanExampleByEqualTo(Liuyan instance) {
LiuyanExample liuyanExample = new LiuyanExample();
LiuyanExample.Criteria criteria = liuyanExample.createCriteria();
//留言反馈id完全匹配
if (null != instance.getId()) {
criteria.andIdEqualTo(instance.getId());
}
//标题biaoti完全匹配
if (null != instance.getBiaoti() && !instance.getBiaoti().equals("")) {
criteria.andBiaotiEqualTo(instance.getBiaoti());
}
//内容neirong完全匹配
if (null != instance.getNeirong() && !instance.getNeirong().equals("")) {
criteria.andNeirongEqualTo(instance.getNeirong());
}
//留言添加时间addshijian完全匹配
if (null != instance.getAddshijian() && !instance.getAddshijian().equals("")) {
criteria.andAddshijianEqualTo(instance.getAddshijian());
}
//用户idusersid完全匹配
if (null != instance.getUsersid()) {
criteria.andUsersidEqualTo(instance.getUsersid());
}
//回复huifu完全匹配
if (null != instance.getHuifu() && !instance.getHuifu().equals("")) {
criteria.andHuifuEqualTo(instance.getHuifu());
}
return liuyanExample;
}
}

@ -1,180 +0,0 @@
package com.service.impl;
import com.dao.*;
import com.entity.*;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.service.*;
import com.util.ExampleBuilder;
import com.util.PageData;
import com.util.PageWrap;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* @ClassName LunboServiceImpl
* @Description
*/
@Service
public class LunboServiceImpl implements LunboService {
@Autowired
private LunboMapper lunboMapper;
//保存或更新轮播图表lunbo
@Override
public Integer saveOrUpdate(Lunbo instance) {
if(null != instance.getId() && instance.getId() > 0) {
lunboMapper.updateByPrimaryKeySelective(instance);
}else {
lunboMapper.insertSelective(instance);
}
return instance.getId();
}
//查询轮播图表lunbo
@Override
public List<Lunbo> findAll() {
List<Lunbo> list = lunboMapper.selectByExample(null);
for (Lunbo info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型模糊匹配)查询轮播图表lunbo
@Override
public List<Lunbo> find(Lunbo instance) {
LunboExample lunboExample = getLunboExampleByLike(instance);
lunboExample.setOrderByClause(" id desc");
List<Lunbo> list = lunboMapper.selectByExample(lunboExample);
for (Lunbo info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型完全匹配)查询轮播图表lunbo
@Override
public List<Lunbo> findByEqualTo(Lunbo instance) {
LunboExample lunboExample = getLunboExampleByEqualTo(instance);
lunboExample.setOrderByClause(" id desc");
List<Lunbo> list = lunboMapper.selectByExample(lunboExample);
for (Lunbo info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型模糊匹配)查询轮播图表lunbo最后一条数据
@Override
public Lunbo findOne(Lunbo instance) {
List<Lunbo> list = find(instance);
if (list.size() > 0) {
return list.get(0);
}
return null;
}
//根据条件(字符类型完全匹配)查询轮播图表lunbo最后一条数据
@Override
public Lunbo findOneByEqualTo(Lunbo instance) {
List<Lunbo> list = findByEqualTo(instance);
if (list.size() > 0) {
return list.get(0);
}
return null;
}
//根据id列查询轮播图表lunbo数据
@Override
public Lunbo findById(Integer id) {
Lunbo info = lunboMapper.selectByPrimaryKey(id);
setFatherInfo(info);
return info;
}
//根据主键id列删除轮播图表lunbo数据
@Override
public int deleteById(Integer id) {
return lunboMapper.deleteByPrimaryKey(id);
}
//根据条件(字符类型模糊匹配)分页查询轮播图表lunbo数据
@Override
public PageData<Lunbo> findPage(PageWrap<Lunbo> pageWrap) {
PageHelper.startPage(pageWrap.getPageNum(), pageWrap.getPageSize());
LunboExample lunboExample = getLunboExampleByLike(pageWrap.getModel());
lunboExample.setOrderByClause(pageWrap.getOrderByClause());
List<Lunbo> list = lunboMapper.selectByExample(lunboExample);
for (Lunbo info:list) {
setFatherInfo(info);
}
return PageData.from(new PageInfo<>(list));
}
//根据条件(字符类型完全匹配)分页查询轮播图表lunbo数据
@Override
public PageData<Lunbo> findPageByEqualTo(PageWrap<Lunbo> pageWrap) {
PageHelper.startPage(pageWrap.getPageNum(), pageWrap.getPageSize());
LunboExample lunboExample = getLunboExampleByEqualTo(pageWrap.getModel());
lunboExample.setOrderByClause(pageWrap.getOrderByClause());
List<Lunbo> list = lunboMapper.selectByExample(lunboExample);
for (Lunbo info:list) {
setFatherInfo(info);
}
return PageData.from(new PageInfo<>(list));
}
//父表信息
private void setFatherInfo(Lunbo info){
if (null != info){
}
}
//字符类型模糊查询条件构造器
private LunboExample getLunboExampleByLike(Lunbo instance) {
LunboExample lunboExample = new LunboExample();
LunboExample.Criteria criteria = lunboExample.createCriteria();
//轮播图id完全匹配
if (null != instance.getId()) {
criteria.andIdEqualTo(instance.getId());
}
//标题biaoti模糊匹配
if (null != instance.getBiaoti() && !instance.getBiaoti().equals("")) {
criteria.andBiaotiLike("%" + instance.getBiaoti() + "%");
}
//图片image模糊匹配
if (null != instance.getImage() && !instance.getImage().equals("")) {
criteria.andImageLike("%" + instance.getImage() + "%");
}
return lunboExample;
}
//字符类型完全相等查询条件构造器
private LunboExample getLunboExampleByEqualTo(Lunbo instance) {
LunboExample lunboExample = new LunboExample();
LunboExample.Criteria criteria = lunboExample.createCriteria();
//轮播图id完全匹配
if (null != instance.getId()) {
criteria.andIdEqualTo(instance.getId());
}
//标题biaoti完全匹配
if (null != instance.getBiaoti() && !instance.getBiaoti().equals("")) {
criteria.andBiaotiEqualTo(instance.getBiaoti());
}
//图片image完全匹配
if (null != instance.getImage() && !instance.getImage().equals("")) {
criteria.andImageEqualTo(instance.getImage());
}
return lunboExample;
}
}

@ -1,212 +0,0 @@
package com.service.impl;
import com.dao.*;
import com.entity.*;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.service.*;
import com.util.ExampleBuilder;
import com.util.PageData;
import com.util.PageWrap;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* @ClassName PingjiaServiceImpl
* @Description
*/
@Service
public class PingjiaServiceImpl implements PingjiaService {
@Autowired
private PingjiaMapper pingjiaMapper;
@Autowired
private ShangpinMapper shangpinMapper;
@Autowired
private UsersMapper usersMapper;
//保存或更新评论表pingjia
@Override
public Integer saveOrUpdate(Pingjia instance) {
if(null != instance.getId() && instance.getId() > 0) {
pingjiaMapper.updateByPrimaryKeySelective(instance);
}else {
pingjiaMapper.insertSelective(instance);
}
return instance.getId();
}
//查询评论表pingjia
@Override
public List<Pingjia> findAll() {
List<Pingjia> list = pingjiaMapper.selectByExample(null);
for (Pingjia info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型模糊匹配)查询评论表pingjia
@Override
public List<Pingjia> find(Pingjia instance) {
PingjiaExample pingjiaExample = getPingjiaExampleByLike(instance);
pingjiaExample.setOrderByClause(" id desc");
List<Pingjia> list = pingjiaMapper.selectByExample(pingjiaExample);
for (Pingjia info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型完全匹配)查询评论表pingjia
@Override
public List<Pingjia> findByEqualTo(Pingjia instance) {
PingjiaExample pingjiaExample = getPingjiaExampleByEqualTo(instance);
pingjiaExample.setOrderByClause(" id desc");
List<Pingjia> list = pingjiaMapper.selectByExample(pingjiaExample);
for (Pingjia info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型模糊匹配)查询评论表pingjia最后一条数据
@Override
public Pingjia findOne(Pingjia instance) {
List<Pingjia> list = find(instance);
if (list.size() > 0) {
return list.get(0);
}
return null;
}
//根据条件(字符类型完全匹配)查询评论表pingjia最后一条数据
@Override
public Pingjia findOneByEqualTo(Pingjia instance) {
List<Pingjia> list = findByEqualTo(instance);
if (list.size() > 0) {
return list.get(0);
}
return null;
}
//根据id列查询评论表pingjia数据
@Override
public Pingjia findById(Integer id) {
Pingjia info = pingjiaMapper.selectByPrimaryKey(id);
setFatherInfo(info);
return info;
}
//根据主键id列删除评论表pingjia数据
@Override
public int deleteById(Integer id) {
return pingjiaMapper.deleteByPrimaryKey(id);
}
//根据条件(字符类型模糊匹配)分页查询评论表pingjia数据
@Override
public PageData<Pingjia> findPage(PageWrap<Pingjia> pageWrap) {
PageHelper.startPage(pageWrap.getPageNum(), pageWrap.getPageSize());
PingjiaExample pingjiaExample = getPingjiaExampleByLike(pageWrap.getModel());
pingjiaExample.setOrderByClause(pageWrap.getOrderByClause());
List<Pingjia> list = pingjiaMapper.selectByExample(pingjiaExample);
for (Pingjia info:list) {
setFatherInfo(info);
}
return PageData.from(new PageInfo<>(list));
}
//根据条件(字符类型完全匹配)分页查询评论表pingjia数据
@Override
public PageData<Pingjia> findPageByEqualTo(PageWrap<Pingjia> pageWrap) {
PageHelper.startPage(pageWrap.getPageNum(), pageWrap.getPageSize());
PingjiaExample pingjiaExample = getPingjiaExampleByEqualTo(pageWrap.getModel());
pingjiaExample.setOrderByClause(pageWrap.getOrderByClause());
List<Pingjia> list = pingjiaMapper.selectByExample(pingjiaExample);
for (Pingjia info:list) {
setFatherInfo(info);
}
return PageData.from(new PageInfo<>(list));
}
//父表信息
private void setFatherInfo(Pingjia info){
if (null != info){
Shangpin shangpin= shangpinMapper.selectByPrimaryKey(info.getShangpinid());
info.setShangpin(shangpin);
Users users= usersMapper.selectByPrimaryKey(info.getUsersid());
info.setUsers(users);
}
}
//字符类型模糊查询条件构造器
private PingjiaExample getPingjiaExampleByLike(Pingjia instance) {
PingjiaExample pingjiaExample = new PingjiaExample();
PingjiaExample.Criteria criteria = pingjiaExample.createCriteria();
//评论id完全匹配
if (null != instance.getId()) {
criteria.andIdEqualTo(instance.getId());
}
//评语biaoti模糊匹配
if (null != instance.getBiaoti() && !instance.getBiaoti().equals("")) {
criteria.andBiaotiLike("%" + instance.getBiaoti() + "%");
}
//分数范围1-5fenshu模糊匹配
if (null != instance.getFenshu() && !instance.getFenshu().equals("")) {
criteria.andFenshuLike("%" + instance.getFenshu() + "%");
}
//时间shijian模糊匹配
if (null != instance.getShijian() && !instance.getShijian().equals("")) {
criteria.andShijianLike("%" + instance.getShijian() + "%");
}
//零食idshangpinid完全匹配
if (null != instance.getShangpinid()) {
criteria.andShangpinidEqualTo(instance.getShangpinid());
}
//用户idusersid完全匹配
if (null != instance.getUsersid()) {
criteria.andUsersidEqualTo(instance.getUsersid());
}
return pingjiaExample;
}
//字符类型完全相等查询条件构造器
private PingjiaExample getPingjiaExampleByEqualTo(Pingjia instance) {
PingjiaExample pingjiaExample = new PingjiaExample();
PingjiaExample.Criteria criteria = pingjiaExample.createCriteria();
//评论id完全匹配
if (null != instance.getId()) {
criteria.andIdEqualTo(instance.getId());
}
//评语biaoti完全匹配
if (null != instance.getBiaoti() && !instance.getBiaoti().equals("")) {
criteria.andBiaotiEqualTo(instance.getBiaoti());
}
//分数范围1-5fenshu完全匹配
if (null != instance.getFenshu() && !instance.getFenshu().equals("")) {
criteria.andFenshuEqualTo(instance.getFenshu());
}
//时间shijian完全匹配
if (null != instance.getShijian() && !instance.getShijian().equals("")) {
criteria.andShijianEqualTo(instance.getShijian());
}
//零食idshangpinid完全匹配
if (null != instance.getShangpinid()) {
criteria.andShangpinidEqualTo(instance.getShangpinid());
}
//用户idusersid完全匹配
if (null != instance.getUsersid()) {
criteria.andUsersidEqualTo(instance.getUsersid());
}
return pingjiaExample;
}
}

@ -1,172 +0,0 @@
package com.service.impl;
import com.dao.*;
import com.entity.*;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.service.*;
import com.util.ExampleBuilder;
import com.util.PageData;
import com.util.PageWrap;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* @ClassName PinleiServiceImpl
* @Description
*/
@Service
public class PinleiServiceImpl implements PinleiService {
@Autowired
private PinleiMapper pinleiMapper;
//保存或更新分类表pinlei
@Override
public Integer saveOrUpdate(Pinlei instance) {
if(null != instance.getId() && instance.getId() > 0) {
pinleiMapper.updateByPrimaryKeySelective(instance);
}else {
pinleiMapper.insertSelective(instance);
}
return instance.getId();
}
//查询分类表pinlei
@Override
public List<Pinlei> findAll() {
List<Pinlei> list = pinleiMapper.selectByExample(null);
for (Pinlei info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型模糊匹配)查询分类表pinlei
@Override
public List<Pinlei> find(Pinlei instance) {
PinleiExample pinleiExample = getPinleiExampleByLike(instance);
pinleiExample.setOrderByClause(" id desc");
List<Pinlei> list = pinleiMapper.selectByExample(pinleiExample);
for (Pinlei info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型完全匹配)查询分类表pinlei
@Override
public List<Pinlei> findByEqualTo(Pinlei instance) {
PinleiExample pinleiExample = getPinleiExampleByEqualTo(instance);
pinleiExample.setOrderByClause(" id desc");
List<Pinlei> list = pinleiMapper.selectByExample(pinleiExample);
for (Pinlei info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型模糊匹配)查询分类表pinlei最后一条数据
@Override
public Pinlei findOne(Pinlei instance) {
List<Pinlei> list = find(instance);
if (list.size() > 0) {
return list.get(0);
}
return null;
}
//根据条件(字符类型完全匹配)查询分类表pinlei最后一条数据
@Override
public Pinlei findOneByEqualTo(Pinlei instance) {
List<Pinlei> list = findByEqualTo(instance);
if (list.size() > 0) {
return list.get(0);
}
return null;
}
//根据id列查询分类表pinlei数据
@Override
public Pinlei findById(Integer id) {
Pinlei info = pinleiMapper.selectByPrimaryKey(id);
setFatherInfo(info);
return info;
}
//根据主键id列删除分类表pinlei数据
@Override
public int deleteById(Integer id) {
return pinleiMapper.deleteByPrimaryKey(id);
}
//根据条件(字符类型模糊匹配)分页查询分类表pinlei数据
@Override
public PageData<Pinlei> findPage(PageWrap<Pinlei> pageWrap) {
PageHelper.startPage(pageWrap.getPageNum(), pageWrap.getPageSize());
PinleiExample pinleiExample = getPinleiExampleByLike(pageWrap.getModel());
pinleiExample.setOrderByClause(pageWrap.getOrderByClause());
List<Pinlei> list = pinleiMapper.selectByExample(pinleiExample);
for (Pinlei info:list) {
setFatherInfo(info);
}
return PageData.from(new PageInfo<>(list));
}
//根据条件(字符类型完全匹配)分页查询分类表pinlei数据
@Override
public PageData<Pinlei> findPageByEqualTo(PageWrap<Pinlei> pageWrap) {
PageHelper.startPage(pageWrap.getPageNum(), pageWrap.getPageSize());
PinleiExample pinleiExample = getPinleiExampleByEqualTo(pageWrap.getModel());
pinleiExample.setOrderByClause(pageWrap.getOrderByClause());
List<Pinlei> list = pinleiMapper.selectByExample(pinleiExample);
for (Pinlei info:list) {
setFatherInfo(info);
}
return PageData.from(new PageInfo<>(list));
}
//父表信息
private void setFatherInfo(Pinlei info){
if (null != info){
}
}
//字符类型模糊查询条件构造器
private PinleiExample getPinleiExampleByLike(Pinlei instance) {
PinleiExample pinleiExample = new PinleiExample();
PinleiExample.Criteria criteria = pinleiExample.createCriteria();
//分类id完全匹配
if (null != instance.getId()) {
criteria.andIdEqualTo(instance.getId());
}
//名称mingcheng模糊匹配
if (null != instance.getMingcheng() && !instance.getMingcheng().equals("")) {
criteria.andMingchengLike("%" + instance.getMingcheng() + "%");
}
return pinleiExample;
}
//字符类型完全相等查询条件构造器
private PinleiExample getPinleiExampleByEqualTo(Pinlei instance) {
PinleiExample pinleiExample = new PinleiExample();
PinleiExample.Criteria criteria = pinleiExample.createCriteria();
//分类id完全匹配
if (null != instance.getId()) {
criteria.andIdEqualTo(instance.getId());
}
//名称mingcheng完全匹配
if (null != instance.getMingcheng() && !instance.getMingcheng().equals("")) {
criteria.andMingchengEqualTo(instance.getMingcheng());
}
return pinleiExample;
}
}

@ -1,256 +0,0 @@
package com.service.impl;
import com.dao.*;
import com.entity.*;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.service.*;
import com.util.ExampleBuilder;
import com.util.PageData;
import com.util.PageWrap;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* @ClassName ShangpinServiceImpl
* @Description
*/
@Service
public class ShangpinServiceImpl implements ShangpinService {
@Autowired
private ShangpinMapper shangpinMapper;
@Autowired
private PinleiMapper pinleiMapper;
//保存或更新零食表shangpin
@Override
public Integer saveOrUpdate(Shangpin instance) {
if(null != instance.getId() && instance.getId() > 0) {
shangpinMapper.updateByPrimaryKeySelective(instance);
}else {
shangpinMapper.insertSelective(instance);
}
return instance.getId();
}
//查询零食表shangpin
@Override
public List<Shangpin> findAll() {
List<Shangpin> list = shangpinMapper.selectByExample(null);
for (Shangpin info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型模糊匹配)查询零食表shangpin
@Override
public List<Shangpin> find(Shangpin instance) {
ShangpinExample shangpinExample = getShangpinExampleByLike(instance);
shangpinExample.setOrderByClause(" id desc");
List<Shangpin> list = shangpinMapper.selectByExample(shangpinExample);
for (Shangpin info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型完全匹配)查询零食表shangpin
@Override
public List<Shangpin> findByEqualTo(Shangpin instance) {
ShangpinExample shangpinExample = getShangpinExampleByEqualTo(instance);
shangpinExample.setOrderByClause(" id desc");
List<Shangpin> list = shangpinMapper.selectByExample(shangpinExample);
for (Shangpin info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型模糊匹配)查询零食表shangpin最后一条数据
@Override
public Shangpin findOne(Shangpin instance) {
List<Shangpin> list = find(instance);
if (list.size() > 0) {
return list.get(0);
}
return null;
}
//根据条件(字符类型完全匹配)查询零食表shangpin最后一条数据
@Override
public Shangpin findOneByEqualTo(Shangpin instance) {
List<Shangpin> list = findByEqualTo(instance);
if (list.size() > 0) {
return list.get(0);
}
return null;
}
//根据id列查询零食表shangpin数据
@Override
public Shangpin findById(Integer id) {
Shangpin info = shangpinMapper.selectByPrimaryKey(id);
setFatherInfo(info);
return info;
}
//根据主键id列删除零食表shangpin数据
@Override
public int deleteById(Integer id) {
return shangpinMapper.deleteByPrimaryKey(id);
}
//根据条件(字符类型模糊匹配)分页查询零食表shangpin数据
@Override
public PageData<Shangpin> findPage(PageWrap<Shangpin> pageWrap) {
PageHelper.startPage(pageWrap.getPageNum(), pageWrap.getPageSize());
ShangpinExample shangpinExample = getShangpinExampleByLike(pageWrap.getModel());
shangpinExample.setOrderByClause(pageWrap.getOrderByClause());
List<Shangpin> list = shangpinMapper.selectByExample(shangpinExample);
for (Shangpin info:list) {
setFatherInfo(info);
}
return PageData.from(new PageInfo<>(list));
}
//根据条件(字符类型完全匹配)分页查询零食表shangpin数据
@Override
public PageData<Shangpin> findPageByEqualTo(PageWrap<Shangpin> pageWrap) {
PageHelper.startPage(pageWrap.getPageNum(), pageWrap.getPageSize());
ShangpinExample shangpinExample = getShangpinExampleByEqualTo(pageWrap.getModel());
shangpinExample.setOrderByClause(pageWrap.getOrderByClause());
List<Shangpin> list = shangpinMapper.selectByExample(shangpinExample);
for (Shangpin info:list) {
setFatherInfo(info);
}
return PageData.from(new PageInfo<>(list));
}
//父表信息
private void setFatherInfo(Shangpin info){
if (null != info){
Pinlei pinlei= pinleiMapper.selectByPrimaryKey(info.getPinleiid());
info.setPinlei(pinlei);
}
}
//字符类型模糊查询条件构造器
private ShangpinExample getShangpinExampleByLike(Shangpin instance) {
ShangpinExample shangpinExample = new ShangpinExample();
ShangpinExample.Criteria criteria = shangpinExample.createCriteria();
//零食id完全匹配
if (null != instance.getId()) {
criteria.andIdEqualTo(instance.getId());
}
//名称mingcheng模糊匹配
if (null != instance.getMingcheng() && !instance.getMingcheng().equals("")) {
criteria.andMingchengLike("%" + instance.getMingcheng() + "%");
}
//编号bianhao模糊匹配
if (null != instance.getBianhao() && !instance.getBianhao().equals("")) {
criteria.andBianhaoLike("%" + instance.getBianhao() + "%");
}
//分类idpinleiid完全匹配
if (null != instance.getPinleiid()) {
criteria.andPinleiidEqualTo(instance.getPinleiid());
}
//内容介绍neirong模糊匹配
if (null != instance.getNeirong() && !instance.getNeirong().equals("")) {
criteria.andNeirongLike("%" + instance.getNeirong() + "%");
}
//图片image模糊匹配
if (null != instance.getImage() && !instance.getImage().equals("")) {
criteria.andImageLike("%" + instance.getImage() + "%");
}
//原价yuanshijiage完全匹配
if (null != instance.getYuanshijiage()) {
criteria.andYuanshijiageEqualTo(instance.getYuanshijiage());
}
//现价jiage完全匹配
if (null != instance.getJiage()) {
criteria.andJiageEqualTo(instance.getJiage());
}
//单位danwei模糊匹配
if (null != instance.getDanwei() && !instance.getDanwei().equals("")) {
criteria.andDanweiLike("%" + instance.getDanwei() + "%");
}
//是否特价shenhe模糊匹配
if (null != instance.getShenhe() && !instance.getShenhe().equals("")) {
criteria.andShenheLike("%" + instance.getShenhe() + "%");
}
//库存数量kucunshuliang完全匹配
if (null != instance.getKucunshuliang()) {
criteria.andKucunshuliangEqualTo(instance.getKucunshuliang());
}
//销售数量xiaoshoushuliang完全匹配
if (null != instance.getXiaoshoushuliang()) {
criteria.andXiaoshoushuliangEqualTo(instance.getXiaoshoushuliang());
}
return shangpinExample;
}
//字符类型完全相等查询条件构造器
private ShangpinExample getShangpinExampleByEqualTo(Shangpin instance) {
ShangpinExample shangpinExample = new ShangpinExample();
ShangpinExample.Criteria criteria = shangpinExample.createCriteria();
//零食id完全匹配
if (null != instance.getId()) {
criteria.andIdEqualTo(instance.getId());
}
//名称mingcheng完全匹配
if (null != instance.getMingcheng() && !instance.getMingcheng().equals("")) {
criteria.andMingchengEqualTo(instance.getMingcheng());
}
//编号bianhao完全匹配
if (null != instance.getBianhao() && !instance.getBianhao().equals("")) {
criteria.andBianhaoEqualTo(instance.getBianhao());
}
//分类idpinleiid完全匹配
if (null != instance.getPinleiid()) {
criteria.andPinleiidEqualTo(instance.getPinleiid());
}
//内容介绍neirong完全匹配
if (null != instance.getNeirong() && !instance.getNeirong().equals("")) {
criteria.andNeirongEqualTo(instance.getNeirong());
}
//图片image完全匹配
if (null != instance.getImage() && !instance.getImage().equals("")) {
criteria.andImageEqualTo(instance.getImage());
}
//原价yuanshijiage完全匹配
if (null != instance.getYuanshijiage()) {
criteria.andYuanshijiageEqualTo(instance.getYuanshijiage());
}
//现价jiage完全匹配
if (null != instance.getJiage()) {
criteria.andJiageEqualTo(instance.getJiage());
}
//单位danwei完全匹配
if (null != instance.getDanwei() && !instance.getDanwei().equals("")) {
criteria.andDanweiEqualTo(instance.getDanwei());
}
//是否特价shenhe完全匹配
if (null != instance.getShenhe() && !instance.getShenhe().equals("")) {
criteria.andShenheEqualTo(instance.getShenhe());
}
//库存数量kucunshuliang完全匹配
if (null != instance.getKucunshuliang()) {
criteria.andKucunshuliangEqualTo(instance.getKucunshuliang());
}
//销售数量xiaoshoushuliang完全匹配
if (null != instance.getXiaoshoushuliang()) {
criteria.andXiaoshoushuliangEqualTo(instance.getXiaoshoushuliang());
}
return shangpinExample;
}
}

@ -1,224 +0,0 @@
package com.service.impl;
import com.dao.*;
import com.entity.*;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.service.*;
import com.util.ExampleBuilder;
import com.util.PageData;
import com.util.PageWrap;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* @ClassName ShenqingServiceImpl
* @Description
*/
@Service
public class ShenqingServiceImpl implements ShenqingService {
@Autowired
private ShenqingMapper shenqingMapper;
@Autowired
private UsersMapper usersMapper;
//保存或更新售后申请表shenqing
@Override
public Integer saveOrUpdate(Shenqing instance) {
if(null != instance.getId() && instance.getId() > 0) {
shenqingMapper.updateByPrimaryKeySelective(instance);
}else {
shenqingMapper.insertSelective(instance);
}
return instance.getId();
}
//查询售后申请表shenqing
@Override
public List<Shenqing> findAll() {
List<Shenqing> list = shenqingMapper.selectByExample(null);
for (Shenqing info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型模糊匹配)查询售后申请表shenqing
@Override
public List<Shenqing> find(Shenqing instance) {
ShenqingExample shenqingExample = getShenqingExampleByLike(instance);
shenqingExample.setOrderByClause(" id desc");
List<Shenqing> list = shenqingMapper.selectByExample(shenqingExample);
for (Shenqing info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型完全匹配)查询售后申请表shenqing
@Override
public List<Shenqing> findByEqualTo(Shenqing instance) {
ShenqingExample shenqingExample = getShenqingExampleByEqualTo(instance);
shenqingExample.setOrderByClause(" id desc");
List<Shenqing> list = shenqingMapper.selectByExample(shenqingExample);
for (Shenqing info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型模糊匹配)查询售后申请表shenqing最后一条数据
@Override
public Shenqing findOne(Shenqing instance) {
List<Shenqing> list = find(instance);
if (list.size() > 0) {
return list.get(0);
}
return null;
}
//根据条件(字符类型完全匹配)查询售后申请表shenqing最后一条数据
@Override
public Shenqing findOneByEqualTo(Shenqing instance) {
List<Shenqing> list = findByEqualTo(instance);
if (list.size() > 0) {
return list.get(0);
}
return null;
}
//根据id列查询售后申请表shenqing数据
@Override
public Shenqing findById(Integer id) {
Shenqing info = shenqingMapper.selectByPrimaryKey(id);
setFatherInfo(info);
return info;
}
//根据主键id列删除售后申请表shenqing数据
@Override
public int deleteById(Integer id) {
return shenqingMapper.deleteByPrimaryKey(id);
}
//根据条件(字符类型模糊匹配)分页查询售后申请表shenqing数据
@Override
public PageData<Shenqing> findPage(PageWrap<Shenqing> pageWrap) {
PageHelper.startPage(pageWrap.getPageNum(), pageWrap.getPageSize());
ShenqingExample shenqingExample = getShenqingExampleByLike(pageWrap.getModel());
shenqingExample.setOrderByClause(pageWrap.getOrderByClause());
List<Shenqing> list = shenqingMapper.selectByExample(shenqingExample);
for (Shenqing info:list) {
setFatherInfo(info);
}
return PageData.from(new PageInfo<>(list));
}
//根据条件(字符类型完全匹配)分页查询售后申请表shenqing数据
@Override
public PageData<Shenqing> findPageByEqualTo(PageWrap<Shenqing> pageWrap) {
PageHelper.startPage(pageWrap.getPageNum(), pageWrap.getPageSize());
ShenqingExample shenqingExample = getShenqingExampleByEqualTo(pageWrap.getModel());
shenqingExample.setOrderByClause(pageWrap.getOrderByClause());
List<Shenqing> list = shenqingMapper.selectByExample(shenqingExample);
for (Shenqing info:list) {
setFatherInfo(info);
}
return PageData.from(new PageInfo<>(list));
}
//父表信息
private void setFatherInfo(Shenqing info){
if (null != info){
Users users= usersMapper.selectByPrimaryKey(info.getUsersid());
info.setUsers(users);
}
}
//字符类型模糊查询条件构造器
private ShenqingExample getShenqingExampleByLike(Shenqing instance) {
ShenqingExample shenqingExample = new ShenqingExample();
ShenqingExample.Criteria criteria = shenqingExample.createCriteria();
//售后申请id完全匹配
if (null != instance.getId()) {
criteria.andIdEqualTo(instance.getId());
}
//姓名xingming模糊匹配
if (null != instance.getXingming() && !instance.getXingming().equals("")) {
criteria.andXingmingLike("%" + instance.getXingming() + "%");
}
//电话dianhua模糊匹配
if (null != instance.getDianhua() && !instance.getDianhua().equals("")) {
criteria.andDianhuaLike("%" + instance.getDianhua() + "%");
}
//说明neirong模糊匹配
if (null != instance.getNeirong() && !instance.getNeirong().equals("")) {
criteria.andNeirongLike("%" + instance.getNeirong() + "%");
}
//时间shijian模糊匹配
if (null != instance.getShijian() && !instance.getShijian().equals("")) {
criteria.andShijianLike("%" + instance.getShijian() + "%");
}
//备注beizhu模糊匹配
if (null != instance.getBeizhu() && !instance.getBeizhu().equals("")) {
criteria.andBeizhuLike("%" + instance.getBeizhu() + "%");
}
//是否审核shenhe模糊匹配
if (null != instance.getShenhe() && !instance.getShenhe().equals("")) {
criteria.andShenheLike("%" + instance.getShenhe() + "%");
}
//用户idusersid完全匹配
if (null != instance.getUsersid()) {
criteria.andUsersidEqualTo(instance.getUsersid());
}
return shenqingExample;
}
//字符类型完全相等查询条件构造器
private ShenqingExample getShenqingExampleByEqualTo(Shenqing instance) {
ShenqingExample shenqingExample = new ShenqingExample();
ShenqingExample.Criteria criteria = shenqingExample.createCriteria();
//售后申请id完全匹配
if (null != instance.getId()) {
criteria.andIdEqualTo(instance.getId());
}
//姓名xingming完全匹配
if (null != instance.getXingming() && !instance.getXingming().equals("")) {
criteria.andXingmingEqualTo(instance.getXingming());
}
//电话dianhua完全匹配
if (null != instance.getDianhua() && !instance.getDianhua().equals("")) {
criteria.andDianhuaEqualTo(instance.getDianhua());
}
//说明neirong完全匹配
if (null != instance.getNeirong() && !instance.getNeirong().equals("")) {
criteria.andNeirongEqualTo(instance.getNeirong());
}
//时间shijian完全匹配
if (null != instance.getShijian() && !instance.getShijian().equals("")) {
criteria.andShijianEqualTo(instance.getShijian());
}
//备注beizhu完全匹配
if (null != instance.getBeizhu() && !instance.getBeizhu().equals("")) {
criteria.andBeizhuEqualTo(instance.getBeizhu());
}
//是否审核shenhe完全匹配
if (null != instance.getShenhe() && !instance.getShenhe().equals("")) {
criteria.andShenheEqualTo(instance.getShenhe());
}
//用户idusersid完全匹配
if (null != instance.getUsersid()) {
criteria.andUsersidEqualTo(instance.getUsersid());
}
return shenqingExample;
}
}

@ -1,196 +0,0 @@
package com.service.impl;
import com.dao.*;
import com.entity.*;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.service.*;
import com.util.ExampleBuilder;
import com.util.PageData;
import com.util.PageWrap;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* @ClassName ShoucangServiceImpl
* @Description
*/
@Service
public class ShoucangServiceImpl implements ShoucangService {
@Autowired
private ShoucangMapper shoucangMapper;
@Autowired
private ShangpinMapper shangpinMapper;
@Autowired
private UsersMapper usersMapper;
//保存或更新收藏表shoucang
@Override
public Integer saveOrUpdate(Shoucang instance) {
if(null != instance.getId() && instance.getId() > 0) {
shoucangMapper.updateByPrimaryKeySelective(instance);
}else {
shoucangMapper.insertSelective(instance);
}
return instance.getId();
}
//查询收藏表shoucang
@Override
public List<Shoucang> findAll() {
List<Shoucang> list = shoucangMapper.selectByExample(null);
for (Shoucang info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型模糊匹配)查询收藏表shoucang
@Override
public List<Shoucang> find(Shoucang instance) {
ShoucangExample shoucangExample = getShoucangExampleByLike(instance);
shoucangExample.setOrderByClause(" id desc");
List<Shoucang> list = shoucangMapper.selectByExample(shoucangExample);
for (Shoucang info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型完全匹配)查询收藏表shoucang
@Override
public List<Shoucang> findByEqualTo(Shoucang instance) {
ShoucangExample shoucangExample = getShoucangExampleByEqualTo(instance);
shoucangExample.setOrderByClause(" id desc");
List<Shoucang> list = shoucangMapper.selectByExample(shoucangExample);
for (Shoucang info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型模糊匹配)查询收藏表shoucang最后一条数据
@Override
public Shoucang findOne(Shoucang instance) {
List<Shoucang> list = find(instance);
if (list.size() > 0) {
return list.get(0);
}
return null;
}
//根据条件(字符类型完全匹配)查询收藏表shoucang最后一条数据
@Override
public Shoucang findOneByEqualTo(Shoucang instance) {
List<Shoucang> list = findByEqualTo(instance);
if (list.size() > 0) {
return list.get(0);
}
return null;
}
//根据id列查询收藏表shoucang数据
@Override
public Shoucang findById(Integer id) {
Shoucang info = shoucangMapper.selectByPrimaryKey(id);
setFatherInfo(info);
return info;
}
//根据主键id列删除收藏表shoucang数据
@Override
public int deleteById(Integer id) {
return shoucangMapper.deleteByPrimaryKey(id);
}
//根据条件(字符类型模糊匹配)分页查询收藏表shoucang数据
@Override
public PageData<Shoucang> findPage(PageWrap<Shoucang> pageWrap) {
PageHelper.startPage(pageWrap.getPageNum(), pageWrap.getPageSize());
ShoucangExample shoucangExample = getShoucangExampleByLike(pageWrap.getModel());
shoucangExample.setOrderByClause(pageWrap.getOrderByClause());
List<Shoucang> list = shoucangMapper.selectByExample(shoucangExample);
for (Shoucang info:list) {
setFatherInfo(info);
}
return PageData.from(new PageInfo<>(list));
}
//根据条件(字符类型完全匹配)分页查询收藏表shoucang数据
@Override
public PageData<Shoucang> findPageByEqualTo(PageWrap<Shoucang> pageWrap) {
PageHelper.startPage(pageWrap.getPageNum(), pageWrap.getPageSize());
ShoucangExample shoucangExample = getShoucangExampleByEqualTo(pageWrap.getModel());
shoucangExample.setOrderByClause(pageWrap.getOrderByClause());
List<Shoucang> list = shoucangMapper.selectByExample(shoucangExample);
for (Shoucang info:list) {
setFatherInfo(info);
}
return PageData.from(new PageInfo<>(list));
}
//父表信息
private void setFatherInfo(Shoucang info){
if (null != info){
Shangpin shangpin= shangpinMapper.selectByPrimaryKey(info.getShangpinid());
info.setShangpin(shangpin);
Users users= usersMapper.selectByPrimaryKey(info.getUsersid());
info.setUsers(users);
}
}
//字符类型模糊查询条件构造器
private ShoucangExample getShoucangExampleByLike(Shoucang instance) {
ShoucangExample shoucangExample = new ShoucangExample();
ShoucangExample.Criteria criteria = shoucangExample.createCriteria();
//收藏id完全匹配
if (null != instance.getId()) {
criteria.andIdEqualTo(instance.getId());
}
//时间shijian模糊匹配
if (null != instance.getShijian() && !instance.getShijian().equals("")) {
criteria.andShijianLike("%" + instance.getShijian() + "%");
}
//零食idshangpinid完全匹配
if (null != instance.getShangpinid()) {
criteria.andShangpinidEqualTo(instance.getShangpinid());
}
//用户idusersid完全匹配
if (null != instance.getUsersid()) {
criteria.andUsersidEqualTo(instance.getUsersid());
}
return shoucangExample;
}
//字符类型完全相等查询条件构造器
private ShoucangExample getShoucangExampleByEqualTo(Shoucang instance) {
ShoucangExample shoucangExample = new ShoucangExample();
ShoucangExample.Criteria criteria = shoucangExample.createCriteria();
//收藏id完全匹配
if (null != instance.getId()) {
criteria.andIdEqualTo(instance.getId());
}
//时间shijian完全匹配
if (null != instance.getShijian() && !instance.getShijian().equals("")) {
criteria.andShijianEqualTo(instance.getShijian());
}
//零食idshangpinid完全匹配
if (null != instance.getShangpinid()) {
criteria.andShangpinidEqualTo(instance.getShangpinid());
}
//用户idusersid完全匹配
if (null != instance.getUsersid()) {
criteria.andUsersidEqualTo(instance.getUsersid());
}
return shoucangExample;
}
}

@ -1,244 +0,0 @@
package com.service.impl;
import com.dao.*;
import com.entity.*;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.service.*;
import com.util.ExampleBuilder;
import com.util.PageData;
import com.util.PageWrap;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* @ClassName UsersServiceImpl
* @Description
*/
@Service
public class UsersServiceImpl implements UsersService {
@Autowired
private UsersMapper usersMapper;
//保存或更新用户表users
@Override
public Integer saveOrUpdate(Users instance) {
if(null != instance.getId() && instance.getId() > 0) {
usersMapper.updateByPrimaryKeySelective(instance);
}else {
usersMapper.insertSelective(instance);
}
return instance.getId();
}
//查询用户表users
@Override
public List<Users> findAll() {
List<Users> list = usersMapper.selectByExample(null);
for (Users info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型模糊匹配)查询用户表users
@Override
public List<Users> find(Users instance) {
UsersExample usersExample = getUsersExampleByLike(instance);
usersExample.setOrderByClause(" id desc");
List<Users> list = usersMapper.selectByExample(usersExample);
for (Users info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型完全匹配)查询用户表users
@Override
public List<Users> findByEqualTo(Users instance) {
UsersExample usersExample = getUsersExampleByEqualTo(instance);
usersExample.setOrderByClause(" id desc");
List<Users> list = usersMapper.selectByExample(usersExample);
for (Users info:list) {
setFatherInfo(info);
}
return list;
}
//根据条件(字符类型模糊匹配)查询用户表users最后一条数据
@Override
public Users findOne(Users instance) {
List<Users> list = find(instance);
if (list.size() > 0) {
return list.get(0);
}
return null;
}
//根据条件(字符类型完全匹配)查询用户表users最后一条数据
@Override
public Users findOneByEqualTo(Users instance) {
List<Users> list = findByEqualTo(instance);
if (list.size() > 0) {
return list.get(0);
}
return null;
}
//根据id列查询用户表users数据
@Override
public Users findById(Integer id) {
Users info = usersMapper.selectByPrimaryKey(id);
setFatherInfo(info);
return info;
}
//根据主键id列删除用户表users数据
@Override
public int deleteById(Integer id) {
return usersMapper.deleteByPrimaryKey(id);
}
//根据条件(字符类型模糊匹配)分页查询用户表users数据
@Override
public PageData<Users> findPage(PageWrap<Users> pageWrap) {
PageHelper.startPage(pageWrap.getPageNum(), pageWrap.getPageSize());
UsersExample usersExample = getUsersExampleByLike(pageWrap.getModel());
usersExample.setOrderByClause(pageWrap.getOrderByClause());
List<Users> list = usersMapper.selectByExample(usersExample);
for (Users info:list) {
setFatherInfo(info);
}
return PageData.from(new PageInfo<>(list));
}
//根据条件(字符类型完全匹配)分页查询用户表users数据
@Override
public PageData<Users> findPageByEqualTo(PageWrap<Users> pageWrap) {
PageHelper.startPage(pageWrap.getPageNum(), pageWrap.getPageSize());
UsersExample usersExample = getUsersExampleByEqualTo(pageWrap.getModel());
usersExample.setOrderByClause(pageWrap.getOrderByClause());
List<Users> list = usersMapper.selectByExample(usersExample);
for (Users info:list) {
setFatherInfo(info);
}
return PageData.from(new PageInfo<>(list));
}
//父表信息
private void setFatherInfo(Users info){
if (null != info){
}
}
//字符类型模糊查询条件构造器
private UsersExample getUsersExampleByLike(Users instance) {
UsersExample usersExample = new UsersExample();
UsersExample.Criteria criteria = usersExample.createCriteria();
//用户id完全匹配
if (null != instance.getId()) {
criteria.andIdEqualTo(instance.getId());
}
//用户名称loginname模糊匹配
if (null != instance.getLoginname() && !instance.getLoginname().equals("")) {
criteria.andLoginnameLike("%" + instance.getLoginname() + "%");
}
//密码loginpw模糊匹配
if (null != instance.getLoginpw() && !instance.getLoginpw().equals("")) {
criteria.andLoginpwLike("%" + instance.getLoginpw() + "%");
}
//类型type模糊匹配
if (null != instance.getType() && !instance.getType().equals("")) {
criteria.andTypeLike("%" + instance.getType() + "%");
}
//类型名称typename模糊匹配
if (null != instance.getTypename() && !instance.getTypename().equals("")) {
criteria.andTypenameLike("%" + instance.getTypename() + "%");
}
//姓名xingming模糊匹配
if (null != instance.getXingming() && !instance.getXingming().equals("")) {
criteria.andXingmingLike("%" + instance.getXingming() + "%");
}
//性别xingbie模糊匹配
if (null != instance.getXingbie() && !instance.getXingbie().equals("")) {
criteria.andXingbieLike("%" + instance.getXingbie() + "%");
}
//年龄nianling模糊匹配
if (null != instance.getNianling() && !instance.getNianling().equals("")) {
criteria.andNianlingLike("%" + instance.getNianling() + "%");
}
//地址address模糊匹配
if (null != instance.getAddress() && !instance.getAddress().equals("")) {
criteria.andAddressLike("%" + instance.getAddress() + "%");
}
//电话dianhua模糊匹配
if (null != instance.getDianhua() && !instance.getDianhua().equals("")) {
criteria.andDianhuaLike("%" + instance.getDianhua() + "%");
}
//审核shenhe模糊匹配
if (null != instance.getShenhe() && !instance.getShenhe().equals("")) {
criteria.andShenheLike("%" + instance.getShenhe() + "%");
}
return usersExample;
}
//字符类型完全相等查询条件构造器
private UsersExample getUsersExampleByEqualTo(Users instance) {
UsersExample usersExample = new UsersExample();
UsersExample.Criteria criteria = usersExample.createCriteria();
//用户id完全匹配
if (null != instance.getId()) {
criteria.andIdEqualTo(instance.getId());
}
//用户名称loginname完全匹配
if (null != instance.getLoginname() && !instance.getLoginname().equals("")) {
criteria.andLoginnameEqualTo(instance.getLoginname());
}
//密码loginpw完全匹配
if (null != instance.getLoginpw() && !instance.getLoginpw().equals("")) {
criteria.andLoginpwEqualTo(instance.getLoginpw());
}
//类型type完全匹配
if (null != instance.getType() && !instance.getType().equals("")) {
criteria.andTypeEqualTo(instance.getType());
}
//类型名称typename完全匹配
if (null != instance.getTypename() && !instance.getTypename().equals("")) {
criteria.andTypenameEqualTo(instance.getTypename());
}
//姓名xingming完全匹配
if (null != instance.getXingming() && !instance.getXingming().equals("")) {
criteria.andXingmingEqualTo(instance.getXingming());
}
//性别xingbie完全匹配
if (null != instance.getXingbie() && !instance.getXingbie().equals("")) {
criteria.andXingbieEqualTo(instance.getXingbie());
}
//年龄nianling完全匹配
if (null != instance.getNianling() && !instance.getNianling().equals("")) {
criteria.andNianlingEqualTo(instance.getNianling());
}
//地址address完全匹配
if (null != instance.getAddress() && !instance.getAddress().equals("")) {
criteria.andAddressEqualTo(instance.getAddress());
}
//电话dianhua完全匹配
if (null != instance.getDianhua() && !instance.getDianhua().equals("")) {
criteria.andDianhuaEqualTo(instance.getDianhua());
}
//审核shenhe完全匹配
if (null != instance.getShenhe() && !instance.getShenhe().equals("")) {
criteria.andShenheEqualTo(instance.getShenhe());
}
return usersExample;
}
}

Some files were not shown because too many files have changed in this diff Show More

Loading…
Cancel
Save