微信点餐系统技术总结

1.项目开发步骤

1.项目设计

1.角色划分

买家端(手机端) 卖家端(PC端)

2.功能模块划分

详细设计个各个功能模块

买家卖家

商品: 商品列表数据

订单: 订单创建订单查询订单取消 ...

类目: 订单管理商品管理类目管理 ...

2.架构和基础框架

SSH 框架的了解和使用

Mybatis 的两种配置方法

Redis 的缓存作用分布式锁

Aop 身份验证

等等

3.数据库设计

设计表的成员表与表之间的关系确定每个表的主键设计属性之间的关联...

4开发日志的使用

这里用Slf4j

1.导入依赖

<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>

2.加上注解

@Slf4j

3..使用

log.error("【创建订单】购物车不能为空");

log.info("【微信支付】发起支付request={}",JsonUtil.toJson(payRequest));

5. Logback的配置

需求:区分info 和error 日志 ,每天产生一个日志文件.

1.application.xml文件的配置

logging:
  pattern:
    console: "%d - %msg%n"
  path: /var/log/tomcat/
  file: /var/log/tomcat/sell.log
  level:
    com.imooc.LoggerTest: debug

path 和 file 二选一即可

Path:产生文件的位置

File:产生文件的位置和名字

Level: 指定某个类的日志级别

2.Logback-spring.xml配置文件

Resouces目录下建立 Logback-spring.xml配置文件

<?xml version="1.0" encoding="UTF-8" ?>

<filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>ERROR</level>
            
        </filter>

<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            
            <fileNamePattern>/home/hk/log/tomcat/info.%d.log</fileNamePattern>
        </rollingPolicy>
    </appender>

<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
<level>ERROR</level>
</filter>

<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            
            <fileNamePattern>/home/hk/log/tomcat/error.%d.log</fileNamePattern>
        </rollingPolicy>
    </appender>

简单的日志需求选择第一种即可,复杂的需要选择第二种配置

注意: 这里写配置文件时提示不是很友好,不要打错!

6. 买家类目

1.买家类目-dao

1.数据库的连接:

添加依赖:

Mysql的驱动

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>

Jap的驱动

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

配置数据库的信息:

