SpringCloud（3）——SpringDataJpa之EntityManager的CRUD

最新推荐文章于 2022-03-29 09:21:54 发布
詹小布
最新推荐文章于 2022-03-29 09:21:54 发布
阅读量168
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/xushuyi/articles/6673040.html
版权
废话少说，直接上代码
如果不采用自动注入方式，也是是可以采用手工开启EntityManager事物的，具体参照：http://www.cnblogs.com/wwzyy/p/5896220.html
package com.sinosoft.service.impl;

import com.sinosoft.common.CommonUtil;
import com.sinosoft.common.DateUtil;
import com.sinosoft.config.Constant;
import com.sinosoft.dto.MessagePageReqDTO;
import com.sinosoft.dto.MessagePageResDTO;
import com.sinosoft.dto.MessageTypeReqDTO;
import com.sinosoft.dto.MessagetypeResDTO;
import com.sinosoft.dto.common.RequestInfo;
import com.sinosoft.dto.common.ResponseInfo;
import com.sinosoft.feign.RunGroupFeignClient;
import com.sinosoft.repository.MessageinfoRepository;
import com.sinosoft.service.MessageInfoService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import java.io.UnsupportedEncodingException;
import java.util.*;

/**
 * Created by xushuyi on 2017/3/9.
 */
@Service
public class MessageInfoServiceImpl implements MessageInfoService {

    private static final Logger LOGGER = LoggerFactory.getLogger(MessageInfoServiceImpl.class);

    @Autowired
    private MessageinfoRepository messageinfoRepository;

    @Autowired
    private RunGroupFeignClient runGroupFeignClient;

    @PersistenceContext
    private EntityManager entityManager;

    /**
     * 根据设备Token获取对应消息类型列表数据
     *
     * @return T
     */
    @Override
    public ResponseInfo<MessagetypeResDTO> findMessType(MessageTypeReqDTO messageTypeReqDTO) {
        //校验入参信息
        String messageTypeStr = messageTypeReqDTO.getMessageType();
        if (CommonUtil.isEmpty(messageTypeStr)) {
            LOGGER.error("消息类型列表不能为空！");
            return new ResponseInfo<>(false, "消息类型列表不能为空！", 400);
        }
        String token = messageTypeReqDTO.getToken();
        if (CommonUtil.isEmpty(token)) {
            LOGGER.error("设备Token不能为空！");
            return new ResponseInfo<>(false, "设备Token不能为空！", 400);
        }
        String[] messageTypeList = messageTypeStr.split(",");
        List<Map<String, Object>> resList = new ArrayList<Map<String, Object>>();
        //开始遍历消息类型列表
        for (String messageType : messageTypeList) {
            Map<String, Object> retMap = new HashMap<String, Object>();
            retMap.put("messageTypeCode", messageType);
            //获取系统通知、活动通知、i动小编对应消息数据
            if (messageType.equals(Constant.SYS_TZ_CODE)
                    || messageType.equals(Constant.ACTIVITY_TZ_CODE)
                    || messageType.equals(Constant.IMOVE_TZ_CODE)) {
                retMap.put("messageTypeName", switchMessageTypeName(messageType));//消息类型名称
                //获取未读消息数量
                Map<String, Object> map = messageinfoRepository.
                        findMessageNum(Constant.READ_STATE_N, messageType, token);
                retMap.put("messageCount", map.get("num"));//未读消息数量
                //创建一个排序及分页对象
                List<Sort.Order> orders = new ArrayList<Sort.Order>();
                orders.add(new Sort.Order(Sort.Direction.DESC, "messagedate"));
                orders.add(new Sort.Order(Sort.Direction.DESC, "messagetime"));
                Pageable pageable = new PageRequest(0, 1, new Sort(orders));
                //查询最新的消息
                List<Map<String, Object>> messageInfo = messageinfoRepository
                        .findLatestMessageInfo(messageType, token, pageable);
                if (messageInfo.size() > 0) {
                    byte[] b = (byte[]) messageInfo.get(0).get("messagecontent");
                    try {
                        retMap.put("messageInfo", new String(b, "utf-8"));  //最新消息
                        retMap.put("messageTime", convertMessageTime(messageInfo.get(0)));//最新消息时间
                    } catch (UnsupportedEncodingException e) {
                        e.printStackTrace();
                    }
                }
            }
            //获取跑团通知
            if (messageType.equals(Constant.RUN_TZ_CODE)) {
                retMap.put("messageTypeName", switchMessageTypeName(messageType));//消息类型名称
                //调取跑团模块接口
                List<Map<String, Object>> responseEntity = requestRunGroupPushAll(token);
                Integer num = 0;
                retMap.put("messageCount", num);//未读消息数量
                for (Map<String, Object> map : responseEntity) {
                    Map<String, Object> resMap = (Map<String, Object>) map.get("main");
                    //获取未读跑团通知未读状态值
                    String flag = (String) resMap.get("readflag");
                    if (!CommonUtil.isEmpty(flag) && flag.equals("N")) {
                        num++;
                    }
                    retMap.put("messageCount", num);//未读消息数量
                    //获取最新的消息及消息时间
                    if (num == responseEntity.size()) {
                        retMap.put("messageInfo", resMap.get("message"));  //最新消息
                        Map<String, Object> dateMap = new HashMap<String, Object>();
                        dateMap.put("messagedate", DateUtil.stampToDate((Long) resMap.get("pushdate")));
                        dateMap.put("messagetime", resMap.get("pushtime"));
                        retMap.put("messageTime", convertMessageTime(dateMap));//最新消息时间
                    }
                }
            }
            resList.add(retMap);
        }
        return new ResponseInfo(true, "success", resList);
    }

