Java单体架构项目_云霄外卖-特殊点

项目介绍：

定位：

        专门为餐饮企业（餐厅、饭店）定制的一款软件商品
分为：
        管理端：外卖商家使用
        用户端（微信小步伐）：点餐用户使用。
功能架构：

（体现项目中的业务功能模块）

技能选型：

（展示项目中使用到的技能框架和中间件等）

环境搭建

整体架构：

前端：

        管理端使用nginx，使用已经打包好的前端代码，而且Nginx的设置文件中已经设置了反向署理，通过此设置可以将前端哀求转发到后端服务。
        用户端之后再做介绍
后端：

后端框架：

  

1.sky-common子模块中存放的是一些工具类，可以供其他模块使用
2.sky-pojo子模块中存放的是一些entity(实体类)，DTO，VO

3.sky-server子模块中存放的是设置文件、设置类、拦截器、controller、service、mapper、启动类等
版本控制

        使用Git进行版本控制
数据库：

前后端联调：

        使用nginx反向署理：
nginx反向署理：

利益：

使用方法：

接口文档：

前后端分离开辟流程：

设计阶段：

Apifox：

        Apifox是设计阶段使用的工具，管理和维护接口。
开辟阶段：

Swagger：

        Swagger是在开辟阶段使用的框架，资助后端开辟人员做后端的接口测试
介绍：

使用方式：

1.

2.

3.

常用注解：

管理端业务功能编写：

登录功能：

        美满登录功能使用MD5对数据加密

员工管理：

添加员工：

        添加员工时通过ThreadLocal获取执行人id和创建人id
ThreadLocal介绍：

        而且客户端发起的每一次哀求都是一个单独的线程，这样就满足使用ThreadLocal的条件。
ThreadLocal常用方法：

员工分页查询：

        调整LocalDataTime范例数据响应归去的格式

        推荐第二种，只必要一次编码就可以调整全部指定内容
操纵过程：

1.新建一个对象映射器：

1. /**
2. * 对象映射器:基于jackson将Java对象转为json，或者将json转为Java对象
3. * 将JSON解析为Java对象的过程称为 [从JSON反序列化Java对象]
4. * 从Java对象生成JSON的过程称为 [序列化Java对象到JSON]
5. */
6. public class JacksonObjectMapper extends ObjectMapper {
8.     public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
9.     //public static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
10.     public static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm";
11.     public static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";
13.     public JacksonObjectMapper() {
14.         super();
15.         //收到未知属性时不报异常
16.         this.configure(FAIL_ON_UNKNOWN_PROPERTIES, false);
18.         //反序列化时，属性不存在的兼容处理
19.         this.getDeserializationConfig().withoutFeatures(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
21.         SimpleModule simpleModule = new SimpleModule()
22.                 .addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)))
23.                 .addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)))
24.                 .addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)))
25.                 .addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)))
26.                 .addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)))
27.                 .addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)));
29.         //注册功能模块 例如，可以添加自定义序列化器和反序列化器
30.         this.registerModule(simpleModule);
31.     }
32. }

复制代码

2.在设置类中添加如下代码：

1.     /**
2.      * 扩展MVC框架的消息转换器
3.      * @param converters
4.      */
5.     @Override
6.     protected void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
7.         log.info("开始扩展消息转换器");
9.         //创建一个消息转换器对象
10.         MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
12.         //设置对象转换器，可以将java对象转为json对象
13.         converter.setObjectMapper(new JacksonObjectMapper());
15.         //将自己的转换器放入spring MVC框架的容器中，并放到0索引位置，排到第一个，这样一定会使用它
16.         converters.add(0, converter);
17.     }

复制代码

公共字段自动填充：

枚举类：

1. /**
2. * 数据库操作类型
3. */
4. public enum OperationType {
6.     /**
7.      * 更新操作
8.      */
9.     UPDATE,
11.     /**
12.      * 插入操作
13.      */
14.     INSERT
16. }

复制代码

自界说注解：

1. /**
2. * 自定义注解，用于标识需要进行公共字段自动填充的方法
3. */
4. @Target(ElementType.METHOD)
5. @Retention(RetentionPolicy.RUNTIME)
6. public @interface AutoFill {
8.     /**
9.      * 枚举类 自定义数据库操作类型insert和update操作
10.      * @return
11.      */
12.     OperationType value();
14. }

复制代码

自界说切面类：

