应用程序主函数接口

@SpringBootApplication(scanBasePackages = {"org.linlinjava.litemall.db", "org.linlinjava.litemall.core", "org.linlinjava.litemall.admin"})

@MapperScan("org.linlinjava.litemall.db.dao")

@EnableTransactionManagement

@EnableScheduling

public class Application {

public static void main(String[] args) {

SpringApplication.run(Application.class, args);

}

}

优惠卷管理

/**

* 检测优惠券过期情况

*/

@Component

public class CouponJob {

private final Log logger = LogFactory.getLog(CouponJob.class);

@Autowired

private LitemallCouponService couponService;

@Autowired

private LitemallCouponUserService couponUserService;

/**

* 每隔一个小时检查

* TODO

* 注意，因为是相隔一个小时检查，因此导致优惠券真正超时时间可能比设定时间延迟1个小时

*/

@Scheduled(fixedDelay = 60 * 60 * 1000)

public void checkCouponExpired() {

logger.info("系统开启任务检查优惠券是否已经过期");

List<LitemallCoupon> couponList = couponService.queryExpired();

for(LitemallCoupon coupon : couponList){

coupon.setStatus(CouponConstant.STATUS_EXPIRED);

couponService.updateById(coupon);

}

List<LitemallCouponUser> couponUserList = couponUserService.queryExpired();

for(LitemallCouponUser couponUser : couponUserList){

couponUser.setStatus(CouponUserConstant.STATUS_EXPIRED);

couponUserService.update(couponUser);

}

}

}

订单管理

/**

* 检测订单状态

*/

@Component

public class OrderJob {

private final Log logger = LogFactory.getLog(OrderJob.class);

@Autowired

private LitemallOrderGoodsService orderGoodsService;

@Autowired

private LitemallOrderService orderService;

@Autowired

private LitemallGoodsProductService productService;

/**

* 自动取消订单

* <p>

* 定时检查订单未付款情况，如果超时 LITEMALL_ORDER_UNPAID 分钟则自动取消订单

* 定时时间是每次相隔半个小时。

* <p>

* TODO

* 注意，因为是相隔半小时检查，因此导致订单真正超时时间是 [LITEMALL_ORDER_UNPAID, 30 + LITEMALL_ORDER_UNPAID]

*/

@Scheduled(fixedDelay = 30 * 60 * 1000)

@Transactional

public void checkOrderUnpaid() {

logger.info("系统开启任务检查订单是否已经超期自动取消订单");

List<LitemallOrder> orderList = orderService.queryUnpaid(SystemConfig.getOrderUnpaid());

for (LitemallOrder order : orderList) {

// 设置订单已取消状态

order.setOrderStatus(OrderUtil.STATUS_AUTO_CANCEL);

order.setEndTime(LocalDateTime.now());

if (orderService.updateWithOptimisticLocker(order) == 0) {

throw new RuntimeException("更新数据已失效");

}

// 商品货品数量增加

Integer orderId = order.getId();

List<LitemallOrderGoods> orderGoodsList = orderGoodsService.queryByOid(orderId);

for (LitemallOrderGoods orderGoods : orderGoodsList) {

Integer productId = orderGoods.getProductId();

Short number = orderGoods.getNumber();

if (productService.addStock(productId, number) == 0) {

throw new RuntimeException("商品货品库存增加失败");

}

}

logger.info("订单 ID=" + order.getId() + " 已经超期自动取消订单");

}

}

/**

* 自动确认订单

* <p>

* 定时检查订单未确认情况，如果超时 LITEMALL_ORDER_UNCONFIRM 天则自动确认订单

* 定时时间是每天凌晨3点。

* <p>

* TODO

* 注意，因为是相隔一天检查，因此导致订单真正超时时间是 [LITEMALL_ORDER_UNCONFIRM, 1 + LITEMALL_ORDER_UNCONFIRM]

*/

@Scheduled(cron = "0 0 3 * * ?")

public void checkOrderUnconfirm() {

logger.info("系统开启任务检查订单是否已经超期自动确认收货");

List<LitemallOrder> orderList = orderService.queryUnconfirm(SystemConfig.getOrderUnconfirm());

for (LitemallOrder order : orderList) {

// 设置订单已取消状态

order.setOrderStatus(OrderUtil.STATUS_AUTO_CONFIRM);

order.setConfirmTime(LocalDateTime.now());

if (orderService.updateWithOptimisticLocker(order) == 0) {

logger.info("订单 ID=" + order.getId() + " 数据已经更新，放弃自动确认收货");

} else {

logger.info("订单 ID=" + order.getId() + " 已经超期自动确认收货");

}

}

}

/**

* 可评价订单商品超期

* <p>

* 定时检查订单商品评价情况，如果确认商品超时 LITEMALL_ORDER_COMMENT 天则取消可评价状态

* 定时时间是每天凌晨4点。

* <p>

* TODO

* 注意，因为是相隔一天检查，因此导致订单真正超时时间是 [LITEMALL_ORDER_COMMENT, 1 + LITEMALL_ORDER_COMMENT]

*/

@Scheduled(cron = "0 0 4 * * ?")

public void checkOrderComment() {

logger.info("系统开启任务检查订单是否已经超期未评价");

LocalDateTime now = LocalDateTime.now();

List<LitemallOrder> orderList = orderService.queryComment(SystemConfig.getOrderComment());

for (LitemallOrder order : orderList) {

order.setComments((short) 0);

orderService.updateWithOptimisticLocker(order);

List<LitemallOrderGoods> orderGoodsList = orderGoodsService.queryByOid(order.getId());

for (LitemallOrderGoods orderGoods : orderGoodsList) {

orderGoods.setComment(-1);

orderGoodsService.updateById(orderGoods);

}

}

}

}

上架商品管理服务

@Service

