微信点餐系统技术总结
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" ?>
<configuration>
<appender name="consoleLog" class="ch.qos.logback.core.ConsoleAppender">
<layout class="ch.qos.logback.classic.PatternLayout">
<pattern>
%d - %msg%n
</pattern>
</layout>
</appender>
<appender name="fileInfoLog" class="ch.qos.logback.core.rolling.RollingFileAppender">
<filter class="ch.qos.logback.classic.filter.LevelFilter">
<level>ERROR</level>
<!--<onMatch>DENY</onMatch>
<onMismatch>ACCEPT</onMismatch>-->
</filter>
<encoder>
<pattern>
%msg%n
</pattern>
</encoder>
<!--滚动策略-->
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!--路径 -->
<fileNamePattern>/home/hk/log/tomcat/info.%d.log</fileNamePattern>
</rollingPolicy>
</appender>
<appender name="fileErrorLog" class="ch.qos.logback.core.rolling.RollingFileAppender">
<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
<level>ERROR</level>
</filter>
<encoder>
<pattern>
%msg%n
</pattern>
</encoder>
<!--滚动策略-->
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!--路径 -->
<fileNamePattern>/home/hk/log/tomcat/error.%d.log</fileNamePattern>
</rollingPolicy>
</appender>
<root level="info">
<appender-ref ref="consoleLog"/>
<appender-ref ref="fileInfoLog"/>
<appender-ref ref="fileErrorLog"/>
</root>
</configuration>
简单的日志需求选择第一种即可,复杂的需要选择第二种配置
注意: 这里写配置文件时提示不是很友好,不要打错!
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引用
<dependency>
<groupId>com.github.binarywang</groupId>
<artifactId>（不同模块参考下文）</artifactId>
<version>2.9.0</version>
</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 : 接口的位置
<mapper namespace="com.cyg.dataobject.mapper.ProductCategoryMapper">
Type: 操作的实体类的位置
<id 实体类的属性 />
<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>
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">
<mapper namespace="com.cyg.dataobject.mapper.ProductCategoryMapper">
<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的使用
推荐一个网站
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分布式锁] 解锁异常");
}
}
}
775
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
