diff --git a/backend/src/main/java/com/supwisdom/dlpay/portal/dao/impl/MsgTemplateRepositoryImpl.java b/backend/src/main/java/com/supwisdom/dlpay/portal/dao/impl/MsgTemplateRepositoryImpl.java
index f6efb5b..23d8bb4 100644
--- a/backend/src/main/java/com/supwisdom/dlpay/portal/dao/impl/MsgTemplateRepositoryImpl.java
+++ b/backend/src/main/java/com/supwisdom/dlpay/portal/dao/impl/MsgTemplateRepositoryImpl.java
@@ -4,6 +4,7 @@
 import com.supwisdom.dlpay.framework.jpa.Finder;
 import com.supwisdom.dlpay.framework.jpa.page.Pagination;
 import com.supwisdom.dlpay.framework.util.StringUtil;
+import com.supwisdom.dlpay.mobile.domain.TBMsg;
 import com.supwisdom.dlpay.portal.bean.MsgTemplateSearchBean;
 import com.supwisdom.dlpay.portal.dao.MsgTemplateRepository;
 import com.supwisdom.dlpay.portal.domain.TBMsgTemplate;
@@ -34,4 +35,12 @@
     }
     return findNative(f, Transformers.aliasToBean(TBMsgTemplate.class), pageno, pagesize);
   }
+
+  @NotNull
+  @Override
+  public Pagination getPushMsgList(int pageno, int pagesize, @NotNull String uid) {
+    Finder f = Finder.create("select * from tb_msg where uid=:uid order by lastupdate desc");
+    f.setParameter("uid", uid);
+    return findNative(f, Transformers.aliasToBean(TBMsg.class), pageno, pagesize);
+  }
 }
diff --git a/backend/src/main/kotlin/com/supwisdom/dlpay/api/service/impl/kafka_service_impl.kt b/backend/src/main/kotlin/com/supwisdom/dlpay/api/service/impl/kafka_service_impl.kt
index ac2689f..44ff3c7 100644
--- a/backend/src/main/kotlin/com/supwisdom/dlpay/api/service/impl/kafka_service_impl.kt
+++ b/backend/src/main/kotlin/com/supwisdom/dlpay/api/service/impl/kafka_service_impl.kt
@@ -60,6 +60,7 @@
             if ("ios".equals(it.lastloginplatform, true)) {
                 platform = "ios"
             }
+            msg.uid = it.uid
             val message = KafkaXgMessage()
             message.alltarget = false
             message.callback = true
diff --git a/backend/src/main/kotlin/com/supwisdom/dlpay/mobile/MobileApi.kt b/backend/src/main/kotlin/com/supwisdom/dlpay/mobile/MobileApi.kt
index 0e59219..b08b896 100644
--- a/backend/src/main/kotlin/com/supwisdom/dlpay/mobile/MobileApi.kt
+++ b/backend/src/main/kotlin/com/supwisdom/dlpay/mobile/MobileApi.kt
@@ -613,7 +613,7 @@
     /**
      * 子系统调用手机推送接口
      */