public class AdminGoodsService {

private final Log logger = LogFactory.getLog(AdminGoodsService.class);

@Autowired

private LitemallGoodsService goodsService;

@Autowired

private LitemallGoodsSpecificationService specificationService;

@Autowired

private LitemallGoodsAttributeService attributeService;

@Autowired

private LitemallGoodsProductService productService;

@Autowired

private LitemallCategoryService categoryService;

@Autowired

private LitemallBrandService brandService;

@Autowired

private LitemallCartService cartService;

@Autowired

private LitemallOrderGoodsService orderGoodsService;

@Autowired

private QCodeService qCodeService;

public Object list(String goodsSn, String name,

Integer page, Integer limit, String sort, String order) {

List<LitemallGoods> goodsList = goodsService.querySelective(goodsSn, name, page, limit, sort, order);

return ResponseUtil.okList(goodsList);

}

private Object validate(GoodsAllinone goodsAllinone) {

LitemallGoods goods = goodsAllinone.getGoods();

String name = goods.getName();

if (StringUtils.isEmpty(name)) {

return ResponseUtil.badArgument();

}

String goodsSn = goods.getGoodsSn();

if (StringUtils.isEmpty(goodsSn)) {

return ResponseUtil.badArgument();

}

// 品牌商可以不设置，如果设置则需要验证品牌商存在

Integer brandId = goods.getBrandId();

if (brandId != null && brandId != 0) {

if (brandService.findById(brandId) == null) {

return ResponseUtil.badArgumentValue();

}

}

// 分类可以不设置，如果设置则需要验证分类存在

Integer categoryId = goods.getCategoryId();

if (categoryId != null && categoryId != 0) {

if (categoryService.findById(categoryId) == null) {

return ResponseUtil.badArgumentValue();

}

}

LitemallGoodsAttribute[] attributes = goodsAllinone.getAttributes();

for (LitemallGoodsAttribute attribute : attributes) {

String attr = attribute.getAttribute();

if (StringUtils.isEmpty(attr)) {

return ResponseUtil.badArgument();

}

String value = attribute.getValue();

if (StringUtils.isEmpty(value)) {

return ResponseUtil.badArgument();

}

}

LitemallGoodsSpecification[] specifications = goodsAllinone.getSpecifications();

for (LitemallGoodsSpecification specification : specifications) {

String spec = specification.getSpecification();

if (StringUtils.isEmpty(spec)) {

return ResponseUtil.badArgument();

}

String value = specification.getValue();

if (StringUtils.isEmpty(value)) {

return ResponseUtil.badArgument();

}

}

LitemallGoodsProduct[] products = goodsAllinone.getProducts();

for (LitemallGoodsProduct product : products) {

Integer number = product.getNumber();

if (number == null || number < 0) {

return ResponseUtil.badArgument();

}

BigDecimal price = product.getPrice();

if (price == null) {

return ResponseUtil.badArgument();

}

String[] productSpecifications = product.getSpecifications();

if (productSpecifications.length == 0) {

return ResponseUtil.badArgument();

}

}

return null;

}

/**

* 编辑商品

* <p>

* TODO

* 目前商品修改的逻辑是

* 1. 更新litemall_goods表

* 2. 逻辑删除litemall_goods_specification、litemall_goods_attribute、litemall_goods_product

* 3. 添加litemall_goods_specification、litemall_goods_attribute、litemall_goods_product

* <p>

* 这里商品三个表的数据采用删除再添加的策略是因为

* 商品编辑页面，支持管理员添加删除商品规格、添加删除商品属性，因此这里仅仅更新是不可能的，

* 只能删除三个表旧的数据，然后添加新的数据。

* 但是这里又会引入新的问题，就是存在订单商品货品ID指向了失效的商品货品表。

* 因此这里会拒绝管理员编辑商品，如果订单或购物车中存在商品。

* 所以这里可能需要重新设计。

*/

@Transactional

public Object update(GoodsAllinone goodsAllinone) {

Object error = validate(goodsAllinone);

if (error != null) {

return error;

}

LitemallGoods goods = goodsAllinone.getGoods();

LitemallGoodsAttribute[] attributes = goodsAllinone.getAttributes();

LitemallGoodsSpecification[] specifications = goodsAllinone.getSpecifications();

LitemallGoodsProduct[] products = goodsAllinone.getProducts();

Integer id = goods.getId();

//将生成的分享图片地址写入数据库

String url = qCodeService.createGoodShareImage(goods.getId().toString(), goods.getPicUrl(), goods.getName());

goods.setShareUrl(url);

// 商品基本信息表litemall_goods

if (goodsService.updateById(goods) == 0) {

throw new RuntimeException("更新数据失败");

}

Integer gid = goods.getId();

specificationService.deleteByGid(gid);

attributeService.deleteByGid(gid);

productService.deleteByGid(gid);

// 商品规格表litemall_goods_specification

for (LitemallGoodsSpecification specification : specifications) {

specification.setGoodsId(goods.getId());

specificationService.add(specification);

}

// 商品参数表litemall_goods_attribute

for (LitemallGoodsAttribute attribute : attributes) {

attribute.setGoodsId(goods.getId());

attributeService.add(attribute);

}

// 商品货品表litemall_product

for (LitemallGoodsProduct product : products) {

product.setGoodsId(goods.getId());

productService.add(product);

}

return ResponseUtil.ok();

}

@Transactional

public Object delete(LitemallGoods goods) {

Integer id = goods.getId();

if (id == null) {

return ResponseUtil.badArgument();

}

Integer gid = goods.getId();

goodsService.deleteById(gid);

specificationService.deleteByGid(gid);

attributeService.deleteByGid(gid);

productService.deleteByGid(gid);

return ResponseUtil.ok();

}

@Transactional

public Object create(GoodsAllinone goodsAllinone) {

Object error = validate(goodsAllinone);

if (error != null) {

return error;

}

LitemallGoods goods = goodsAllinone.getGoods();

LitemallGoodsAttribute[] attributes = goodsAllinone.getAttributes();

LitemallGoodsSpecification[] specifications = goodsAllinone.getSpecifications();

LitemallGoodsProduct[] products = goodsAllinone.getProducts();

String name = goods.getName();

if (goodsService.checkExistByName(name)) {

return ResponseUtil.fail(GOODS_NAME_EXIST, "商品名已经存在");

}

// 商品基本信息表litemall_goods

goodsService.add(goods);

//将生成的分享图片地址写入数据库

String url = qCodeService.createGoodShareImage(goods.getId().toString(), goods.getPicUrl(), goods.getName());

if (!StringUtils.isEmpty(url)) {

goods.setShareUrl(url);

if (goodsService.updateById(goods) == 0) {

throw new RuntimeException("更新数据失败");

}

}

// 商品规格表litemall_goods_specification

for (LitemallGoodsSpecification specification : specifications) {

specification.setGoodsId(goods.getId());

specificationService.add(specification);

}

// 商品参数表litemall_goods_attribute

for (LitemallGoodsAttribute attribute : attributes) {

attribute.setGoodsId(goods.getId());

attributeService.add(attribute);

}

// 商品货品表litemall_product

for (LitemallGoodsProduct product : products) {

product.setGoodsId(goods.getId());

productService.add(product);

}

return ResponseUtil.ok();

}

public Object list2() {

// http://element-cn.eleme.io/#/zh-CN/component/cascader

// 管理员设置“所属分类”

List<LitemallCategory> l1CatList = categoryService.queryL1();

List<CatVo> categoryList = new ArrayList<>(l1CatList.size());

for (LitemallCategory l1 : l1CatList) {

CatVo l1CatVo = new CatVo();

l1CatVo.setValue(l1.getId());

l1CatVo.setLabel(l1.getName());

List<LitemallCategory> l2CatList = categoryService.queryByPid(l1.getId());

List<CatVo> children = new ArrayList<>(l2CatList.size());

for (LitemallCategory l2 : l2CatList) {

CatVo l2CatVo = new CatVo();

l2CatVo.setValue(l2.getId());

l2CatVo.setLabel(l2.getName());

children.add(l2CatVo);

}

l1CatVo.setChildren(children);

categoryList.add(l1CatVo);

}

// http://element-cn.eleme.io/#/zh-CN/component/select

// 管理员设置“所属品牌商”

List<LitemallBrand> list = brandService.all();

List<Map<String, Object>> brandList = new ArrayList<>(l1CatList.size());

for (LitemallBrand brand : list) {

Map<String, Object> b = new HashMap<>(2);

b.put("value", brand.getId());

b.put("label", brand.getName());

brandList.add(b);

}

Map<String, Object> data = new HashMap<>();

data.put("categoryList", categoryList);

data.put("brandList", brandList);

return ResponseUtil.ok(data);

}

public Object detail(Integer id) {

LitemallGoods goods = goodsService.findById(id);

List<LitemallGoodsProduct> products = productService.queryByGid(id);

List<LitemallGoodsSpecification> specifications = specificationService.queryByGid(id);

List<LitemallGoodsAttribute> attributes = attributeService.queryByGid(id);

Integer categoryId = goods.getCategoryId();

LitemallCategory category = categoryService.findById(categoryId);

Integer[] categoryIds = new Integer[]{};

if (category != null) {

Integer parentCategoryId = category.getPid();

categoryIds = new Integer[]{parentCategoryId, categoryId};

}

Map<String, Object> data = new HashMap<>();

data.put("goods", goods);

data.put("specifications", specifications);

data.put("products", products);

data.put("attributes", attributes);

data.put("categoryIds", categoryIds);

return ResponseUtil.ok(data);

}

}

订单管理服务

@Service