    /**
     * 根据消息类型获取对应的消息分页列表数据
     *
     * @param messagePageReqDTO dto
     * @return T
     */
    @Override
    @Transactional
    public ResponseInfo<MessagePageResDTO> findMessInfoByMessType(RequestInfo<MessagePageReqDTO> messagePageReqDTO) {
        //校验请求参数不能为空
        String messageType = messagePageReqDTO.getQuery().getMessageType();
        if (CommonUtil.isEmpty(messageType)) {
            LOGGER.error("消息类型'messageType'不能为空！");
            return new ResponseInfo<>(false, "消息类型'messageType'不能为空！", 400);
        }
        String token = messagePageReqDTO.getQuery().getToken();
        if (CommonUtil.isEmpty(token)) {
            LOGGER.error("设备'token'不能为空！");
            return new ResponseInfo<>(false, "设备'token'不能为空！", 400);
        }
        //校验请求分页数据
        if (!CommonUtil.verifyReqPageInfo(messagePageReqDTO)) {
            return new ResponseInfo<>(false, CommonUtil.getVerifyPageError(), 400);
        }
        List<Map<String, Object>> list = null;
        //系统通知、活动通知、i动小编 调取后台消息数据表
        if (messageType.equals(Constant.SYS_TZ_CODE)
                || messageType.equals(Constant.ACTIVITY_TZ_CODE)
                || messageType.equals(Constant.IMOVE_TZ_CODE)) {
            //开始执行排序
            List<Sort.Order> orders = new ArrayList<Sort.Order>();
            orders.add(new Sort.Order(Sort.Direction.DESC, "messagedate"));
            orders.add(new Sort.Order(Sort.Direction.DESC, "messagetime"));
            Pageable pageable = new PageRequest(messagePageReqDTO.getCurrentPage(), messagePageReqDTO.getPageSize(), new Sort(orders));

            //执行分页查询
            list = this.messageinfoRepository.findMessInfoByMessType(messageType, token, pageable);
            StringBuffer batchnums = new StringBuffer("'");
            for (Map<String, Object> map : list) {
                byte[] b = (byte[]) map.get("messagecontent");
                try {
                    String message = new String(b, "utf-8");
                    map.put("messagecontent", message);
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
                batchnums.append(map.get("batchnum") + "','");
                map.remove("batchnum");
            }
            if (batchnums.length() > 1) {
                batchnums = new StringBuffer(batchnums.substring(0, batchnums.length() - 2));
            }
            if (list == null || list.size() == 0) {
                LOGGER.error("无消息列表数据，分析原因：当前请求页码有误或无此消息类型");
                return new ResponseInfo<>(false, "无消息列表数据，分析原因：当前请求页码有误或无此消息类型", 400);
            }
            //根据本用户的token调整对应的消息阅读状态（修改为已读）
            Query query = null;
            try {
                String tablename = "Pushdetail";
                query = this.entityManager.createQuery("update " + tablename + " p set p.readstate = '1' where p.batchnum " +
                        "in (" + batchnums.toString() + ") and p.devicetoken = ?1");
                query.setParameter(1, token);
                query.executeUpdate();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        //跑团通知需要调取跑团接口，获取对应消息列表信息
        if (messageType.equals(Constant.RUN_TZ_CODE)) {
            //调取跑团模块接口
            List<Map<String, Object>> responseEntity = requestRunGroupPushAll(token);
            for (Map<String, Object> map : responseEntity) {
                //获取主main
                Map<String, Object> mainMap = null;
                if (!CommonUtil.isEmpty(map.get("main"))) {
                    mainMap = (Map<String, Object>) map.get("main");
                    mainMap.put("pushdate", DateUtil.stampToDate(
                            (Long) mainMap.get("pushdate")).replace("-", "/"));    //消息日期
                    mainMap.put("pushtime", String.valueOf(mainMap.get("pushtime")).substring(0, 5));
                }
                //获取子second
                if (!CommonUtil.isEmpty(map.get("second"))) {
                    Map<String, Object> secondMap = (Map<String, Object>) map.get("second");
                    secondMap.remove("createdate");
                }
                //根据本用户的applyid及阅读状态调整对应的跑团通知消息阅读状态（修改为已读）
                modifyRunGroupPushReadFlag(mainMap);
                list = responseEntity;
            }
            if (list == null || list.size() == 0) {
                LOGGER.error("无消息列表数据，分析原因：当前请求页码有误或无此消息类型");
                return new ResponseInfo<>(false, "无消息列表数据，分析原因：当前请求页码有误或无此消息类型", 400);
            }
        }
        return (new ResponseInfo(true, "success", list));
    }

    /**
     * 根据跑团推送消息表中的id来更新跑团通知消息的阅读状态值为Y
     *
     * @param map
     */
    private void modifyRunGroupPushReadFlag(Map<String, Object> map) {
        try {
            //获取推送消息主键
            Long id = Long.parseLong(String.valueOf(map.get("id")));
            //获取阅读状态
            String readFlag = (String) map.get("readflag");
            RequestInfo<String> requestInfo = new RequestInfo<String>();
            requestInfo.setQuery(readFlag);
            runGroupFeignClient.updatePushInfo(id, requestInfo);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 调取跑团接口
     *
     * @param token 用户设备token
     * @return List
     */
    private List<Map<String, Object>> requestRunGroupPushAll(String token) {
        ResponseInfo<List<Map<String, Object>>> responseInfo = null;
        try {
            LOGGER.info("调取跑团通知接口...");
            RequestInfo<String> requestInfo = new RequestInfo<String>();
            requestInfo.setQuery(token);
            responseInfo = runGroupFeignClient.findPushAll(requestInfo);
        } catch (Exception e) {
            e.printStackTrace();
            LOGGER.error("调取跑团接口异常，原因：" + e.getMessage());
            return null;
        }
        return responseInfo.getEntityies().get(0);
    }

    /**
     * 根据消息类型获取消息类型名称
     *
     * @param messageType 消息类型
     * @return obj
     * java 7 开始switch除了基本的byte、short、int、char、enum 及对应封装外的string型
     */
    private Object switchMessageTypeName(String messageType) {
        switch (messageType) {
            case Constant.SYS_TZ_CODE:
                return "系统通知";
            case Constant.ACTIVITY_TZ_CODE:
                return "活动通知";
            case Constant.IMOVE_TZ_CODE:
                return "i动小编";
            case Constant.RUN_TZ_CODE:
                return "跑团通知";
            default:
                return null;
        }
    }

    /**
     * 根据查询的消息时间进行转化
     *
     * @param map map
     * @return T
     */
    private Object convertMessageTime(Map<String, Object> map) {
        try {
            //获取消息时间
            String messageDate = (String) map.get("messagedate");
            //获取消息时间
            String messageTime = (String) map.get("messagetime");
            LOGGER.info("消息日期：" + messageDate + "    消息时间：" + messageTime);
            String nowDate = DateUtil.convertDate(new Date(), DateUtil.YYYY_MM_DD);
            Integer val = DateUtil.getDateSpace(messageDate, nowDate);
            if (val == 0) { //今天
                return (messageTime.substring(0, 5));
            }
            if (val == 1) { //昨天
                return "昨天";
            }
            if (val > 1) { //昨天以前
                return (messageDate.replace("-", "/"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}