在application.yml配置文件中`配置

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    username: root
    password: 741623
    url: jdbc:mysql://127.0.0.1:3306/food?characterEncoding=utf8&useSSL=false&zeroDateTimeBehavior=convertToNull
  jpa:
    show-sql: true

2.建立和数据表映射过来对应的对象

对象类需要加入

@Entity 注解

导入包 import javax.persistence.Entity

默认下类名和表明一致

类名中除了第一个字母,其他字母的大写在表中会自动用_加对应的小写字母替代

表名: product_category

类名:ProductCategory

也可以加注解来添加映射关系

@Table(name = “ product_category”)

对象里面的属性名也必须和数据表里面的属性名对应

否则需要在属性之前添加注解@Column(name = “属性名”)

对象的主键用 @Id 标识导入下面的包

import javax.persistence.Id;

对象自增用 @GeneratedValue 表示

import javax.persistence.GeneratedValue;

若类名和属性名都与数据表对应, 则这个类就和 product_category数据表建立映射关系.

注意: 建议用默认值

类名前面添加 @Data

导入包import lombok.Data;

依赖文件和之前日志的依赖一样

这个注解可以省去 get 和 set 方法

DAO 层的编写

与对象做关联

public interface ProductCategoryRepository extends JpaRepository<ProductCategory, Integer>

继承接口 JpaRepository<> 第一个参数表明对象类的名称 , 第二个参数表明对象的主键

2.买家类目-service

1.先建立CategoryService接口

在接口中列出可能需要用的方法

再建立CategoryServiceImpl类实现接口 CategoryService

在 CategoryServiceImpl 需要加入注解 @Service

导入包import org.springframework.stereotype.Service;

3.买家类目-controller

由于类目不存在单独给买家端的接口,所以不存在 controller

7.买家商品

基本步骤和上面买家类目实现一样

注重Service的编写

Dao ---> Service ---> Controller

------------------技术技巧------------------------------------------------

1.分页查询

查询的时候传入 Pageable pageable对象可以分页查询

Page<ProductInfo> findAll(Pageable pageable);

导入包 import org.springframework.data.domain.Pageable;

传入Pageable pageable对象返回的时一个 Page<>对象

2.枚举类的使用

当用数字表示一些商品的情况或者订单的情况时,一旦数目过多就容易混淆,

这时候可以用到枚举类 Enum, 可以建立一个单独的包来管理各个枚举类

枚举类可以将对应的数字信息和和文字信息结合起来,可以更加方便的了解数字对应的信息

package com.imooc.enums;

import lombok.Getter;

/**
* 商品状态
* Created by 廖师兄
* 2017-05-09 17:33
*/
@Getter
public enum ProductStatusEnum implements CodeEnum {
    UP(0, "在架"),
    DOWN(1, "下架")
    ;

private Integer code;

private String message;

ProductStatusEnum(Integer code, String message) {
        this.code = code;
        this.message = message;
    }
}

3.封装返回结果

返回给前端的类目信息分三层结构

1. 最外层(ResultVO<T>): 包含code(错误码) , msg(提示信息) , 泛形 T(包含返回的具体信息)

package com.imooc.VO;

import lombok.Data;

/**
* http请求返回的最外层对象
* Created by 廖师兄
* 2017-05-12 14:13
*/
@Data
public class ResultVO<T> {

/** 错误码. */
private Integer code;

/** 提示信息. */
private String msg;

/** 具体内容. */
private T data;
}

2.中间层(ProductVO): 商品类目信息,包含类目名字 , 类目编号 , 商品信息 List (里面包含属于这个类目的商品信息).

package com.imooc.VO;

import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;

import java.util.List;

/**
* 商品(包含类目)
* Created by 廖师兄
* 2017-05-12 14:20
*/
@Data
public class ProductVO {

@JsonProperty("name")
private String categoryName;

@JsonProperty("type")
private Integer categoryType;

@JsonProperty("foods")
private List<ProductInfoVO> productInfoVOList;
}

3.最里层(ProductInfoVO): 商品详情( 包含用户能看到的商品信息 )

package com.imooc.VO;

import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;

import java.math.BigDecimal;

/**
* 商品详情
* Created by 廖师兄
* 2017-05-12 14:25
*/
@Data
public class ProductInfoVO {

@JsonProperty("id")
private String productId;

@JsonProperty("name")
private String productName;

@JsonProperty("price")
private BigDecimal productPrice;

@JsonProperty("description")
private String productDescription;

@JsonProperty("icon")
private String productIcon;
}

4.对查询请求的反应和相应的操作

1.查询所有上架商品

2.查询类目(一次性查询)

这里用到一个 lambda 表达式(从商品对象中获得类目属性)

List<Integer> categoryTypeList = productInfoList.stream()
.map(e -> e.getCategoryType())
.collect(Collectors.toList());

作用是从对象集合productInfoList中抽取一个属性集合 categoryTypeList

作用等价于:

List<Integer> categoryTypeList = new ArrayList<>();
传统方法
for (ProductInfo productInfo : productInfoList) {
categoryTypeList.add(productInfo.getCategoryType());
}

根据获得的类目type属性集合来得到类目对象集合

List<ProductCategory> productCategoryList = categoryService.findByCategoryTypeIn(categoryTypeList);

3.数据拼装(将对应的商品对象添加到对应的类目List下去)

新建一个ProductVO(商品类目信息: 包含类目名字 , 类目编号 , 商品信息 List )的 List

List<ProductVO> productVOList = new ArrayList<>();

对类目对象集合循环遍历

for (ProductCategory productCategory: productCategoryList) {

新建一个ProductVO对象

设置CategoryType和CategoryName 属性值

ProductVO productVO = new ProductVO();
productVO.setCategoryType(productCategory.getCategoryType());
productVO.setCategoryName(productCategory.getCategoryName());

新建一个 ProductInfoVO 的List --->roductInfoVOList

List<ProductInfoVO> productInfoVOList = new ArrayList<>();

在类目循环体内部对商品信息金额和循环遍历

for (ProductInfo productInfo: productInfoList) {

If 判断 : 若满足商品对象的类目属性与当前类目对象的类目属性相同

if (productInfo.getCategoryType().equals(productCategory.getCategoryType())) {

满足上述 if 判断则新建一个 productInfoVO 对象

运用工具类BeanUtils中的copyProperties()方法将productInfo中的属性值拷贝到productInfoVO对象中(拷贝的值包括两个对象中名字和类型一样的属性)

ProductInfoVO productInfoVO = new ProductInfoVO();
BeanUtils.copyProperties(productInfo, productInfoVO);
productInfoVOList.add(productInfoVO);

设置 productVO 的 ProductInfoVOList 的值为 productInfoVOList

productVO.setProductInfoVOList(productInfoVOList);

将 productVO 添加到 productVOList

productVOList.add(productVO);

8.买家订单

Dao --- service --- controller

都是相关逻辑的处理不一一列举了

涉及两张数据表(订单用户信息表和订单商品详情表)

DAO层

订单表接口的方法

Page<OrderMaster> findByBuyerOpenid(String buyerOpenid, Pageable pageable);

订单详情表接口的方法

List<OrderDetail> findByOrderId(String orderId);

买家订单的service接口的方法

/** 创建订单. */
OrderDTO create(OrderDTO orderDTO);

/** 查询单个订单. */
OrderDTO findOne(String orderId);

/** 查询订单列表. */
Page<OrderDTO> findList(String buyerOpenid, Pageable pageable);

/** 取消订单. */
OrderDTO cancel(OrderDTO orderDTO);

/** 完结订单. */
OrderDTO finish(OrderDTO orderDTO);

/** 支付订单. */
OrderDTO paid(OrderDTO orderDTO);

/** 查询订单列表. */
Page<OrderDTO> findList(Pageable pageable);

JSON格式转化为 List

导入依赖

<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
</dependency>

Json格式的 orderForm.getItems() 转化为 List<OrderDetail>

Gson gson = new Gson();

orderDetailList = gson.fromJson(orderForm.getItems(),
new TypeToken<List<OrderDetail>>() {
}.getType());

9.获得微信授权

注: 必须时服务号才能进行微信相关接口开发,订阅号不行

1.手动造轮子

1.设置域名

2.获取 code(code作为换取access_token的票据,每次用户授权带上的code不一样,code只能使用一次,5分钟未使用自动过期).

3.通过code 获得网页受权access_token

2.微信网页授权的第三方SDK

这里是可能是目前最好最全的微信Java开发工具包（SDK）

包括微信支付、开放平台、公众号、企业微信、企业号、小程序等

https://github.com/Wechat-Group/weixin-java-tools

添加Maven引用

注意：以下为最新正式版，最新测试版本号为

<groupId>com.github.binarywang</groupId>

<artifactId>（不同模块参考下文）</artifactId>

</dependency>

· 各模块的artifactId：

o 微信小程序：weixin-java-miniapp

o 微信支付：weixin-java-pay

o 微信开放平台：weixin-java-open

o 公众号：weixin-java-mp

o 企业号/企业微信：weixin-java-cp

8.微信支付

注:由于没有服务号,这一块没有研究

1.微信发起支付(后端)

2.在网页发起支付

3.动态注入参数发起支付

4.微信异步通知

5.微信退款

9.卖家订单

--->service ----->controller

由于之前买家端写了很多代码了,其中与数据交互的dao层在卖家端不用写了

1.Service层(重用买家订单的service层接口)

/** 创建订单. */
OrderDTO create(OrderDTO orderDTO);

/** 查询单个订单. */
OrderDTO findOne(String orderId);

/** 查询订单列表. */
Page<OrderDTO> findList(String buyerOpenid, Pageable pageable);

/** 取消订单. */
OrderDTO cancel(OrderDTO orderDTO);

/** 完结订单. */
OrderDTO finish(OrderDTO orderDTO);

/** 支付订单. */
OrderDTO paid(OrderDTO orderDTO);

/** 查询订单列表. */
Page<OrderDTO> findList(Pageable pageable);

添加一个查询所有用户的订单方法(分页查询)

2.Controller层

(不予具体说明)

10.卖家商品

1. 新增和修改页面

2.修改表单体提交

3.新增功能

4.卖家类目功能开发

11.登录登出

1.分布式下的session

1.什么叫分布式系统

旨在支持应用程序和服务的开发,可以利用物理架构由多个自治的处理元素,不共享主内存,但是通过网络发送消息合作.

三个特点: 1.多节点

2.消息通信(http通信)

3.不共享内存

三个概念: 1.分布式系统

2.集群

3.分布式计算

2.AOP实现身份验证

1.先选取有身份验证的位置做切面

@Pointcut("execution(public * com.imooc.controller.Seller*.*(..))" +
"&& !execution(public * com.imooc.controller.SellerUserController.*(..))")
public void verify() {}

2.在需要验证的方法需要做什么

@Before("verify()")
public void doVerify() {
ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = attributes.getRequest();

//查询cookie
    Cookie cookie = CookieUtil.get(request, CookieConstant.TOKEN);
    if (cookie == null) {
        log.warn("【登录校验】Cookie中查不到token");
        throw new SellerAuthorizeException();
    }

//去redis里查询
    String tokenValue = redisTemplate.opsForValue().get(String.format(RedisConstant.TOKEN_PREFIX, cookie.getValue()));
    if (StringUtils.isEmpty(tokenValue)) {
        log.warn("【登录校验】Redis中查不到token");
        throw new SellerAuthorizeException();
    }
}

3.拦截登录异常,不正常访问将会跳转到登录界面

//拦截登录异常
//http://sell.natapp4.cc/sell/wechat/qrAuthorize?returnUrl=http://sell.natapp4.cc/sell/seller/login
@ExceptionHandler(value = SellerAuthorizeException.class)
public ModelAndView handlerAuthorizeException() {
    return new ModelAndView("redirect:"
    .concat(projectUrlConfig.getWechatOpenAuthorize())
    .concat("/sell/wechat/qrAuthorize")
    .concat("?returnUrl=")
    .concat(projectUrlConfig.getSell())
    .concat("/sell/seller/login"));
}

12.项目相关其他技术

1.mybatis的使用

1.注解使用方式(sql语句写在注解里面)

导入依赖

<dependency>
   <groupId>org.mybatis.spring.boot</groupId>
   <artifactId>mybatis-spring-boot-starter</artifactId>
   <version>1.3.1</version>
</dependency>

创建一个mapper 包

包下建立对应实体类的sql语句操作类

1.通过map的方式插入 sql 语句(一般不用)

//通过 map 的方式
@Insert("insert into product_category(category_name, category_type) values (#{category_name, jdbcType=VARCHAR}, #{category_type, jdbcType=INTEGER})")
int insertByMap(Map<String,Object>map);

2.通过对象的方式插入 sql 语句

//通过对象的方式
//插入
@Insert("insert into product_category(category_name, category_type) values (#{categoryName, jdbcType=VARCHAR}, #{categoryType, jdbcType=INTEGER})")
int insertByObject(ProductCategory productCatrgory);

3.通过类型查询

//通过类型查询
@Select("select *from product_category where category_type = #{categoryType}")
@Results({
        @Result(column = "category_type" , property = "categoryType"),
        @Result(column = "category_id" ,   property = "categoryId"),
        @Result(column = "category_name" , property = "categoryName")

})
ProductCategory findByCategoryType(Integer categoryType);

4.通过名字查询

//通过名字查询
@Select("select *from product_category where category_name = #{categoryName}")
@Results({
        @Result(column = "category_type" , property = "categoryType"),
        @Result(column = "category_id" ,   property = "categoryId"),
        @Result(column = "category_name" , property = "categoryName")

})
List<ProductCategory> findByCategoryName(String categoryName);

5.更新姓名

(传入姓名和type)

//更新姓名
@Update("update product_category set category_name = #{categoryName} where category_type = #{categoryType}")
int updateByCategoryType(@Param("categoryName") String categoryName, @Param("categoryType") Integer categoryType);

(传入对象)

@Update("update product_category set category_name = #{categoryName} where category_type = #{categoryType}")
int updateByObject(ProductCategory productCategory);

6.通过categoryType 删除

@Delete("delete from product_category where category_type = #{categoryType}")
int deleteByCategoryType(Integer categoryType);

2.xml方式的使用(sql语句写在xml文件里面)

Namespace : 接口的位置

Type: 操作的实体类的位置

Id : 方法名

resuletMap: 上面定义的 resuletMap标签

parameterType : 写入参的类型如果入参时个对象,就写入参的路径

<select id="selectByCategoryType" resultMap="BaseResultMap"  parameterType="java.lang.Integer">
    SELECT category_id,category_name,category_type
    FROM product_category
    WHERE category_type = #{category_type , jdbcType = INTEGER}
</select>

完整xml文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<resultMap id="BaseResultMap" type="com.cyg.dataobject.ProductCategory">
         <id column="category_id"  property="categoryId" jdbcType="INTEGER" />
         <id column="category_name"  property="categoryName" jdbcType="VARCHAR" />
         <id column="category_type"  property="categoryType" jdbcType="INTEGER" />
    </resultMap>

    <select id="selectByCategoryType" resultMap="BaseResultMap"  parameterType="java.lang.Integer">
        SELECT category_id,category_name,category_type
        FROM product_category
        WHERE category_type = #{category_type,jdbcType = INTEGER}
    </select>

</mapper>为

接下来在配置文件里面配置

mybatis:
mapper-locations: classpath:mapper/*.xml

在启动类中配置配置文件的位置

@MapperScan(basePackages = "com.cyg.dataobject.mapper")

13.redis的使用

推荐一个网站

www.redis.cn

1.redis分布式锁

package com.cyg.service;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

/**
* @author cyg
* @date 18-3-17 下午5:14
**/
@Component
@Slf4j
public class RedisLock {

@Autowired
private StringRedisTemplate redisTemplate;

public boolean lock(String key , String value){

if (redisTemplate.opsForValue().setIfAbsent(key,value)){
return true;
}

String currentValue  = redisTemplate.opsForValue().get(key);
         //如果锁过期
         if(!StringUtils.isEmpty(currentValue)
                 && Long.parseLong(currentValue) < System.currentTimeMillis()){

//获取上一个锁的时间
String oldValue = redisTemplate.opsForValue().getAndSet(key , value);

if (!StringUtils.isEmpty(oldValue) && oldValue.equals(System.currentTimeMillis())){
return true;
}

}
return false;
}

public void unlock(String key , String value){

try {
             String currentValue = redisTemplate.opsForValue(.get(key);
             if (StringUtils.isEmpty(currentValue) && currentValue.equals(value)){
                 redisTemplate.opsForValue().getOperations().delete(key);
             }
         }catch (Exception e){
               log.error("[redis分布式锁] 解锁异常");
         }
     }

}

2.redis缓存的使用

14.项目部署

15.总结