public class AdminOrderService {

private final Log logger = LogFactory.getLog(AdminOrderService.class);

@Autowired

private LitemallOrderGoodsService orderGoodsService;

@Autowired

private LitemallOrderService orderService;

@Autowired

private LitemallGoodsProductService productService;

@Autowired

private LitemallUserService userService;

@Autowired

private LitemallCommentService commentService;

@Autowired

private WxPayService wxPayService;

@Autowired

private NotifyService notifyService;

@Autowired

private LogHelper logHelper;

public Object list(Integer userId, String orderSn, List<Short> orderStatusArray,

Integer page, Integer limit, String sort, String order) {

List<LitemallOrder> orderList = orderService.querySelective(userId, orderSn, orderStatusArray, page, limit, sort, order);

return ResponseUtil.okList(orderList);

}

public Object detail(Integer id) {

LitemallOrder order = orderService.findById(id);

List<LitemallOrderGoods> orderGoods = orderGoodsService.queryByOid(id);

UserVo user = userService.findUserVoById(order.getUserId());

Map<String, Object> data = new HashMap<>();

data.put("order", order);

data.put("orderGoods", orderGoods);

data.put("user", user);

return ResponseUtil.ok(data);

}

/**

* 订单退款

* <p>

* 1. 检测当前订单是否能够退款;

* 2. 微信退款操作;

* 3. 设置订单退款确认状态；

* 4. 订单商品库存回库。

* <p>

* TODO

* 虽然接入了微信退款API，但是从安全角度考虑，建议开发者删除这里微信退款代码，采用以下两步走步骤：

* 1. 管理员登录微信官方支付平台点击退款操作进行退款

* 2. 管理员登录litemall管理后台点击退款操作进行订单状态修改和商品库存回库

* @param body 订单信息，{ orderId：xxx }

* @return 订单退款操作结果

*/

@Transactional

public Object refund(String body) {

Integer orderId = JacksonUtil.parseInteger(body, "orderId");

String refundMoney = JacksonUtil.parseString(body, "refundMoney");

if (orderId == null) {

return ResponseUtil.badArgument();

}

if (StringUtils.isEmpty(refundMoney)) {

return ResponseUtil.badArgument();

}

LitemallOrder order = orderService.findById(orderId);

if (order == null) {

return ResponseUtil.badArgument();

}

if (order.getActualPrice().compareTo(new BigDecimal(refundMoney)) != 0) {

return ResponseUtil.badArgumentValue();

}

// 如果订单不是退款状态，则不能退款

if (!order.getOrderStatus().equals(OrderUtil.STATUS_REFUND)) {

return ResponseUtil.fail(ORDER_CONFIRM_NOT_ALLOWED, "订单不能确认收货");

}

// 微信退款

WxPayRefundRequest wxPayRefundRequest = new WxPayRefundRequest();

wxPayRefundRequest.setOutTradeNo(order.getOrderSn());

wxPayRefundRequest.setOutRefundNo("refund_" + order.getOrderSn());

// 元转成分

Integer totalFee = order.getActualPrice().multiply(new BigDecimal(100)).intValue();

wxPayRefundRequest.setTotalFee(totalFee);

wxPayRefundRequest.setRefundFee(totalFee);

WxPayRefundResult wxPayRefundResult = null;

try {

wxPayRefundResult = wxPayService.refund(wxPayRefundRequest);

} catch (WxPayException e) {

e.printStackTrace();

return ResponseUtil.fail(ORDER_REFUND_FAILED, "订单退款失败");

}

if (!wxPayRefundResult.getReturnCode().equals("SUCCESS")) {

logger.warn("refund fail: " + wxPayRefundResult.getReturnMsg());

return ResponseUtil.fail(ORDER_REFUND_FAILED, "订单退款失败");

}

if (!wxPayRefundResult.getResultCode().equals("SUCCESS")) {

logger.warn("refund fail: " + wxPayRefundResult.getReturnMsg());

return ResponseUtil.fail(ORDER_REFUND_FAILED, "订单退款失败");

}

// 设置订单取消状态

order.setOrderStatus(OrderUtil.STATUS_REFUND_CONFIRM);

if (orderService.updateWithOptimisticLocker(order) == 0) {

throw new RuntimeException("更新数据已失效");

}

// 商品货品数量增加

List<LitemallOrderGoods> orderGoodsList = orderGoodsService.queryByOid(orderId);

for (LitemallOrderGoods orderGoods : orderGoodsList) {

Integer productId = orderGoods.getProductId();

Short number = orderGoods.getNumber();

if (productService.addStock(productId, number) == 0) {

throw new RuntimeException("商品货品库存增加失败");

}

}

//TODO 发送邮件和短信通知，这里采用异步发送

// 退款成功通知用户, 例如“您申请的订单退款 [ 单号:{1} ] 已成功，请耐心等待到账。”

// 注意订单号只发后6位

notifyService.notifySmsTemplate(order.getMobile(), NotifyType.REFUND, new String[]{order.getOrderSn().substring(8, 14)});

logHelper.logOrderSucceed("退款", "订单编号 " + orderId);

return ResponseUtil.ok();

}

/**

* 发货

* 1. 检测当前订单是否能够发货

* 2. 设置订单发货状态

*

* @param body 订单信息，{ orderId：xxx, shipSn: xxx, shipChannel: xxx }

* @return 订单操作结果

* 成功则 { errno: 0, errmsg: '成功' }

* 失败则 { errno: XXX, errmsg: XXX }

*/

public Object ship(String body) {

Integer orderId = JacksonUtil.parseInteger(body, "orderId");

String shipSn = JacksonUtil.parseString(body, "shipSn");

String shipChannel = JacksonUtil.parseString(body, "shipChannel");

if (orderId == null || shipSn == null || shipChannel == null) {

return ResponseUtil.badArgument();

}

LitemallOrder order = orderService.findById(orderId);

if (order == null) {

return ResponseUtil.badArgument();

}

// 如果订单不是已付款状态，则不能发货

if (!order.getOrderStatus().equals(OrderUtil.STATUS_PAY)) {

return ResponseUtil.fail(ORDER_CONFIRM_NOT_ALLOWED, "订单不能确认收货");

}

order.setOrderStatus(OrderUtil.STATUS_SHIP);

order.setShipSn(shipSn);

order.setShipChannel(shipChannel);

order.setShipTime(LocalDateTime.now());

if (orderService.updateWithOptimisticLocker(order) == 0) {

return ResponseUtil.updatedDateExpired();

}

//TODO 发送邮件和短信通知，这里采用异步发送

// 发货会发送通知短信给用户:          *

// "您的订单已经发货，快递公司 {1}，快递单 {2} ，请注意查收"

notifyService.notifySmsTemplate(order.getMobile(), NotifyType.SHIP, new String[]{shipChannel, shipSn});

logHelper.logOrderSucceed("发货", "订单编号 " + orderId);

return ResponseUtil.ok();

}

/**

* 回复订单商品

* @param body 订单信息，{ orderId：xxx }

* @return 订单操作结果

* 成功则 { errno: 0, errmsg: '成功' }

* 失败则 { errno: XXX, errmsg: XXX }

*/

public Object reply(String body) {

Integer commentId = JacksonUtil.parseInteger(body, "commentId");

if (commentId == null || commentId == 0) {

return ResponseUtil.badArgument();

}

// 目前只支持回复一次

if (commentService.findById(commentId) != null) {

return ResponseUtil.fail(ORDER_REPLY_EXIST, "订单商品已回复！");

}

String content = JacksonUtil.parseString(body, "content");

if (StringUtils.isEmpty(content)) {

return ResponseUtil.badArgument();

}

// 创建评价回复

LitemallComment comment = new LitemallComment();

comment.setType((byte) 2);

comment.setValueId(commentId);

comment.setContent(content);

comment.setUserId(0);                 // 评价回复没有用

comment.setStar((short) 0);           // 评价回复没有用

comment.setHasPicture(false);        // 评价回复没有用

comment.setPicUrls(new String[]{});  // 评价回复没有用

commentService.save(comment);

return ResponseUtil.ok()

}

}

操作日志管理服务

/**

* 这里的日志类型设计成四种（当然开发者需要可以自己扩展）

* 一般日志：用户觉得需要查看的一般操作日志，建议是默认的日志级别

* 安全日志：用户安全相关的操作日志，例如登录、删除管理员

* 订单日志：用户交易相关的操作日志，例如订单发货、退款

* 其他日志：如果以上三种不合适，可以选择其他日志，建议是优先级最低的日志级别

*

* 当然可能很多操作是不需要记录到数据库的，例如编辑商品、编辑广告品之类。

*/

@Component

public class LogHelper {

public final static Integer LOG_TYPE_GENERAL = 0;

public final static Integer LOG_TYPE_AUTH = 1;

public final static Integer LOG_TYPE_ORDER = 2;

public final static Integer LOG_TYPE_OTHER = 3;

@Autowired

private LitemallLogService logService;

public void logGeneralSucceed(String action){

logAdmin(LOG_TYPE_GENERAL, action, true, "", "");

}

public void logGeneralSucceed(String action, String result){

logAdmin(LOG_TYPE_GENERAL, action, true, result, "");

}

public void logGeneralFail(String action, String error){

logAdmin(LOG_TYPE_GENERAL, action, false, error, "");

}

public void logAuthSucceed(String action){

logAdmin(LOG_TYPE_AUTH, action, true, "", "");

}

public void logAuthSucceed(String action, String result){

logAdmin(LOG_TYPE_AUTH, action, true, result, "");

}

public void logAuthFail(String action, String error){

logAdmin(LOG_TYPE_AUTH, action, false, error, "");

}

public void logOrderSucceed(String action){

logAdmin(LOG_TYPE_ORDER, action, true, "", "");

}

public void logOrderSucceed(String action, String result){

logAdmin(LOG_TYPE_ORDER, action, true, result, "");

}

public void logOrderFail(String action, String error){

logAdmin(LOG_TYPE_ORDER, action, false, error, "");

}

public void logOtherSucceed(String action){

logAdmin(LOG_TYPE_OTHER, action, true, "", "");

}

public void logOtherSucceed(String action, String result){

logAdmin(LOG_TYPE_OTHER, action, true, result, "");

}

public void logOtherFail(String action, String error){

logAdmin(LOG_TYPE_OTHER, action, false, error, "");

}

public void logAdmin (Integer type, String action, Boolean succeed, String result, String comment){

LitemallLog log = new LitemallLog();

Subject currentUser = SecurityUtils.getSubject();

if(currentUser != null) {

LitemallAdmin admin = (LitemallAdmin) currentUser.getPrincipal();

if(admin != null) {

log.setAdmin(admin.getUsername());

}

else{

log.setAdmin("匿名用户");

}

}

else{

log.setAdmin("匿名用户");

}

HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();

if(request != null) {

log.setIp(IpUtil.getIpAddr(request));

}

log.setType(type);

log.setAction(action);

log.setStatus(succeed);

log.setResult(result);

log.setComment(comment);

logService.add(log);

}

}

顾客（会员）身份认证

public class AdminAuthorizingRealm extends AuthorizingRealm {

private static final Logger log = LoggerFactory.getLogger(AdminAuthorizingRealm.class);

@Autowired

private LitemallAdminService adminService;

@Autowired

private LitemallRoleService roleService;

@Autowired

private LitemallPermissionService permissionService;

@Override

protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {

if (principals == null) {

throw new AuthorizationException("PrincipalCollection method argument cannot be null.");

}

LitemallAdmin admin = (LitemallAdmin) getAvailablePrincipal(principals);

Integer[] roleIds = admin.getRoleIds();

Set<String> roles = roleService.queryByIds(roleIds);

Set<String> permissions = permissionService.queryByRoleIds(roleIds);

SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();

info.setRoles(roles);

info.setStringPermissions(permissions);

return info;

}

@Override

protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

UsernamePasswordToken upToken = (UsernamePasswordToken) token;

String username = upToken.getUsername();

String password=new String(upToken.getPassword());

if (StringUtils.isEmpty(username)) {

throw new AccountException("用户名不能为空");

}

if (StringUtils.isEmpty(password)) {

throw new AccountException("密码不能为空");

}

List<LitemallAdmin> adminList = adminService.findAdmin(username);

Assert.state(adminList.size() < 2, "同一个用户名存在两个账户");

if (adminList.size() == 0) {

throw new UnknownAccountException("找不到用户（"+username+"）的帐号信息");

}

LitemallAdmin admin = adminList.get(0);

BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();

if (!encoder.matches(password, admin.getPassword())) {

throw new UnknownAccountException("找不到用户（"+username+"）的帐号信息");

}

return new SimpleAuthenticationInfo(admin,password,getName());

}

}