1. /**
2. * 自定义切面，实现公共字段自动填充处理逻辑
3. */
4. @Aspect
5. @Component
6. @Slf4j
7. public class AutoFillAspect {
9.     /**
10.      * 切入点
11.      */
12.     @Pointcut("execution(* com.sky.mapper.*.*(..)) && @annotation(com.sky.annotation.AutoFill)")
13.     public void autoFillPointCut() {}
15.     /**
16.      * 前置通知，为公共字段赋值
17.      */
18.     @Before("autoFillPointCut()")
19.     public void autoFill(JoinPoint joinPoint) {
20.         log.info("开始进行公共字段填充...");
21.         //获取到当前被拦截方法上的数据库操作类型
22.         MethodSignature signature = (MethodSignature) joinPoint.getSignature();//方法签名对象
23.         AutoFill autoFill = signature.getMethod().getAnnotation(AutoFill.class);//获得方法上的注解
24.         OperationType operationType = autoFill.value();//获得数据库操作类型
26.         //获取到当前被拦截方法的参数--实体对象
27.         Object[] args = joinPoint.getArgs();
28.         Object entity = args[0];
30.         //准备赋值的数据
31.         LocalDateTime now = LocalDateTime.now();
32.         Long currentId = BaseContext.getCurrentId();
34.         //根据当前不同的操作类型，为对应的属性通过反射来赋值
35.         if(operationType == OperationType.INSERT) {
36.             try {
37.                 Method setCreateTime = entity.getClass().getMethod(AutoFillConstant.SET_CREATE_TIME, LocalDateTime.class);
38.                 Method setCreateUser = entity.getClass().getMethod(AutoFillConstant.SET_CREATE_USER, Long.class);
39.                 Method setUpdateTime = entity.getClass().getMethod(AutoFillConstant.SET_UPDATE_TIME, LocalDateTime.class);
40.                 Method setUpdateUser = entity.getClass().getMethod(AutoFillConstant.SET_UPDATE_USER, Long.class);
41.                 setCreateTime.invoke(entity,now);
42.                 setCreateUser.invoke(entity,currentId);
43.                 setUpdateTime.invoke(entity,now);
44.                 setUpdateUser.invoke(entity,currentId);
45.             } catch (Exception e) {
46.                 e.printStackTrace();
47.             }
48.         } else if(operationType == OperationType.UPDATE) {
49.             try {
50.                 Method setUpdateTime = entity.getClass().getMethod(AutoFillConstant.SET_UPDATE_TIME, LocalDateTime.class);
51.                 Method setUpdateUser = entity.getClass().getMethod(AutoFillConstant.SET_UPDATE_USER, Long.class);
52.                 setUpdateTime.invoke(entity,now);
53.                 setUpdateUser.invoke(entity,currentId);
54.             } catch (Exception e) {
55.                 e.printStackTrace();
56.             }
57.         }
59.     }
61. }

复制代码

给mapper层的insert和update数据库操纵范例添加自界说的注解：
        @AutoFill(OperationType.UPDATE)或@AutoFill(OperationType.INSERT)

留意点：

        ·在菜品分页查询部门，可能传来的参数：status状态在动态SQL里只能判断其为null，不能加上and status = ''，这样会一直读取不到它，详细原因不清楚。
        ·<set>标签下的<if>标签中的内容记得加逗号

操纵Redis：

        想要了解Redis的底子知识及使用方法可以参考作者另一边文章《Java_中间件——Redis》
Redis的Java客户端：

        下面我们使用Spring Data Redis来操纵Redis
Spring Data Redis使用方式：

设置类RedisTemplate：

1. @Configuration
2. @Slf4j
3. public class RedisConfiguration {
5.     @Bean
6.     public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
7.         log.info("开始创建redis模板对象...");
8.         RedisTemplate redisTemplate = new RedisTemplate();
9.         //设置redis连接工厂对象
10.         redisTemplate.setConnectionFactory(redisConnectionFactory);
11.         //设置redis key的序列化器
12.         redisTemplate.setKeySerializer(new StringRedisSerializer());
13.         return redisTemplate;
14.     }
16. }

复制代码

代码演示：