-    @RequestMapping(value = ["/template/sendmsg"], method = [RequestMethod.POST])
+    @RequestMapping(value = ["/pushmsg/send"], method = [RequestMethod.POST])
     fun sendMsg(@RequestBody bean: SendMsgBean): JsonResult? {
         return try {
             val userInfo = userProxy.querybycardno(QueryUserParam().apply {
@@ -639,10 +639,10 @@
     fun getPrompt(@PathVariable code: String): JsonResult? {
         return try {
             val prompt = advisoryService.getPromptByCode(code)
-            JsonResult.ok().put("prompt",prompt.content)
+            JsonResult.ok().put("prompt", prompt.content)
         } catch (e: Exception) {
-            logger.error("获取提示信息异常",e)
-            JsonResult.ok().put("prompt","")
+            logger.error("获取提示信息异常", e)
+            JsonResult.ok().put("prompt", "")
         }
     }
 }
@@ -671,11 +671,13 @@
     lateinit var userProxy: UserProxy
     @Autowired
     lateinit var secretSecurityService: SecretSecurityService
+    @Autowired
+    lateinit var msgService: MsgService
     val logger = KotlinLogging.logger { }
 
     @RequestMapping("/idtypes")
     fun idtypes(): JsonResult {
-        var dict = dictionaryProxy.getDictionaryAsMap(Dictionary.IDTYPE)
+        val dict = dictionaryProxy.getDictionaryAsMap(Dictionary.IDTYPE)
         return JsonResult.ok("OK").put("idtypes", dict)!!
     }
 
@@ -697,11 +699,11 @@
     @RequestMapping("/infor")
     fun getUserInfor(): JsonResult {
         val p = SecurityContextHolder.getContext().authentication
-        var user = mobileApiService.findUserById(p.name)
+        val user = mobileApiService.findUserById(p.name)
                 ?: return JsonResult.error("用户不存在，请注册")
         var tk = ""
         if (!user.jti.isNullOrEmpty()) {
-            var opt = apiJwtRepository.findById(user.jti!!)
+            val opt = apiJwtRepository.findById(user.jti!!)
             if (opt.isPresent) {
                 var jwt = opt.get()
                 val cur = System.currentTimeMillis()
@@ -1872,5 +1874,23 @@
         }
     }
 
-
+    /**
+     * 查询推送通知列表
+     */
+    @RequestMapping(value = ["/pushmsg/list"], method = [RequestMethod.GET])
+    fun getPushMsgList(pageno: Int, pagesize: Int): JsonResult? {
+        return try {
+            val p = SecurityContextHolder.getContext().authentication
+            val user = mobileApiService.findUserById(p.name)
+                    ?: return JsonResult.error("用户不存在，请注册")
+            val page = msgService.getPushMsgList(pageno, pagesize, user.uid)
+            JsonResult.ok().put("data", page)
+        } catch (e: Exception) {
+            if (e is PortalBusinessException) {
+                return JsonResult.error(e.message)
+            }
+            logger.error("获取推送消息异常", e)
+            JsonResult.error("获取推送消息失败")
+        }
+    }
 }
\ No newline at end of file
diff --git a/backend/src/main/kotlin/com/supwisdom/dlpay/mobile/domain/TBMsg.kt b/backend/src/main/kotlin/com/supwisdom/dlpay/mobile/domain/TBMsg.kt
index ad2d372..23a0ef8 100644
--- a/backend/src/main/kotlin/com/supwisdom/dlpay/mobile/domain/TBMsg.kt
+++ b/backend/src/main/kotlin/com/supwisdom/dlpay/mobile/domain/TBMsg.kt
@@ -44,4 +44,7 @@
 
     @Column(name = "tenantid", length = 32)
     var tenantid:String? = null
+
+    @Column(name = "uid", length = 32)
+    var uid:String? = null
 }
diff --git a/backend/src/main/kotlin/com/supwisdom/dlpay/portal/dao/MsgTemplateDao.kt b/backend/src/main/kotlin/com/supwisdom/dlpay/portal/dao/MsgTemplateDao.kt
index 2c5f093..773b8e2 100644
--- a/backend/src/main/kotlin/com/supwisdom/dlpay/portal/dao/MsgTemplateDao.kt
+++ b/backend/src/main/kotlin/com/supwisdom/dlpay/portal/dao/MsgTemplateDao.kt
@@ -5,6 +5,4 @@
 import org.springframework.stereotype.Repository
 
 @Repository
-interface MsgTemplateDao : JpaRepository<TBMsgTemplate, String>,MsgTemplateRepository {
-
-}
\ No newline at end of file
+interface MsgTemplateDao : JpaRepository<TBMsgTemplate, String>, MsgTemplateRepository
\ No newline at end of file
diff --git a/backend/src/main/kotlin/com/supwisdom/dlpay/portal/dao/MsgTemplateRepository.kt b/backend/src/main/kotlin/com/supwisdom/dlpay/portal/dao/MsgTemplateRepository.kt
index f6ca359..0ed82de 100644
--- a/backend/src/main/kotlin/com/supwisdom/dlpay/portal/dao/MsgTemplateRepository.kt
+++ b/backend/src/main/kotlin/com/supwisdom/dlpay/portal/dao/MsgTemplateRepository.kt
@@ -5,4 +5,5 @@
 
 interface MsgTemplateRepository {
     fun getMsgTemplateList(bean: MsgTemplateSearchBean): Pagination
+    fun getPushMsgList(pageno: Int, pagesize: Int, uid: String):Pagination
 }
\ No newline at end of file
diff --git a/backend/src/main/kotlin/com/supwisdom/dlpay/portal/service/Impl/MsgServiceImpl.kt b/backend/src/main/kotlin/com/supwisdom/dlpay/portal/service/Impl/MsgServiceImpl.kt
index 60c2c8b..358d0bc 100644
--- a/backend/src/main/kotlin/com/supwisdom/dlpay/portal/service/Impl/MsgServiceImpl.kt
+++ b/backend/src/main/kotlin/com/supwisdom/dlpay/portal/service/Impl/MsgServiceImpl.kt
@@ -55,4 +55,8 @@
             throw RuntimeException("未找到id为：<${bean.templateid}>的模板，请确认模板id")
         }
     }
+
+    override fun getPushMsgList(pageno: Int, pagesize: Int, uid: String): Pagination {
+        return msgTemplateDao.getPushMsgList(pageno, pagesize, uid)
+    }
 }
\ No newline at end of file
diff --git a/backend/src/main/kotlin/com/supwisdom/dlpay/portal/service/MsgService.kt b/backend/src/main/kotlin/com/supwisdom/dlpay/portal/service/MsgService.kt
index f874828..15e6d99 100644
--- a/backend/src/main/kotlin/com/supwisdom/dlpay/portal/service/MsgService.kt
+++ b/backend/src/main/kotlin/com/supwisdom/dlpay/portal/service/MsgService.kt
@@ -8,9 +8,14 @@
 
 interface MsgService {
     @Transactional
-    fun getMsgTemplateList(bean:MsgTemplateSearchBean):Pagination
+    fun getMsgTemplateList(bean: MsgTemplateSearchBean): Pagination
+
     @Transactional
-    fun saveMsgTemplate(template:TBMsgTemplate)
+    fun saveMsgTemplate(template: TBMsgTemplate)
+
     @Transactional
     fun sendMsg(bean: SendMsgBean)
+
+    @Transactional
+    fun getPushMsgList(pageno: Int, pagesize: Int, uid: String): Pagination
 }