广告管理控制器

Ps:其他控制器与此类似，不在一一冗赘

@RestController

@RequestMapping("/admin/ad")

@Validated

public class AdminAdController {

private final Log logger = LogFactory.getLog(AdminAdController.class);

@Autowired

private LitemallAdService adService;

@RequiresPermissions("admin:ad:list")

@RequiresPermissionsDesc(menu={"推广管理" , "广告管理"}, button="查询")

@GetMapping("/list")

public Object list(String name, String content,

@RequestParam(defaultValue = "1") Integer page,

@RequestParam(defaultValue = "10") Integer limit,

@Sort @RequestParam(defaultValue = "add_time") String sort,

@Order @RequestParam(defaultValue = "desc") String order) {

List<LitemallAd> adList = adService.querySelective(name, content, page, limit, sort, order);

return ResponseUtil.okList(adList);

}

private Object validate(LitemallAd ad) {

String name = ad.getName();

if (StringUtils.isEmpty(name)) {

return ResponseUtil.badArgument();

}

String content = ad.getContent();

if (StringUtils.isEmpty(content)) {

return ResponseUtil.badArgument();

}

return null;

}

@RequiresPermissions("admin:ad:create")

@RequiresPermissionsDesc(menu={"推广管理" , "广告管理"}, button="添加")

@PostMapping("/create")

public Object create(@RequestBody LitemallAd ad) {

Object error = validate(ad);

if (error != null) {

return error;

}

adService.add(ad);

return ResponseUtil.ok(ad);

}

@RequiresPermissions("admin:ad:read")

@RequiresPermissionsDesc(menu={"推广管理" , "广告管理"}, button="详情")

@GetMapping("/read")

public Object read(@NotNull Integer id) {

LitemallAd ad = adService.findById(id);

return ResponseUtil.ok(ad);

}

@RequiresPermissions("admin:ad:update")

@RequiresPermissionsDesc(menu={"推广管理" , "广告管理"}, button="编辑")

@PostMapping("/update")

public Object update(@RequestBody LitemallAd ad) {

Object error = validate(ad);

if (error != null) {

return error;

}

if (adService.updateById(ad) == 0) {

return ResponseUtil.updatedDataFailed();

}

return ResponseUtil.ok(ad);

}

@RequiresPermissions("admin:ad:delete")

@RequiresPermissionsDesc(menu={"推广管理" , "广告管理"}, button="删除")

@PostMapping("/delete")

public Object delete(@RequestBody LitemallAd ad) {

Integer id = ad.getId();

if (id == null) {

return ResponseUtil.badArgument();

}

adService.deleteById(id);

return ResponseUtil.ok();

}

}

数据库操作部分

Ps:其他操作和对商品品牌数据库表操作类似，再次不在冗赘。

商品品牌数据库表操作

@Service

publicclassLitemallBrandService {

@Resource

privateLitemallBrandMapperbrandMapper;

privateColumn[] columns = newColumn[]{Column.id, Column.name, Column.desc, Column.picUrl, Column.floorPrice};

publicList<LitemallBrand> query(Integerpage, Integerlimit, Stringsort, Stringorder) {

LitemallBrandExampleexample = newLitemallBrandExample();

example.or().andDeletedEqualTo(false);

if (!StringUtils.isEmpty(sort) && !StringUtils.isEmpty(order)) {

example.setOrderByClause(sort + " " + order);

}

PageHelper.startPage(page, limit);

returnbrandMapper.selectByExampleSelective(example, columns);

}

publicList<LitemallBrand> query(Integerpage, Integerlimit) {

returnquery(page, limit, null, null);

}

publicLitemallBrandfindById(Integerid) {

returnbrandMapper.selectByPrimaryKey(id);

}

publicList<LitemallBrand> querySelective(Stringid, Stringname, Integerpage, Integersize, Stringsort, Stringorder) {

LitemallBrandExampleexample = newLitemallBrandExample();

LitemallBrandExample.Criteriacriteria = example.createCriteria();

if (!StringUtils.isEmpty(id)) {

criteria.andIdEqualTo(Integer.valueOf(id));

}

if (!StringUtils.isEmpty(name)) {

criteria.andNameLike("%" + name + "%");

}

criteria.andDeletedEqualTo(false);

if (!StringUtils.isEmpty(sort) && !StringUtils.isEmpty(order)) {

example.setOrderByClause(sort + " " + order);

}

PageHelper.startPage(page, size);

returnbrandMapper.selectByExample(example);

}

publicintupdateById(LitemallBrandbrand) {

brand.setUpdateTime(LocalDateTime.now());

returnbrandMapper.updateByPrimaryKeySelective(brand);

}

publicvoiddeleteById(Integerid) {

brandMapper.logicalDeleteByPrimaryKey(id);

}

publicvoidadd(LitemallBrandbrand) {

brand.setAddTime(LocalDateTime.now());

brand.setUpdateTime(LocalDateTime.now());

brandMapper.insertSelective(brand);

}

publicList<LitemallBrand> all() {

LitemallBrandExampleexample = newLitemallBrandExample();

example.or().andDeletedEqualTo(false);

returnbrandMapper.selectByExample(example);

}

}

核心操作部分

Ps:其他核心操作同存储（商品信息、图片对象等）操作、物流查询服务类似，不在冗赘。

存储操作

/**

* 对象存储接口

*/

publicinterfaceStorage {

/**

* 存储一个文件对象

*

* @paraminputStream   文件输入流

* @paramcontentLength文件长度

* @paramcontentType   文件类型

* @paramkeyName       文件名

*/

voidstore(InputStreaminputStream, longcontentLength, StringcontentType, StringkeyName);

Stream<Path> loadAll();

Pathload(StringkeyName);

ResourceloadAsResource(StringkeyName);

voiddelete(StringkeyName);

StringgenerateUrl(StringkeyName);

}

物流查询服务

/**

* 物流查询服务

*

* 快递鸟即时查询API http://www.kdniao.com/api-track

*/

public class ExpressService {

//请求url

private String ReqURL = "http://api.kdniao.com/Ebusiness/EbusinessOrderHandle.aspx";

private ExpressProperties properties;

public ExpressProperties getProperties() {

return properties;

}

public void setProperties(ExpressProperties properties) {

this.properties = properties;

}

/**

* 获取物流供应商名

*

* @param vendorCode

* @return

*/

public String getVendorName(String vendorCode) {

for (Map<String, String> item : properties.getVendors()) {

if (item.get("code").equals(vendorCode))

return item.get("name");

}

return null;

}

/**

* 获取物流信息

*

* @param expCode

* @param expNo

* @return

*/

public ExpressInfo getExpressInfo(String expCode, String expNo) {

try {

String result = getOrderTracesByJson(expCode, expNo);

ObjectMapper objMap = new ObjectMapper();

ExpressInfo ei = objMap.readValue(result, ExpressInfo.class);

ei.setShipperName(getVendorName(expCode));

return ei;

} catch (Exception e) {

e.printStackTrace();

}

return null;

}

/**

* Json方式 查询订单物流轨迹

*

* @throws Exception

*/

private String getOrderTracesByJson(String expCode, String expNo) throws Exception {

if (!properties.isEnable()) {

return null;

}

String requestData = "{'OrderCode':'','ShipperCode':'" + expCode + "','LogisticCode':'" + expNo + "'}";

Map<String, String> params = new HashMap<String, String>();

params.put("RequestData", URLEncoder.encode(requestData, "UTF-8"));

params.put("EBusinessID", properties.getAppId());

params.put("RequestType", "1002");

String dataSign = encrypt(requestData, properties.getAppKey(), "UTF-8");

params.put("DataSign", URLEncoder.encode(dataSign, "UTF-8"));

params.put("DataType", "2");

String result = HttpUtil.sendPost(ReqURL, params);

//根据公司业务处理返回的信息......

return result;

}

/**

* MD5加密

*

* @param str     内容

* @param charset 编码方式

* @throws Exception

*/

private String MD5(String str, String charset) throws Exception {

MessageDigest md = MessageDigest.getInstance("MD5");

md.update(str.getBytes(charset));

byte[] result = md.digest();

StringBuffer sb = new StringBuffer(32);

for (int i = 0; i < result.length; i++) {

int val = result[i] & 0xff;

if (val <= 0xf) {

sb.append("0");

}

sb.append(Integer.toHexString(val));

}

return sb.toString().toLowerCase();

}

/**

* Sign签名生成

*

* @param content  内容

* @param keyValue Appkey

* @param charset  编码方式

* @return DataSign签名

*/

private String encrypt(String content, String keyValue, String charset) {

if (keyValue != null) {

content = content + keyValue;

}

byte[] src = new byte[0];

try {

src = MD5(content, charset).getBytes(charset);

return Base64Utils.encodeToString(src);

} catch (Exception e) {

e.printStackTrace();

}

return null;

}

}

迷你商城后端管理