1.     @Autowired
2.     private RedisTemplate redisTemplate;
4.     @Test
5.     public void testRedisTemplate() {
6.         System.out.println(redisTemplate);
7.         //操作字符串
8.         ValueOperations valueOperations = redisTemplate.opsForValue();
9.         //操作Hash
10.         HashOperations hashOperations = redisTemplate.opsForHash();
11.         //操作List
12.         ListOperations listOperations = redisTemplate.opsForList();
13.         //操作set
14.         SetOperations setOperations = redisTemplate.opsForSet();
15.         //操作有序集合
16.         ZSetOperations zSetOperations = redisTemplate.opsForZSet();
18.     }
20.     /**
21.      * 操作字符串类型的数据
22.      */
23.     @Test
24.     public void testStirng() {
25.         // set get setex setnx
26.         redisTemplate.opsForValue().set("city","北京");
27.         String city = (String) redisTemplate.opsForValue().get("city");
28.         System.out.println(city);
29.         redisTemplate.opsForValue().set("code","6562",60, TimeUnit.SECONDS);
30.         redisTemplate.opsForValue().setIfAbsent("lock","1");
31.         redisTemplate.opsForValue().setIfAbsent("lock","2");
32.     }
34.     /**
35.      * 操作哈希类型的数据
36.      */
37.     @Test
38.     public void testHash() {
39.         //hset hget hdel hkeys hvals
40.         HashOperations hashOperations = redisTemplate.opsForHash();
42.         hashOperations.put("100","name","xiaobai");
43.         hashOperations.put("100","age","20");
45.         String name = (String) hashOperations.get("100", "name");
46.         System.out.println(name);
48.         Set keys = hashOperations.keys("100");
49.         System.out.println(keys);
51.         List values = hashOperations.values("100");
52.         System.out.println(values);
54.         hashOperations.delete("100","age");
55.     }
57.     /**
58.      * 操作列表类型的数据
59.      */
60.     @Test
61.     public void testList() {
62.         // lpush lrange rpop llen
63.         ListOperations listOperations = redisTemplate.opsForList();
65.         listOperations.leftPushAll("mylist","a","b","c");
66.         listOperations.leftPush("mylist","d");
68.         List mylist = listOperations.range("mylist", 0, -1);
69.         System.out.println(mylist);
71.         listOperations.rightPop("mylist");
73.         Long size = listOperations.size("mylist");
74.         System.out.println(size);
76.     }
78.     /**
79.      * 操作集合类型的数据
80.      */
81.     @Test
82.     public void testSet() {
83.         // sadd smembers scard sinter sunion srem
84.         SetOperations setOperations = redisTemplate.opsForSet();
86.         setOperations.add("set1","a","b","c");
87.         setOperations.add("set2","b","c","d");
89.         Set set1 = setOperations.members("set1");
90.         System.out.println(set1);
92.         Long size = setOperations.size("set1");
93.         System.out.println(size);
95.         Set intersect = setOperations.intersect("set1", "set2");
96.         System.out.println(intersect);
98.         Set union = setOperations.union("set1", "set2");
99.         System.out.println(union);
101.         setOperations.remove("set1","a","b");
103.     }
105.     /**
106.      * 操作有序集合类型的数据
107.      */
108.     @Test
109.     public void testZSet() {
110.         // zadd zrange zincrby zrem
111.         ZSetOperations zSetOperations = redisTemplate.opsForZSet();
113.         zSetOperations.add("zset1","a",10);
114.         zSetOperations.add("zset1","b",11);
115.         zSetOperations.add("zset1","c",9);
117.         Set zset1 = zSetOperations.range("zset1", 0, -1);
118.         System.out.println(zset1);
120.         zSetOperations.incrementScore("zset1","c",10);
122.         zSetOperations.remove("zset1","a","b");
123.     }
125.     /**
126.      * 通用命令操作
127.      */
128.     @Test
129.     public void testCommon() {
130.         // keys exists type del
131.         Set keys = redisTemplate.keys("*");
132.         System.out.println(keys);
134.         Boolean name = redisTemplate.hasKey("name");
135.         Boolean set1 = redisTemplate.hasKey("set1");
137.         for (Object key : keys) {
138.             DataType type = redisTemplate.type(key);
139.             System.out.println(type.name());
140.         }
142.         redisTemplate.delete("mylist");
144.     }

复制代码

店铺营业状态设置：

        基于Redis的字符串来进行存储
        

        1表现营业，0表现打样
代码演示：

管理端设置营业状态、获取营业状态

1. @RequestMapping("/admin/shop")
2. @RestController("adminShopController")
3. @Slf4j
4. @Api(tags = "店铺相关接口")
5. public class ShopController {
7.     public static final String KEY = "SHOP_STATUS";
9.     @Autowired
10.     private RedisTemplate redisTemplate;
12.     /**
13.      * 设置店铺的营业状态
14.      * @param status
15.      * @return
16.      */
17.     @PutMapping("/{status}")
18.     @ApiOperation("设置营业状态")
19.     public Result setStatus(@PathVariable Integer status) {
20.         redisTemplate.opsForValue().set(KEY,status);
21.         log.info("设置当前营业状态为:{}",status == 1 ? "营业中" : "打烊中");
22.         return Result.success();
23.     }
25.     @GetMapping("/status")
26.     @ApiOperation("管理端获取营业状态")
27.     public Result<Integer> getStatus() {
28.         Integer status = (Integer) redisTemplate.opsForValue().get(KEY);
29.         log.info("当前的营业状态为:{}",status == 1 ? "营业中":"打烊中");
30.         return Result.success(status);
31.     }
33. }