应用程序主函数接口

@SpringBootApplication(scanBasePackages = {"org.linlinjava.litemall.db", "org.linlinjava.litemall.core", "org.linlinjava.litemall.admin"})

@MapperScan("org.linlinjava.litemall.db.dao")

@EnableTransactionManagement

@EnableScheduling

public class Application {

public static void main(String[] args) {

SpringApplication.run(Application.class, args);

}

}

优惠卷管理

/**

* 检测优惠券过期情况

*/

@Component

public class CouponJob {

private final Log logger = LogFactory.getLog(CouponJob.class);

@Autowired

private LitemallCouponService couponService;

@Autowired

private LitemallCouponUserService couponUserService;

/**

* 每隔一个小时检查

* TODO

* 注意，因为是相隔一个小时检查，因此导致优惠券真正超时时间可能比设定时间延迟1个小时

*/

@Scheduled(fixedDelay = 60 * 60 * 1000)

public void checkCouponExpired() {

logger.info("系统开启任务检查优惠券是否已经过期");

List<LitemallCoupon> couponList = couponService.queryExpired();

for(LitemallCoupon coupon : couponList){

coupon.setStatus(CouponConstant.STATUS_EXPIRED);

couponService.updateById(coupon);

}

List<LitemallCouponUser> couponUserList = couponUserService.queryExpired();

for(LitemallCouponUser couponUser : couponUserList){

couponUser.setStatus(CouponUserConstant.STATUS_EXPIRED);

couponUserService.update(couponUser);

}

}

}

订单管理

/**

* 检测订单状态

*/

@Component

public class OrderJob {

private final Log logger = LogFactory.getLog(OrderJob.class);

@Autowired

private LitemallOrderGoodsService orderGoodsService;

@Autowired

private LitemallOrderService orderService;

@Autowired

private LitemallGoodsProductService productService;

/**

* 自动取消订单

* <p>

* 定时检查订单未付款情况，如果超时 LITEMALL_ORDER_UNPAID 分钟则自动取消订单

* 定时时间是每次相隔半个小时。

* <p>

* TODO

* 注意，因为是相隔半小时检查，因此导致订单真正超时时间是 [LITEMALL_ORDER_UNPAID, 30 + LITEMALL_ORDER_UNPAID]

*/

@Scheduled(fixedDelay = 30 * 60 * 1000)

@Transactional

public void checkOrderUnpaid() {

logger.info("系统开启任务检查订单是否已经超期自动取消订单");

List<LitemallOrder> orderList = orderService.queryUnpaid(SystemConfig.getOrderUnpaid());

for (LitemallOrder order : orderList) {

// 设置订单已取消状态

order.setOrderStatus(OrderUtil.STATUS_AUTO_CANCEL);

order.setEndTime(LocalDateTime.now());

if (orderService.updateWithOptimisticLocker(order) == 0) {

throw new RuntimeException("更新数据已失效");

}

// 商品货品数量增加

Integer orderId = order.getId();

List<LitemallOrderGoods> orderGoodsList = orderGoodsService.queryByOid(orderId);

for (LitemallOrderGoods orderGoods : orderGoodsList) {

Integer productId = orderGoods.getProductId();

Short number = orderGoods.getNumber();

if (productService.addStock(productId, number) == 0) {

throw new RuntimeException("商品货品库存增加失败");

}

}

logger.info("订单 ID=" + order.getId() + " 已经超期自动取消订单");

}

}

/**

* 自动确认订单

* <p>

* 定时检查订单未确认情况，如果超时 LITEMALL_ORDER_UNCONFIRM 天则自动确认订单

* 定时时间是每天凌晨3点。

* <p>

* TODO

* 注意，因为是相隔一天检查，因此导致订单真正超时时间是 [LITEMALL_ORDER_UNCONFIRM, 1 + LITEMALL_ORDER_UNCONFIRM]

*/

@Scheduled(cron = "0 0 3 * * ?")

public void checkOrderUnconfirm() {

logger.info("系统开启任务检查订单是否已经超期自动确认收货");

List<LitemallOrder> orderList = orderService.queryUnconfirm(SystemConfig.getOrderUnconfirm());

for (LitemallOrder order : orderList) {

// 设置订单已取消状态

order.setOrderStatus(OrderUtil.STATUS_AUTO_CONFIRM);

order.setConfirmTime(LocalDateTime.now());

if (orderService.updateWithOptimisticLocker(order) == 0) {

logger.info("订单 ID=" + order.getId() + " 数据已经更新，放弃自动确认收货");

} else {

logger.info("订单 ID=" + order.getId() + " 已经超期自动确认收货");

}

}

}

/**

* 可评价订单商品超期

* <p>

* 定时检查订单商品评价情况，如果确认商品超时 LITEMALL_ORDER_COMMENT 天则取消可评价状态

* 定时时间是每天凌晨4点。

* <p>

* TODO

* 注意，因为是相隔一天检查，因此导致订单真正超时时间是 [LITEMALL_ORDER_COMMENT, 1 + LITEMALL_ORDER_COMMENT]

*/

@Scheduled(cron = "0 0 4 * * ?")

public void checkOrderComment() {

logger.info("系统开启任务检查订单是否已经超期未评价");

LocalDateTime now = LocalDateTime.now();

List<LitemallOrder> orderList = orderService.queryComment(SystemConfig.getOrderComment());

for (LitemallOrder order : orderList) {

order.setComments((short) 0);

orderService.updateWithOptimisticLocker(order);

List<LitemallOrderGoods> orderGoodsList = orderGoodsService.queryByOid(order.getId());

for (LitemallOrderGoods orderGoods : orderGoodsList) {

orderGoods.setComment(-1);

orderGoodsService.updateById(orderGoods);

}

}

}

}

上架商品管理服务

@Service

public class AdminGoodsService {

private final Log logger = LogFactory.getLog(AdminGoodsService.class);

@Autowired

private LitemallGoodsService goodsService;

@Autowired

private LitemallGoodsSpecificationService specificationService;

@Autowired

private LitemallGoodsAttributeService attributeService;

@Autowired

private LitemallGoodsProductService productService;

@Autowired

private LitemallCategoryService categoryService;

@Autowired

private LitemallBrandService brandService;

@Autowired

private LitemallCartService cartService;

@Autowired

private LitemallOrderGoodsService orderGoodsService;

@Autowired

private QCodeService qCodeService;

public Object list(String goodsSn, String name,

Integer page, Integer limit, String sort, String order) {

List<LitemallGoods> goodsList = goodsService.querySelective(goodsSn, name, page, limit, sort, order);

return ResponseUtil.okList(goodsList);

}

private Object validate(GoodsAllinone goodsAllinone) {

LitemallGoods goods = goodsAllinone.getGoods();

String name = goods.getName();

if (StringUtils.isEmpty(name)) {

return ResponseUtil.badArgument();

}

String goodsSn = goods.getGoodsSn();

if (StringUtils.isEmpty(goodsSn)) {

return ResponseUtil.badArgument();

}

// 品牌商可以不设置，如果设置则需要验证品牌商存在

Integer brandId = goods.getBrandId();

if (brandId != null && brandId != 0) {

if (brandService.findById(brandId) == null) {

return ResponseUtil.badArgumentValue();

}

}

// 分类可以不设置，如果设置则需要验证分类存在

Integer categoryId = goods.getCategoryId();

if (categoryId != null && categoryId != 0) {

if (categoryService.findById(categoryId) == null) {

return ResponseUtil.badArgumentValue();

}

}

LitemallGoodsAttribute[] attributes = goodsAllinone.getAttributes();

for (LitemallGoodsAttribute attribute : attributes) {

String attr = attribute.getAttribute();

if (StringUtils.isEmpty(attr)) {

return ResponseUtil.badArgument();

}

String value = attribute.getValue();

if (StringUtils.isEmpty(value)) {

return ResponseUtil.badArgument();

}

}

LitemallGoodsSpecification[] specifications = goodsAllinone.getSpecifications();

for (LitemallGoodsSpecification specification : specifications) {

String spec = specification.getSpecification();

if (StringUtils.isEmpty(spec)) {

return ResponseUtil.badArgument();

}

String value = specification.getValue();

if (StringUtils.isEmpty(value)) {

return ResponseUtil.badArgument();

}

}

LitemallGoodsProduct[] products = goodsAllinone.getProducts();

for (LitemallGoodsProduct product : products) {

Integer number = product.getNumber();

if (number == null || number < 0) {

return ResponseUtil.badArgument();

}

BigDecimal price = product.getPrice();

if (price == null) {

return ResponseUtil.badArgument();

}

String[] productSpecifications = product.getSpecifications();

if (productSpecifications.length == 0) {

return ResponseUtil.badArgument();

}

}

return null;

}

/**

* 编辑商品

* <p>

* TODO

* 目前商品修改的逻辑是

* 1. 更新litemall_goods表

* 2. 逻辑删除litemall_goods_specification、litemall_goods_attribute、litemall_goods_product

* 3. 添加litemall_goods_specification、litemall_goods_attribute、litemall_goods_product

* <p>

* 这里商品三个表的数据采用删除再添加的策略是因为

* 商品编辑页面，支持管理员添加删除商品规格、添加删除商品属性，因此这里仅仅更新是不可能的，

* 只能删除三个表旧的数据，然后添加新的数据。

* 但是这里又会引入新的问题，就是存在订单商品货品ID指向了失效的商品货品表。

* 因此这里会拒绝管理员编辑商品，如果订单或购物车中存在商品。

* 所以这里可能需要重新设计。

*/

@Transactional

public Object update(GoodsAllinone goodsAllinone) {

Object error = validate(goodsAllinone);

if (error != null) {

return error;

}

LitemallGoods goods = goodsAllinone.getGoods();

LitemallGoodsAttribute[] attributes = goodsAllinone.getAttributes();

LitemallGoodsSpecification[] specifications = goodsAllinone.getSpecifications();

LitemallGoodsProduct[] products = goodsAllinone.getProducts();

Integer id = goods.getId();

//将生成的分享图片地址写入数据库

String url = qCodeService.createGoodShareImage(goods.getId().toString(), goods.getPicUrl(), goods.getName());

goods.setShareUrl(url);

// 商品基本信息表litemall_goods

if (goodsService.updateById(goods) == 0) {

throw new RuntimeException("更新数据失败");

}

Integer gid = goods.getId();

specificationService.deleteByGid(gid);

attributeService.deleteByGid(gid);

productService.deleteByGid(gid);

// 商品规格表litemall_goods_specification

for (LitemallGoodsSpecification specification : specifications) {

specification.setGoodsId(goods.getId());

specificationService.add(specification);

}

// 商品参数表litemall_goods_attribute

for (LitemallGoodsAttribute attribute : attributes) {

attribute.setGoodsId(goods.getId());

attributeService.add(attribute);

}

// 商品货品表litemall_product

for (LitemallGoodsProduct product : products) {

product.setGoodsId(goods.getId());

productService.add(product);

}

return ResponseUtil.ok();

}

@Transactional

public Object delete(LitemallGoods goods) {

Integer id = goods.getId();

if (id == null) {

return ResponseUtil.badArgument();

}

Integer gid = goods.getId();

goodsService.deleteById(gid);

specificationService.deleteByGid(gid);

attributeService.deleteByGid(gid);

productService.deleteByGid(gid);

return ResponseUtil.ok();

}

@Transactional

public Object create(GoodsAllinone goodsAllinone) {

Object error = validate(goodsAllinone);

if (error != null) {

return error;

}

LitemallGoods goods = goodsAllinone.getGoods();

LitemallGoodsAttribute[] attributes = goodsAllinone.getAttributes();

LitemallGoodsSpecification[] specifications = goodsAllinone.getSpecifications();

LitemallGoodsProduct[] products = goodsAllinone.getProducts();

String name = goods.getName();

if (goodsService.checkExistByName(name)) {

return ResponseUtil.fail(GOODS_NAME_EXIST, "商品名已经存在");

}

// 商品基本信息表litemall_goods

goodsService.add(goods);

//将生成的分享图片地址写入数据库

String url = qCodeService.createGoodShareImage(goods.getId().toString(), goods.getPicUrl(), goods.getName());

if (!StringUtils.isEmpty(url)) {

goods.setShareUrl(url);

if (goodsService.updateById(goods) == 0) {

throw new RuntimeException("更新数据失败");

}

}

// 商品规格表litemall_goods_specification

for (LitemallGoodsSpecification specification : specifications) {

specification.setGoodsId(goods.getId());

specificationService.add(specification);

}

// 商品参数表litemall_goods_attribute

for (LitemallGoodsAttribute attribute : attributes) {

attribute.setGoodsId(goods.getId());

attributeService.add(attribute);

}

// 商品货品表litemall_product

for (LitemallGoodsProduct product : products) {

product.setGoodsId(goods.getId());

productService.add(product);

}

return ResponseUtil.ok();

}

public Object list2() {

// http://element-cn.eleme.io/#/zh-CN/component/cascader

// 管理员设置“所属分类”

List<LitemallCategory> l1CatList = categoryService.queryL1();

List<CatVo> categoryList = new ArrayList<>(l1CatList.size());

for (LitemallCategory l1 : l1CatList) {

CatVo l1CatVo = new CatVo();

l1CatVo.setValue(l1.getId());

l1CatVo.setLabel(l1.getName());

List<LitemallCategory> l2CatList = categoryService.queryByPid(l1.getId());

List<CatVo> children = new ArrayList<>(l2CatList.size());

for (LitemallCategory l2 : l2CatList) {

CatVo l2CatVo = new CatVo();

l2CatVo.setValue(l2.getId());

l2CatVo.setLabel(l2.getName());

children.add(l2CatVo);

}

l1CatVo.setChildren(children);

categoryList.add(l1CatVo);

}

// http://element-cn.eleme.io/#/zh-CN/component/select

// 管理员设置“所属品牌商”

List<LitemallBrand> list = brandService.all();

List<Map<String, Object>> brandList = new ArrayList<>(l1CatList.size());

for (LitemallBrand brand : list) {

Map<String, Object> b = new HashMap<>(2);

b.put("value", brand.getId());

b.put("label", brand.getName());

brandList.add(b);

}

Map<String, Object> data = new HashMap<>();

data.put("categoryList", categoryList);

data.put("brandList", brandList);

return ResponseUtil.ok(data);

}

public Object detail(Integer id) {

LitemallGoods goods = goodsService.findById(id);

List<LitemallGoodsProduct> products = productService.queryByGid(id);

List<LitemallGoodsSpecification> specifications = specificationService.queryByGid(id);

List<LitemallGoodsAttribute> attributes = attributeService.queryByGid(id);

Integer categoryId = goods.getCategoryId();

LitemallCategory category = categoryService.findById(categoryId);

Integer[] categoryIds = new Integer[]{};

if (category != null) {

Integer parentCategoryId = category.getPid();

categoryIds = new Integer[]{parentCategoryId, categoryId};

}

Map<String, Object> data = new HashMap<>();

data.put("goods", goods);

data.put("specifications", specifications);

data.put("products", products);

data.put("attributes", attributes);

data.put("categoryIds", categoryIds);

return ResponseUtil.ok(data);

}

}

订单管理服务

@Service