复制代码

用户端获取营业状态

1. @RequestMapping("/user/shop")
2. @RestController("userShopController")
3. @Slf4j
4. @Api(tags = "店铺相关接口")
5. public class ShopController {
7.     public static final String KEY = "SHOP_STATUS";
9.     @Autowired
10.     private RedisTemplate redisTemplate;
12.     @GetMapping("/status")
13.     @ApiOperation("用户端获取营业状态")
14.     public Result<Integer> getStatus() {
15.         Integer status = (Integer) redisTemplate.opsForValue().get(KEY);
16.         log.info("当前的营业状态为:{}",status == 1 ? "营业中":"打烊中");
17.         return Result.success(status);
18.     }
20. }

复制代码

HttpClient

使用HttpCilent必要导入依赖：
（如果导入了阿里云OSS的依赖就不必要导入了，由于这个依赖中已经包罗了这个依赖）

核心API：

发送哀求步调：

代码演示：

1.     /**
2.      * 测试通过HttpClient发送GET方式的请求
3.      */
4.     @Test
5.     public void testGET() throws Exception {
6.        //创建HttpClient对象
7.         CloseableHttpClient httpClient = HttpClients.createDefault();
9.         //创建请求对象
10.         HttpGet httpGet = new HttpGet("http://localhost:8080/user/shop/status");
12.         //发送请求，接收响应结果
13.         CloseableHttpResponse response = httpClient.execute(httpGet);
15.         //解析结果
16.         //获取服务端返回的状态码
17.         int statusCode = response.getStatusLine().getStatusCode();
18.         System.out.println("服务端返回的状态码为:" + statusCode);
19.         //获取服务端返回数据
20.         HttpEntity entity = response.getEntity();
21.         String body = EntityUtils.toString(entity);
22.         System.out.println("服务端返回的数据为:" + body);
24.         //关闭资源
25.         response.close();
26.         httpClient.close();
28.     }
30.     /**
31.      * 测试通过HttpClient发送GET方式的请求
32.      */
33.     @Test
34.     public void testPOST() throws Exception {
35.         //创建HttpClient对象
36.         CloseableHttpClient httpClient = HttpClients.createDefault();
38.         //创建请求对象
39.         HttpPost httpPost = new HttpPost("http://localhost:8080/admin/employee/login");
40.         JSONObject jsonObject = new JSONObject();
41.         jsonObject.put("username", "admin");
42.         jsonObject.put("password", "123456");
43.         StringEntity entity = new StringEntity(jsonObject.toString());
44.         //指定请求编码方式
45.         entity.setContentEncoding("UTF-8");
46.         //指定数据格式
47.         entity.setContentType("application/json");
48.         httpPost.setEntity(entity);
50.         //发送请求
51.         CloseableHttpResponse response = httpClient.execute(httpPost);
53.         //解析返回结果
54.         int statusCode = response.getStatusLine().getStatusCode();
55.         System.out.println("响应码为：" + statusCode);
56.         HttpEntity entity1 = response.getEntity();
57.         String body = EntityUtils.toString(entity1);
58.         System.out.println("响应数据为：" + body);
60.         //关闭资源
61.         response.close();
62.         httpClient.close();
64.     }

复制代码

用户端微信小步伐开辟：

小步伐目次结构：

主体：

页面：

微信登录过程：

Redis缓存菜品、套餐

原因：

        使用数据库一直查找会导致体系响应慢、用户体验差。以是使用Redis缓存。
缓存菜品：

实现思路：

Spring Cache：

常用注解：

                                                                                                                     (cacheName::key)↑
@Cacheable注解在方法执行前会通过动态署理，署理出一个Controller对象，然后判断缓存中是否有数据，如果有，则直接返回缓存数据，不再执行方法，如果没有，就会通过反射来调用方法。
删除全部：

Spring Task

定位：

        定时使命框架

cron表达式：

        留意：日和周只能一个填数值一个填？
        使用Spring Task对超时订单和一直配送中的订单进行处置惩罚

WebSocket

介绍：

应用场景：

        ·视频弹幕
        ·网页谈天
        ·体育实况更新
        ·股票基金报价实时更新
实现步调：

       
         使用WebSocket来完成来单提醒和客户催单功能。
设计：

Apache POI

介绍：

应用场景：

创新点：

        1.用户端根据分类id查看菜品：通过在service、mapper层添加获取在售(status=1)商品/套餐方法，替代通过创建实体类对象进行list方法查找，将查询时间由5~17ms变为4~7ms。
        2.将工作台订单数据使用redis存储，实时更新。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。