public class AdminOrderService {

private final Log logger = LogFactory.getLog(AdminOrderService.class);

@Autowired

private LitemallOrderGoodsService orderGoodsService;

@Autowired

private LitemallOrderService orderService;

@Autowired

private LitemallGoodsProductService productService;

@Autowired

private LitemallUserService userService;

@Autowired

private LitemallCommentService commentService;

@Autowired

private WxPayService wxPayService;

@Autowired

private NotifyService notifyService;

@Autowired

private LogHelper logHelper;

public Object list(Integer userId, String orderSn, List<Short> orderStatusArray,

Integer page, Integer limit, String sort, String order) {

List<LitemallOrder> orderList = orderService.querySelective(userId, orderSn, orderStatusArray, page, limit, sort, order);

return ResponseUtil.okList(orderList);

}

public Object detail(Integer id) {

LitemallOrder order = orderService.findById(id);

List<LitemallOrderGoods> orderGoods = orderGoodsService.queryByOid(id);

UserVo user = userService.findUserVoById(order.getUserId());

Map<String, Object> data = new HashMap<>();

data.put("order", order);

data.put("orderGoods", orderGoods);

data.put("user", user);

return ResponseUtil.ok(data);

}

/**

* 订单退款

* <p>

* 1. 检测当前订单是否能够退款;

* 2. 微信退款操作;

* 3. 设置订单退款确认状态；

* 4. 订单商品库存回库。

* <p>

* TODO

* 虽然接入了微信退款API，但是从安全角度考虑，建议开发者删除这里微信退款代码，采用以下两步走步骤：

* 1. 管理员登录微信官方支付平台点击退款操作进行退款

* 2. 管理员登录litemall管理后台点击退款操作进行订单状态修改和商品库存回库

*

* @param body 订单信息，{ orderId：xxx }

* @return 订单退款操作结果

*/

@Transactional

public Object refund(String body) {

Integer orderId = JacksonUtil.parseInteger(body, "orderId");

String refundMoney = JacksonUtil.parseString(body, "refundMoney");

if (orderId == null) {

return ResponseUtil.badArgument();

}

if (StringUtils.isEmpty(refundMoney)) {

return ResponseUtil.badArgument();

}

LitemallOrder order = orderService.findById(orderId);

if (order == null) {

return ResponseUtil.badArgument();

}

if (order.getActualPrice().compareTo(new BigDecimal(refundMoney)) != 0) {

return ResponseUtil.badArgumentValue();

}

// 如果订单不是退款状态，则不能退款

if (!order.getOrderStatus().equals(OrderUtil.STATUS_REFUND)) {

return ResponseUtil.fail(ORDER_CONFIRM_NOT_ALLOWED, "订单不能确认收货");

}

// 微信退款

WxPayRefundRequest wxPayRefundRequest = new WxPayRefundRequest();

wxPayRefundRequest.setOutTradeNo(order.getOrderSn());

wxPayRefundRequest.setOutRefundNo("refund_" + order.getOrderSn());

// 元转成分

Integer totalFee = order.getActualPrice().multiply(new BigDecimal(100)).intValue();

wxPayRefundRequest.setTotalFee(totalFee);

wxPayRefundRequest.setRefundFee(totalFee);

WxPayRefundResult wxPayRefundResult = null;

try {

wxPayRefundResult = wxPayService.refund(wxPayRefundRequest);

} catch (WxPayException e) {

e.printStackTrace();

return ResponseUtil.fail(ORDER_REFUND_FAILED, "订单退款失败");

}

if (!wxPayRefundResult.getReturnCode().equals("SUCCESS")) {

logger.warn("refund fail: " + wxPayRefundResult.getReturnMsg());

return ResponseUtil.fail(ORDER_REFUND_FAILED, "订单退款失败");

}

if (!wxPayRefundResult.getResultCode().equals("SUCCESS")) {

logger.warn("refund fail: " + wxPayRefundResult.getReturnMsg());

return ResponseUtil.fail(ORDER_REFUND_FAILED, "订单退款失败");

}

// 设置订单取消状态

order.setOrderStatus(OrderUtil.STATUS_REFUND_CONFIRM);

if (orderService.updateWithOptimisticLocker(order) == 0) {

throw new RuntimeException("更新数据已失效");

}

// 商品货品数量增加

List<LitemallOrderGoods> orderGoodsList = orderGoodsService.queryByOid(orderId);

for (LitemallOrderGoods orderGoods : orderGoodsList) {

Integer productId = orderGoods.getProductId();

Short number = orderGoods.getNumber();

if (productService.addStock(productId, number) == 0) {

throw new RuntimeException("商品货品库存增加失败");

}

}

//TODO 发送邮件和短信通知，这里采用异步发送

// 退款成功通知用户, 例如“您申请的订单退款 [ 单号:{1} ] 已成功，请耐心等待到账。”

// 注意订单号只发后6位

notifyService.notifySmsTemplate(order.getMobile(), NotifyType.REFUND, new String[]{order.getOrderSn().substring(8, 14)});

logHelper.logOrderSucceed("退款", "订单编号 " + orderId);

return ResponseUtil.ok();

}

/**

* 发货

* 1. 检测当前订单是否能够发货

* 2. 设置订单发货状态

*

* @param body 订单信息，{ orderId：xxx, shipSn: xxx, shipChannel: xxx }

* @return 订单操作结果

* 成功则 { errno: 0, errmsg: '成功' }

* 失败则 { errno: XXX, errmsg: XXX }

*/

public Object ship(String body) {

Integer orderId = JacksonUtil.parseInteger(body, "orderId");

String shipSn = JacksonUtil.parseString(body, "shipSn");

String shipChannel = JacksonUtil.parseString(body, "shipChannel");

if (orderId == null || shipSn == null || shipChannel == null) {

return ResponseUtil.badArgument();

}

LitemallOrder order = orderService.findById(orderId);

if (order == null) {

return ResponseUtil.badArgument();

}

// 如果订单不是已付款状态，则不能发货

if (!order.getOrderStatus().equals(OrderUtil.STATUS_PAY)) {

return ResponseUtil.fail(ORDER_CONFIRM_NOT_ALLOWED, "订单不能确认收货");

}

order.setOrderStatus(OrderUtil.STATUS_SHIP);

order.setShipSn(shipSn);

order.setShipChannel(shipChannel);

order.setShipTime(LocalDateTime.now());

if (orderService.updateWithOptimisticLocker(order) == 0) {

return ResponseUtil.updatedDateExpired();

}

//TODO 发送邮件和短信通知，这里采用异步发送

// 发货会发送通知短信给用户:          *

// "您的订单已经发货，快递公司 {1}，快递单 {2} ，请注意查收"

notifyService.notifySmsTemplate(order.getMobile(), NotifyType.SHIP, new String[]{shipChannel, shipSn});

logHelper.logOrderSucceed("发货", "订单编号 " + orderId);

return ResponseUtil.ok();

}

/**

* 回复订单商品

*

* @param body 订单信息，{ orderId：xxx }

* @return 订单操作结果

* 成功则 { errno: 0, errmsg: '成功' }

* 失败则 { errno: XXX, errmsg: XXX }

*/

public Object reply(String body) {

Integer commentId = JacksonUtil.parseInteger(body, "commentId");

if (commentId == null || commentId == 0) {

return ResponseUtil.badArgument();

}

// 目前只支持回复一次

if (commentService.findById(commentId) != null) {

return ResponseUtil.fail(ORDER_REPLY_EXIST, "订单商品已回复！");

}

String content = JacksonUtil.parseString(body, "content");

if (StringUtils.isEmpty(content)) {

return ResponseUtil.badArgument();

}

// 创建评价回复

LitemallComment comment = new LitemallComment();

comment.setType((byte) 2);

comment.setValueId(commentId);

comment.setContent(content);

comment.setUserId(0);                 // 评价回复没有用

comment.setStar((short) 0);           // 评价回复没有用

comment.setHasPicture(false);        // 评价回复没有用

comment.setPicUrls(new String[]{});  // 评价回复没有用

commentService.save(comment);

return ResponseUtil.ok();

}

}

操作日志管理服务

/**

* 这里的日志类型设计成四种（当然开发者需要可以自己扩展）

* 一般日志：用户觉得需要查看的一般操作日志，建议是默认的日志级别

* 安全日志：用户安全相关的操作日志，例如登录、删除管理员

* 订单日志：用户交易相关的操作日志，例如订单发货、退款

* 其他日志：如果以上三种不合适，可以选择其他日志，建议是优先级最低的日志级别

*

* 当然可能很多操作是不需要记录到数据库的，例如编辑商品、编辑广告品之类。

*/

@Component

public class LogHelper {

public final static Integer LOG_TYPE_GENERAL = 0;

public final static Integer LOG_TYPE_AUTH = 1;

public final static Integer LOG_TYPE_ORDER = 2;

public final static Integer LOG_TYPE_OTHER = 3;

@Autowired

private LitemallLogService logService;

public void logGeneralSucceed(String action){

logAdmin(LOG_TYPE_GENERAL, action, true, "", "");

}

public void logGeneralSucceed(String action, String result){

logAdmin(LOG_TYPE_GENERAL, action, true, result, "");

}

public void logGeneralFail(String action, String error){

logAdmin(LOG_TYPE_GENERAL, action, false, error, "");

}

public void logAuthSucceed(String action){

logAdmin(LOG_TYPE_AUTH, action, true, "", "");

}

public void logAuthSucceed(String action, String result){

logAdmin(LOG_TYPE_AUTH, action, true, result, "");

}

public void logAuthFail(String action, String error){

logAdmin(LOG_TYPE_AUTH, action, false, error, "");

}

public void logOrderSucceed(String action){

logAdmin(LOG_TYPE_ORDER, action, true, "", "");

}

public void logOrderSucceed(String action, String result){

logAdmin(LOG_TYPE_ORDER, action, true, result, "");

}

public void logOrderFail(String action, String error){

logAdmin(LOG_TYPE_ORDER, action, false, error, "");

}

public void logOtherSucceed(String action){

logAdmin(LOG_TYPE_OTHER, action, true, "", "");

}

public void logOtherSucceed(String action, String result){

logAdmin(LOG_TYPE_OTHER, action, true, result, "");

}

public void logOtherFail(String action, String error){

logAdmin(LOG_TYPE_OTHER, action, false, error, "");

}

public void logAdmin (Integer type, String action, Boolean succeed, String result, String comment){

LitemallLog log = new LitemallLog();

Subject currentUser = SecurityUtils.getSubject();

if(currentUser != null) {

LitemallAdmin admin = (LitemallAdmin) currentUser.getPrincipal();

if(admin != null) {

log.setAdmin(admin.getUsername());

}

else{

log.setAdmin("匿名用户");

}

}

else{

log.setAdmin("匿名用户");

}

HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();

if(request != null) {

log.setIp(IpUtil.getIpAddr(request));

}

log.setType(type);

log.setAction(action);

log.setStatus(succeed);

log.setResult(result);

log.setComment(comment);

logService.add(log);

}

}

顾客（会员）身份认证

public class AdminAuthorizingRealm extends AuthorizingRealm {

private static final Logger log = LoggerFactory.getLogger(AdminAuthorizingRealm.class);

@Autowired

private LitemallAdminService adminService;

@Autowired

private LitemallRoleService roleService;

@Autowired

private LitemallPermissionService permissionService;

@Override

protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {

if (principals == null) {

throw new AuthorizationException("PrincipalCollection method argument cannot be null.");

}

LitemallAdmin admin = (LitemallAdmin) getAvailablePrincipal(principals);

Integer[] roleIds = admin.getRoleIds();

Set<String> roles = roleService.queryByIds(roleIds);

Set<String> permissions = permissionService.queryByRoleIds(roleIds);

SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();

info.setRoles(roles);

info.setStringPermissions(permissions);

return info;

}

@Override

protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

UsernamePasswordToken upToken = (UsernamePasswordToken) token;

String username = upToken.getUsername();

String password=new String(upToken.getPassword());

if (StringUtils.isEmpty(username)) {

throw new AccountException("用户名不能为空");

}

if (StringUtils.isEmpty(password)) {

throw new AccountException("密码不能为空");

}

List<LitemallAdmin> adminList = adminService.findAdmin(username);

Assert.state(adminList.size() < 2, "同一个用户名存在两个账户");

if (adminList.size() == 0) {

throw new UnknownAccountException("找不到用户（"+username+"）的帐号信息");

}

LitemallAdmin admin = adminList.get(0);

BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();

if (!encoder.matches(password, admin.getPassword())) {

throw new UnknownAccountException("找不到用户（"+username+"）的帐号信息");

}

return new SimpleAuthenticationInfo(admin,password,getName());

}

}

广告管理控制器

Ps:其他控制器与此类似，不在一一冗赘

@RestController

@RequestMapping("/admin/ad")

@Validated

public class AdminAdController {

private final Log logger = LogFactory.getLog(AdminAdController.class);

@Autowired

private LitemallAdService adService;

@RequiresPermissions("admin:ad:list")

@RequiresPermissionsDesc(menu={"推广管理" , "广告管理"}, button="查询")

@GetMapping("/list")

public Object list(String name, String content,

@RequestParam(defaultValue = "1") Integer page,

@RequestParam(defaultValue = "10") Integer limit,

@Sort @RequestParam(defaultValue = "add_time") String sort,

@Order @RequestParam(defaultValue = "desc") String order) {

List<LitemallAd> adList = adService.querySelective(name, content, page, limit, sort, order);

return ResponseUtil.okList(adList);

}

private Object validate(LitemallAd ad) {

String name = ad.getName();

if (StringUtils.isEmpty(name)) {

return ResponseUtil.badArgument();

}

String content = ad.getContent();

if (StringUtils.isEmpty(content)) {

return ResponseUtil.badArgument();

}

return null;

}

@RequiresPermissions("admin:ad:create")

@RequiresPermissionsDesc(menu={"推广管理" , "广告管理"}, button="添加")

@PostMapping("/create")

public Object create(@RequestBody LitemallAd ad) {

Object error = validate(ad);

if (error != null) {

return error;

}

adService.add(ad);

return ResponseUtil.ok(ad);

}

@RequiresPermissions("admin:ad:read")

@RequiresPermissionsDesc(menu={"推广管理" , "广告管理"}, button="详情")

@GetMapping("/read")

public Object read(@NotNull Integer id) {

LitemallAd ad = adService.findById(id);

return ResponseUtil.ok(ad);

}

@RequiresPermissions("admin:ad:update")

@RequiresPermissionsDesc(menu={"推广管理" , "广告管理"}, button="编辑")

@PostMapping("/update")

public Object update(@RequestBody LitemallAd ad) {

Object error = validate(ad);

if (error != null) {

return error;

}

if (adService.updateById(ad) == 0) {

return ResponseUtil.updatedDataFailed();

}

return ResponseUtil.ok(ad);

}

@RequiresPermissions("admin:ad:delete")

@RequiresPermissionsDesc(menu={"推广管理" , "广告管理"}, button="删除")

@PostMapping("/delete")

public Object delete(@RequestBody LitemallAd ad) {

Integer id = ad.getId();

if (id == null) {

return ResponseUtil.badArgument();

}

adService.deleteById(id);

return ResponseUtil.ok();

}

}

数据库操作部分

Ps:其他操作和对商品品牌数据库表操作类似，再次不在冗赘。

商品品牌数据库表操作

@Service

publicclassLitemallBrandService {

@Resource

privateLitemallBrandMapperbrandMapper;

privateColumn[] columns = newColumn[]{Column.id, Column.name, Column.desc, Column.picUrl, Column.floorPrice};

publicList<LitemallBrand> query(Integerpage, Integerlimit, Stringsort, Stringorder) {

LitemallBrandExampleexample = newLitemallBrandExample();

example.or().andDeletedEqualTo(false);

if (!StringUtils.isEmpty(sort) && !StringUtils.isEmpty(order)) {

example.setOrderByClause(sort + " " + order);

}

PageHelper.startPage(page, limit);

returnbrandMapper.selectByExampleSelective(example, columns);

}

publicList<LitemallBrand> query(Integerpage, Integerlimit) {

returnquery(page, limit, null, null);

}

publicLitemallBrandfindById(Integerid) {

returnbrandMapper.selectByPrimaryKey(id);

}

publicList<LitemallBrand> querySelective(Stringid, Stringname, Integerpage, Integersize, Stringsort, Stringorder) {

LitemallBrandExampleexample = newLitemallBrandExample();

LitemallBrandExample.Criteriacriteria = example.createCriteria();

if (!StringUtils.isEmpty(id)) {

criteria.andIdEqualTo(Integer.valueOf(id));

}

if (!StringUtils.isEmpty(name)) {

criteria.andNameLike("%" + name + "%");

}

criteria.andDeletedEqualTo(false);

if (!StringUtils.isEmpty(sort) && !StringUtils.isEmpty(order)) {

example.setOrderByClause(sort + " " + order);

}

PageHelper.startPage(page, size);

returnbrandMapper.selectByExample(example);

}

publicintupdateById(LitemallBrandbrand) {

brand.setUpdateTime(LocalDateTime.now());

returnbrandMapper.updateByPrimaryKeySelective(brand);

}

publicvoiddeleteById(Integerid) {

brandMapper.logicalDeleteByPrimaryKey(id);

}

publicvoidadd(LitemallBrandbrand) {

brand.setAddTime(LocalDateTime.now());

brand.setUpdateTime(LocalDateTime.now());

brandMapper.insertSelective(brand);

}

publicList<LitemallBrand> all() {

LitemallBrandExampleexample = newLitemallBrandExample();

example.or().andDeletedEqualTo(false);

returnbrandMapper.selectByExample(example);

}

}

核心操作部分

Ps:其他核心操作同存储（商品信息、图片对象等）操作、物流查询服务类似，不在冗赘。

存储操作

/**

* 对象存储接口

*/

publicinterfaceStorage {

/**

* 存储一个文件对象

*

* @paraminputStream   文件输入流

* @paramcontentLength文件长度

* @paramcontentType   文件类型

* @paramkeyName       文件名

*/

voidstore(InputStreaminputStream, longcontentLength, StringcontentType, StringkeyName);

Stream<Path> loadAll();

Pathload(StringkeyName);

ResourceloadAsResource(StringkeyName);

voiddelete(StringkeyName);

StringgenerateUrl(StringkeyName);

}

物流查询服务

/**

* 物流查询服务

*

* 快递鸟即时查询API http://www.kdniao.com/api-track

*/

public class ExpressService {

//请求url

private String ReqURL = "http://api.kdniao.com/Ebusiness/EbusinessOrderHandle.aspx";

private ExpressProperties properties;

public ExpressProperties getProperties() {

return properties;

}

public void setProperties(ExpressProperties properties) {

this.properties = properties;

}

/**

* 获取物流供应商名

*

* @param vendorCode

* @return

*/

public String getVendorName(String vendorCode) {

for (Map<String, String> item : properties.getVendors()) {

if (item.get("code").equals(vendorCode))

return item.get("name");

}

return null;

}

/**

* 获取物流信息

*

* @param expCode

* @param expNo

* @return

*/

public ExpressInfo getExpressInfo(String expCode, String expNo) {

try {

String result = getOrderTracesByJson(expCode, expNo);

ObjectMapper objMap = new ObjectMapper();

ExpressInfo ei = objMap.readValue(result, ExpressInfo.class);

ei.setShipperName(getVendorName(expCode));

return ei;

} catch (Exception e) {

e.printStackTrace();

}

return null;

}

/**

* Json方式 查询订单物流轨迹

*

* @throws Exception

*/

private String getOrderTracesByJson(String expCode, String expNo) throws Exception {

if (!properties.isEnable()) {

return null;

}

String requestData = "{'OrderCode':'','ShipperCode':'" + expCode + "','LogisticCode':'" + expNo + "'}";

Map<String, String> params = new HashMap<String, String>();

params.put("RequestData", URLEncoder.encode(requestData, "UTF-8"));

params.put("EBusinessID", properties.getAppId());

params.put("RequestType", "1002");

String dataSign = encrypt(requestData, properties.getAppKey(), "UTF-8");

params.put("DataSign", URLEncoder.encode(dataSign, "UTF-8"));

params.put("DataType", "2");

String result = HttpUtil.sendPost(ReqURL, params);

//根据公司业务处理返回的信息......

return result;

}

/**

* MD5加密

*

* @param str     内容

* @param charset 编码方式

* @throws Exception

*/

private String MD5(String str, String charset) throws Exception {

MessageDigest md = MessageDigest.getInstance("MD5");

md.update(str.getBytes(charset));

byte[] result = md.digest();

StringBuffer sb = new StringBuffer(32);

for (int i = 0; i < result.length; i++) {

int val = result[i] & 0xff;

if (val <= 0xf) {

sb.append("0");

}

sb.append(Integer.toHexString(val));

}

return sb.toString().toLowerCase();

}

/**

* Sign签名生成

*

* @param content  内容

* @param keyValue Appkey

* @param charset  编码方式

* @return DataSign签名

*/

private String encrypt(String content, String keyValue, String charset) {

if (keyValue != null) {

content = content + keyValue;

}

byte[] src = new byte[0];

try {

src = MD5(content, charset).getBytes(charset);

return Base64Utils.encodeToString(src);

} catch (Exception e) {

e.printStackTrace();

}

return null;

}

}