删除服务器或虚拟主机时的对应的级联删除

@@ -8,7 +8,9 @@ import com.sunyo.wlpt.message.bus.service.utils.IdUtils;
 import org.springframework.web.bind.annotation.*;
 import org.springframework.web.bind.annotation.*;
 
 
 import javax.annotation.Resource;
 import javax.annotation.Resource;
+import java.io.IOException;
 import java.util.List;
 import java.util.List;
+import java.util.concurrent.TimeoutException;
 
 
 import static com.sunyo.wlpt.message.bus.service.common.Constant.EXIST_SERVERNAME;
 import static com.sunyo.wlpt.message.bus.service.common.Constant.EXIST_SERVERNAME;
 import static com.sunyo.wlpt.message.bus.service.common.Constant.EXIST_SERVER_INFO;
 import static com.sunyo.wlpt.message.bus.service.common.Constant.EXIST_SERVER_INFO;
@@ -56,7 +58,7 @@ public class BusServerController {
      * @return {@link ResultJson}
      * @return {@link ResultJson}
      */
      */
     @DeleteMapping("/delete")
     @DeleteMapping("/delete")
-    public ResultJson deleteBusServer(@RequestBody BusServer busServer)
+    public ResultJson deleteBusServer(@RequestBody BusServer busServer) throws IOException, TimeoutException
     {
     {
         return busServerService.deleteByPrimaryKey(busServer.getId()) > 0
         return busServerService.deleteByPrimaryKey(busServer.getId()) > 0
                 ? new ResultJson<>("200", "删除MQ服务器，成功")
                 ? new ResultJson<>("200", "删除MQ服务器，成功")
@@ -70,7 +72,7 @@ public class BusServerController {
      * @return {@link ResultJson}
      * @return {@link ResultJson}
      */
      */
     @GetMapping("/batchRemove")
     @GetMapping("/batchRemove")
-    public ResultJson batchRemoveBusServer(String ids)
+    public ResultJson batchRemoveBusServer(String ids) throws IOException, TimeoutException
     {
     {
         return busServerService.deleteByPrimaryKey(ids) > 0
         return busServerService.deleteByPrimaryKey(ids) > 0
                 ? new ResultJson<>("200", "批量删除服务器，成功")
                 ? new ResultJson<>("200", "批量删除服务器，成功")

@@ -8,7 +8,9 @@ import com.sunyo.wlpt.message.bus.service.utils.IdUtils;
 import org.springframework.web.bind.annotation.*;
 import org.springframework.web.bind.annotation.*;
 
 
 import javax.annotation.Resource;
 import javax.annotation.Resource;
+import java.io.IOException;
 import java.util.List;
 import java.util.List;
+import java.util.concurrent.TimeoutException;
 
 
 import static com.sunyo.wlpt.message.bus.service.common.Constant.EXIST_HOST_INFO;
 import static com.sunyo.wlpt.message.bus.service.common.Constant.EXIST_HOST_INFO;
 
 
@@ -56,7 +58,8 @@ public class VirtualHostController {
      * @return {@link ResultJson}
      * @return {@link ResultJson}
      */
      */
     @DeleteMapping("/delete")
     @DeleteMapping("/delete")
-    public ResultJson deleteVirtualHost(@RequestBody VirtualHost virtualHost) {
+    public ResultJson deleteVirtualHost(@RequestBody VirtualHost virtualHost) throws IOException, TimeoutException
+    {
         return virtualHostService.deleteByPrimaryKey(virtualHost.getId()) > 0
         return virtualHostService.deleteByPrimaryKey(virtualHost.getId()) > 0
                 ? new ResultJson<>("200", "删除虚拟主机信息，成功")
                 ? new ResultJson<>("200", "删除虚拟主机信息，成功")
                 : new ResultJson<>("500", "删除虚拟主机信息，失败");
                 : new ResultJson<>("500", "删除虚拟主机信息，失败");
@@ -69,7 +72,8 @@ public class VirtualHostController {
      * @return {@link ResultJson}
      * @return {@link ResultJson}
      */
      */
     @GetMapping("/batchRemove")
     @GetMapping("/batchRemove")
-    public ResultJson batchRemoveVirtualHost(String ids) {
+    public ResultJson batchRemoveVirtualHost(String ids) throws IOException, TimeoutException
+    {
         return virtualHostService.deleteByPrimaryKey(ids) > 0
         return virtualHostService.deleteByPrimaryKey(ids) > 0
                 ? new ResultJson<>("200", "批量删除虚拟主机，成功")
                 ? new ResultJson<>("200", "批量删除虚拟主机，成功")
                 : new ResultJson<>("500", "批量删除虚拟主机，失败");
                 : new ResultJson<>("500", "批量删除虚拟主机，失败");

@@ -22,6 +22,13 @@ public interface BusExchangeMapper {
     int deleteByPrimaryKey(String id);
     int deleteByPrimaryKey(String id);
 
 
     /**
     /**
+     * 根据虚拟主机删除交换机
+     *
+     * @param virtualHostId 虚拟主机id
+     * @return
+     */
+    int deleteByVirtualHostId(String virtualHostId);
+    /**
      * 新增
      * 新增
      *
      *
      * @param record the record
      * @param record the record
@@ -92,4 +99,13 @@ public interface BusExchangeMapper {
      * @return List<BusExchange>
      * @return List<BusExchange>
      */
      */
     List<BusExchange> selectExchangeExist(BusExchange exchange);
     List<BusExchange> selectExchangeExist(BusExchange exchange);
+
+    /**
+     * 查询交换机列表，根据虚拟主机id
+     *
+     * @param virtualHostId 虚拟主机
+     * @return
+     */
+    List<BusExchange> selectByVirtualHostId(String virtualHostId);
+
 }
 }

@@ -19,6 +19,14 @@ public interface BusQueueMapper {
     int deleteByPrimaryKey(String id);
     int deleteByPrimaryKey(String id);
 
 
     /**
     /**
+     * 删除队列，根据虚拟主机id
+     *
+     * @param virtualHostId 虚拟主机id
+     * @return
+     */
+    int deleteByVirtualHostId(String virtualHostId);
+
+    /**
      * insert record to table
      * insert record to table
      *
      *
      * @param record the record
      * @param record the record
@@ -43,6 +51,14 @@ public interface BusQueueMapper {
     BusQueue selectByPrimaryKey(String id);
     BusQueue selectByPrimaryKey(String id);
 
 
     /**
     /**
+     * 根据虚拟主机id，查询队列列表
+     *
+     * @param virtualHostId 虚拟主机id
+     * @return
+     */
+    List<BusQueue> selectByVirtualHostId(String virtualHostId);
+
+    /**
      * update record selective
      * update record selective
      *
      *
      * @param record the updated record
      * @param record the updated record

@@ -47,6 +47,22 @@ public interface UserMessageBindingMapper {
     int deleteByRoutingKeyId(String routingKeyId);
     int deleteByRoutingKeyId(String routingKeyId);
 
 
     /**
     /**
+     * 删除配置关系
+     *
+     * @param virtualHostId 虚拟主机id
+     * @return
+     */
+    int deleteByVirtualHostId(String virtualHostId);
+
+    /**
+     * 根据服务器id，删除绑定关系
+     *
+     * @param serverId 服务器id
+     * @return
+     */
+    int deleteByServerId(String serverId);
+
+    /**
      * insert record to table
      * insert record to table
      *
      *
      * @param record the record
      * @param record the record
@@ -79,6 +95,22 @@ public interface UserMessageBindingMapper {
     List<UserMessageBinding> selectByRoutingKeyId(String routingKeyId);
     List<UserMessageBinding> selectByRoutingKeyId(String routingKeyId);
 
 
     /**
     /**
+     * 根据虚拟主机id，查询配置关系列表
+     *
+     * @param virtualHostId 虚拟主机id
+     * @return List<UserMessageBinding>
+     */
+    List<UserMessageBinding> selectByVirtualHostId(String virtualHostId);
+
+    /**
+     * 根据服务器id，查询配置关系列表
+     *
+     * @param serverId 服务器id
+     * @return List<UserMessageBinding>
+     */
+    List<UserMessageBinding> selectByServerId(String serverId);
+
+    /**
      * update record selective
      * update record selective
      *
      *
      * @param record the updated record
      * @param record the updated record

@@ -22,6 +22,14 @@ public interface VirtualHostMapper {
     int deleteByPrimaryKey(String id);
     int deleteByPrimaryKey(String id);
 
 
     /**
     /**
+     * 根据服务器id，删除虚拟主机
+     *
+     * @param serverId 服务器id
+     * @return
+     */
+    int deleteByServerId(String serverId);
+
+    /**
      * 新增
      * 新增
      *
      *
      * @param record the record
      * @param record the record
@@ -46,6 +54,14 @@ public interface VirtualHostMapper {
     VirtualHost selectByPrimaryKey(String id);
     VirtualHost selectByPrimaryKey(String id);
 
 
     /**
     /**
+     * 根据服务器id，查询虚拟主机列表
+     *
+     * @param serverId 服务器id
+     * @return
+     */
+    List<VirtualHost> selectByServerId(String serverId);
+
+    /**
      * 更新，选择性，根据主键
      * 更新，选择性，根据主键
      *
      *
      * @param record the updated record
      * @param record the updated record

@@ -96,4 +96,20 @@ public interface BusExchangeService {
      * @return List<BusExchange>
      * @return List<BusExchange>
      */
      */
     List<BusExchange> selectExchangeExist(BusExchange exchange);
     List<BusExchange> selectExchangeExist(BusExchange exchange);
+
+    /**
+     * 根据虚拟主机删除交换机
+     *
+     * @param virtualHostId 虚拟主机id
+     * @return
+     */
+    int deleteByVirtualHostId(String virtualHostId);
+
+    /**
+     * 查询交换机列表，根据虚拟主机id
+     *
+     * @param virtualHostId 虚拟主机
+     * @return
+     */
+    List<BusExchange> selectByVirtualHostId(String virtualHostId);
 }
 }

@@ -23,6 +23,14 @@ public interface BusQueueService {
     int deleteByPrimaryKey(String id) throws IOException, TimeoutException;
     int deleteByPrimaryKey(String id) throws IOException, TimeoutException;
 
 
     /**
     /**
+     * 删除队列，根据虚拟主机id
+     *
+     * @param virtualHostId 虚拟主机id
+     * @return
+     */
+    int deleteByVirtualHostId(String virtualHostId);
+
+    /**
      * 新增
      * 新增
      *
      *
      * @param record the record
      * @param record the record
@@ -87,5 +95,13 @@ public interface BusQueueService {
      * @return
      * @return
      */
      */
     List<BusQueue> getQueueList(BusQueue busQueue);
     List<BusQueue> getQueueList(BusQueue busQueue);
+
+    /**
+     * 根据虚拟主机id，查询队列列表
+     *
+     * @param virtualHostId 虚拟主机id
+     * @return
+     */
+    List<BusQueue> selectByVirtualHostId(String virtualHostId);
 }
 }
 
 

@@ -3,7 +3,9 @@ package com.sunyo.wlpt.message.bus.service.service;
 import com.github.pagehelper.PageInfo;
 import com.github.pagehelper.PageInfo;
 import com.sunyo.wlpt.message.bus.service.domain.BusServer;
 import com.sunyo.wlpt.message.bus.service.domain.BusServer;
 
 
+import java.io.IOException;
 import java.util.List;
 import java.util.List;
+import java.util.concurrent.TimeoutException;
 
 
 /**
 /**
  * @author 子诚
  * @author 子诚
@@ -18,7 +20,7 @@ public interface BusServerService {
      * @param id primaryKey
      * @param id primaryKey
      * @return deleteCount
      * @return deleteCount
      */
      */
-    int deleteByPrimaryKey(String id);
+    int deleteByPrimaryKey(String id) throws IOException, TimeoutException;
 
 
     /**
     /**
      * 新增
      * 新增

@@ -111,6 +111,38 @@ public interface UserMessageBindingService {
      * @return
      * @return
      */
      */
     List<UserMessageBinding> selectByRoutingKeyId(String routingKeyId);
     List<UserMessageBinding> selectByRoutingKeyId(String routingKeyId);
+
+    /**
+     * 根据虚拟主机id，查询配置关系列表
+     *
+     * @param virtualHostId 虚拟主机id
+     * @return List<UserMessageBinding>
+     */
+    List<UserMessageBinding> selectByVirtualHostId(String virtualHostId);
+
+    /**
+     * 删除配置关系
+     *
+     * @param virtualHostId 虚拟主机id
+     * @return
+     */
+    int deleteByVirtualHostId(String virtualHostId);
+
+    /**
+     * 根据服务器id，查询配置关系列表
+     *
+     * @param serverId 服务器id
+     * @return List<UserMessageBinding>
+     */
+    List<UserMessageBinding> selectByServerId(String serverId);
+
+    /**
+     * 根据服务器id，删除绑定关系
+     *
+     * @param serverId 服务器id
+     * @return
+     */
+    int deleteByServerId(String serverId);
 }
 }
 
 
 
 

@@ -3,7 +3,9 @@ package com.sunyo.wlpt.message.bus.service.service;
 import com.github.pagehelper.PageInfo;
 import com.github.pagehelper.PageInfo;
 import com.sunyo.wlpt.message.bus.service.domain.VirtualHost;
 import com.sunyo.wlpt.message.bus.service.domain.VirtualHost;
 
 
+import java.io.IOException;
 import java.util.List;
 import java.util.List;
+import java.util.concurrent.TimeoutException;
 
 
 /**
 /**
  * @author 子诚
  * @author 子诚
@@ -18,7 +20,7 @@ public interface VirtualHostService {
      * @param id primaryKey
      * @param id primaryKey
      * @return deleteCount
      * @return deleteCount
      */
      */
-    int deleteByPrimaryKey(String id);
+    int deleteByPrimaryKey(String id) throws IOException, TimeoutException;
 
 
     /**
     /**
      * 新增
      * 新增
@@ -88,8 +90,25 @@ public interface VirtualHostService {
 
 
     /**
     /**
      * 检验是否存在
      * 检验是否存在
-     * @param virtualHost  {@link VirtualHost}
+     *
+     * @param virtualHost {@link VirtualHost}
      * @return List<VirtualHost>
      * @return List<VirtualHost>
      */
      */
     List<VirtualHost> selectVirtualHostExist(VirtualHost virtualHost);
     List<VirtualHost> selectVirtualHostExist(VirtualHost virtualHost);
+
+    /**
+     * 根据服务器id，查询虚拟主机列表
+     *
+     * @param serverId 服务器id
+     * @return
+     */
+    List<VirtualHost> selectByServerId(String serverId);
+
+    /**
+     * 根据服务器id，删除虚拟主机
+     *
+     * @param serverId 服务器id
+     * @return
+     */
+    int deleteByServerId(String serverId);
 }
 }

@@ -2,9 +2,8 @@ package com.sunyo.wlpt.message.bus.service.service.impl;
 
 
 import com.sunyo.wlpt.message.bus.service.domain.*;
 import com.sunyo.wlpt.message.bus.service.domain.*;
 import com.sunyo.wlpt.message.bus.service.rabbit.utils.RabbitUtils;
 import com.sunyo.wlpt.message.bus.service.rabbit.utils.RabbitUtils;
-import com.sunyo.wlpt.message.bus.service.service.MessageNoteService;
-import com.sunyo.wlpt.message.bus.service.service.RoutingKeyService;
-import com.sunyo.wlpt.message.bus.service.service.UserMessageBindingService;
+import com.sunyo.wlpt.message.bus.service.service.*;
+import org.springframework.context.annotation.Lazy;
 import org.springframework.scheduling.annotation.Async;
 import org.springframework.scheduling.annotation.Async;
 import org.springframework.stereotype.Service;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Propagation;
@@ -30,12 +29,25 @@ public class AsyncTaskService {
     @Resource
     @Resource
     private MessageNoteService messageNoteService;
     private MessageNoteService messageNoteService;
 
 
+    @Lazy
     @Resource
     @Resource
     private RoutingKeyService routingKeyService;
     private RoutingKeyService routingKeyService;
 
 
     @Resource
     @Resource
     private UserMessageBindingService userMessageBindingService;
     private UserMessageBindingService userMessageBindingService;
 
 
+    @Lazy
+    @Resource
+    private BusQueueService busQueueService;
+
+    @Lazy
+    @Resource
+    private BusExchangeService busExchangeService;
+
+    @Lazy
+    @Resource
+    private VirtualHostService virtualHostService;
+
     /**
     /**
      * 异步，无论消息是否发送成功，将消息存储于数据库
      * 异步，无论消息是否发送成功，将消息存储于数据库
      *
      *
@@ -49,14 +61,80 @@ public class AsyncTaskService {
     }
     }
 
 
     /**
     /**
-     * 当删除服务器的时候
+     * 当删除服务器的时候,级联删除与服务器有关的
+     * 虚拟主机,交换机，路由键，队列，绑定关系
      */
      */
-
+    @Async
+    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
+    public void serverCascadeDelete(BusServer busServer) throws IOException, TimeoutException
+    {
+        String serverId = busServer.getId();
+        List<UserMessageBinding> bindings = userMessageBindingService.selectByServerId(serverId);
+        // 1.1 删除数据库中的绑定关系
+        userMessageBindingService.deleteByServerId(serverId);
+        for (UserMessageBinding userMessageBinding : bindings) {
+            // 1.2、解除MQ服务器上的绑定关系
+            rabbitUtils.toRemoveBinding(userMessageBinding);
+        }
+        List<VirtualHost> virtualHostList = virtualHostService.selectByServerId(serverId);
+        // 2.1、删除数据库中的虚拟主机列表
+        virtualHostService.deleteByServerId(serverId);
+        for (VirtualHost virtualHost : virtualHostList) {
+            String virtualHostId = virtualHost.getId();
+            List<BusQueue> queues = busQueueService.selectByVirtualHostId(virtualHostId);
+            // 3.1、删除数据库中对应的队列
+            busQueueService.deleteByVirtualHostId(virtualHostId);
+            for (BusQueue queue : queues) {
+                // 3.2、删除MQ服务器上的队列
+                rabbitUtils.toRemoveQueue(queue);
+            }
+            List<BusExchange> exchanges = busExchangeService.selectByVirtualHostId(virtualHostId);
+            // 4.1 根据虚拟主机id，删除交换机
+            busExchangeService.deleteByVirtualHostId(virtualHostId);
+            for (BusExchange busExchange : exchanges) {
+                String exchangeId = busExchange.getId();
+                // 5.1、删除数据库中对应的路由键
+                routingKeyService.deleteByExchangeId(exchangeId);
+                // 4.2 在MQ服务器上删除该交换机
+                rabbitUtils.toRemoveExchange(busExchange);
+            }
+        }
+    }
 
 
     /**
     /**
-     * 当删除虚拟主机的时候
+     * 当删除虚拟主机的时候，级联删除与虚拟主机有关的
+     * 交换机，路由键，队列，绑定关系
      */
      */
-
+    @Async
+    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
+    public void virtualHostCascadeDelete(VirtualHost virtualHost) throws IOException, TimeoutException
+    {
+        String virtualHostId = virtualHost.getId();
+        List<UserMessageBinding> bindings = userMessageBindingService.selectByVirtualHostId(virtualHostId);
+        // 1.1、删除数据库中的绑定关系
+        userMessageBindingService.deleteByVirtualHostId(virtualHostId);
+        for (UserMessageBinding userMessageBinding : bindings) {
+            // 1.2、解除MQ服务器上的绑定关系
+            rabbitUtils.toRemoveBinding(userMessageBinding);
+        }
+        List<BusQueue> queues = busQueueService.selectByVirtualHostId(virtualHostId);
+        // 2.1、删除数据库中对应的队列
+        busQueueService.deleteByVirtualHostId(virtualHostId);
+        for (BusQueue queue : queues) {
+            // 2.2、删除MQ服务器上的队列
+            rabbitUtils.toRemoveQueue(queue);
+        }
+        List<BusExchange> exchanges = busExchangeService.selectByVirtualHostId(virtualHostId);
+        // 3.1 根据虚拟主机id，删除交换机
+        busExchangeService.deleteByVirtualHostId(virtualHostId);
+        for (BusExchange busExchange : exchanges) {
+            String exchangeId = busExchange.getId();
+            // 4.1、删除数据库中对应的路由键
+            routingKeyService.deleteByExchangeId(exchangeId);
+            // 3.2 在MQ服务器上删除该交换机
+            rabbitUtils.toRemoveExchange(busExchange);
+        }
+    }
 
 
     /**
     /**
      * 当删除交换机的时候，
      * 当删除交换机的时候，
@@ -67,34 +145,34 @@ public class AsyncTaskService {
      */
      */
     @Async
     @Async
     @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
     @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
-    void exchangeCascadeDelete(BusExchange busExchange)
+    public void exchangeCascadeDelete(BusExchange busExchange)
     {
     {
         String exchangeId = busExchange.getId();
         String exchangeId = busExchange.getId();
         List<RoutingKey> routingKeyList = routingKeyService.selectByExchangeId(exchangeId);
         List<RoutingKey> routingKeyList = routingKeyService.selectByExchangeId(exchangeId);
         // 删除相关路由键
         // 删除相关路由键
         routingKeyService.deleteByExchangeId(exchangeId);
         routingKeyService.deleteByExchangeId(exchangeId);
-        // 删除交换机相关配置关系
+        // 删除交换机相关绑定关系
         userMessageBindingService.deleteByExchangeId(exchangeId);
         userMessageBindingService.deleteByExchangeId(exchangeId);
-        // 删除路由键相关配置关系
+        // 删除路由键相关绑定关系
         for (int i = 0; i < routingKeyList.size(); i++) {
         for (int i = 0; i < routingKeyList.size(); i++) {
             userMessageBindingService.deleteByRoutingKeyId(routingKeyList.get(0).getId());
             userMessageBindingService.deleteByRoutingKeyId(routingKeyList.get(0).getId());
         }
         }
     }
     }
 
 
     /**
     /**
-     * 当删除路由键的时候，删除包含该路由键的配置关系
+     * 当删除路由键的时候，删除包含该路由键的绑定关系
      */
      */
     @Async
     @Async
-    void routingKeyCascadeDelete(RoutingKey routingKey) throws IOException, TimeoutException
+    public void routingKeyCascadeDelete(RoutingKey routingKey) throws IOException, TimeoutException
     {
     {
         String routingKeyId = routingKey.getId();
         String routingKeyId = routingKey.getId();
-        // 根据路由键id查询出所有的包含该路由键的配置关系
+        // 根据路由键id查询出所有的包含该路由键的绑定关系
         List<UserMessageBinding> bindings = userMessageBindingService.selectByRoutingKeyId(routingKeyId);
         List<UserMessageBinding> bindings = userMessageBindingService.selectByRoutingKeyId(routingKeyId);
         for (UserMessageBinding userMessageBinding : bindings) {
         for (UserMessageBinding userMessageBinding : bindings) {
-            // 解除MQ服务器上的配置关系
+            // 解除MQ服务器上的绑定关系
             rabbitUtils.toRemoveBinding(userMessageBinding);
             rabbitUtils.toRemoveBinding(userMessageBinding);
         }
         }
-        // 删除数据库中的包含该路由键相关配置关系
+        // 删除数据库中的包含该路由键相关绑定关系
         userMessageBindingService.deleteByRoutingKeyId(routingKey.getId());
         userMessageBindingService.deleteByRoutingKeyId(routingKey.getId());
     }
     }
 
 
@@ -102,9 +180,9 @@ public class AsyncTaskService {
      * 当删除队列的时候，删除包含队列的绑定关系
      * 当删除队列的时候，删除包含队列的绑定关系
      */
      */
     @Async
     @Async
-    void queueCascadeDelete(BusQueue busQueue)
+    public void queueCascadeDelete(BusQueue busQueue)
     {
     {
-        // 删除相关配置关系
+        // 删除相关绑定关系
         userMessageBindingService.deleteByQueueId(busQueue.getId());
         userMessageBindingService.deleteByQueueId(busQueue.getId());
     }
     }
 
 

@@ -6,6 +6,7 @@ import com.sunyo.wlpt.message.bus.service.domain.BusExchange;
 import com.sunyo.wlpt.message.bus.service.mapper.BusExchangeMapper;
 import com.sunyo.wlpt.message.bus.service.mapper.BusExchangeMapper;
 import com.sunyo.wlpt.message.bus.service.rabbit.utils.RabbitUtils;
 import com.sunyo.wlpt.message.bus.service.rabbit.utils.RabbitUtils;
 import com.sunyo.wlpt.message.bus.service.service.BusExchangeService;
 import com.sunyo.wlpt.message.bus.service.service.BusExchangeService;
+import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.transaction.annotation.Transactional;
@@ -26,6 +27,7 @@ public class BusExchangeServiceImpl implements BusExchangeService {
     @Resource
     @Resource
     private BusExchangeMapper busExchangeMapper;
     private BusExchangeMapper busExchangeMapper;
 
 
+    @Lazy
     @Resource
     @Resource
     private AsyncTaskService asyncTaskService;
     private AsyncTaskService asyncTaskService;
 
 
@@ -137,4 +139,15 @@ public class BusExchangeServiceImpl implements BusExchangeService {
         return busExchangeMapper.selectExchangeExist(exchange);
         return busExchangeMapper.selectExchangeExist(exchange);
     }
     }
 
 
+    @Override
+    public int deleteByVirtualHostId(String virtualHostId)
+    {
+        return busExchangeMapper.deleteByVirtualHostId(virtualHostId);
+    }
+
+    @Override
+    public List<BusExchange> selectByVirtualHostId(String virtualHostId)
+    {
+        return busExchangeMapper.selectByVirtualHostId(virtualHostId);
+    }
 }
 }

@@ -84,6 +84,12 @@ public class BusQueueServiceImpl implements BusQueueService {
     }
     }
 
 
     @Override
     @Override
+    public int deleteByVirtualHostId(String virtualHostId)
+    {
+        return busQueueMapper.deleteByVirtualHostId(virtualHostId);
+    }
+
+    @Override
     public int insert(BusQueue record)
     public int insert(BusQueue record)
     {
     {
         return busQueueMapper.insert(record);
         return busQueueMapper.insert(record);
@@ -150,5 +156,11 @@ public class BusQueueServiceImpl implements BusQueueService {
         }
         }
         return busQueueMapper.getQueueList(busQueue);
         return busQueueMapper.getQueueList(busQueue);
     }
     }
+
+    @Override
+    public List<BusQueue> selectByVirtualHostId(String virtualHostId)
+    {
+        return busQueueMapper.selectByVirtualHostId(virtualHostId);
+    }
 }
 }
 
 

@@ -5,12 +5,15 @@ import com.github.pagehelper.PageInfo;
 import com.sunyo.wlpt.message.bus.service.domain.BusServer;
 import com.sunyo.wlpt.message.bus.service.domain.BusServer;
 import com.sunyo.wlpt.message.bus.service.mapper.BusServerMapper;
 import com.sunyo.wlpt.message.bus.service.mapper.BusServerMapper;
 import com.sunyo.wlpt.message.bus.service.service.BusServerService;
 import com.sunyo.wlpt.message.bus.service.service.BusServerService;
+import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.transaction.annotation.Transactional;
 
 
 import javax.annotation.Resource;
 import javax.annotation.Resource;
+import java.io.IOException;
 import java.util.List;
 import java.util.List;
+import java.util.concurrent.TimeoutException;
 
 
 /**
 /**
  * @author 子诚
  * @author 子诚
@@ -23,6 +26,10 @@ public class BusServerServiceImpl implements BusServerService {
     @Resource
     @Resource
     private BusServerMapper busServerMapper;
     private BusServerMapper busServerMapper;
 
 
+    @Lazy
+    @Resource
+    private AsyncTaskService asyncTaskService;
+
     @Override
     @Override
     public PageInfo selectBusServerList(BusServer busServer, Integer pageNum, Integer pageSize)
     public PageInfo selectBusServerList(BusServer busServer, Integer pageNum, Integer pageSize)
     {
     {
@@ -41,7 +48,7 @@ public class BusServerServiceImpl implements BusServerService {
 
 
     @Override
     @Override
     @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
     @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
-    public int deleteByPrimaryKey(String id)
+    public int deleteByPrimaryKey(String id) throws IOException, TimeoutException
     {
     {
         // 判断删除的个数，需被删除的个数是否一致
         // 判断删除的个数，需被删除的个数是否一致
         int index = 0;
         int index = 0;
@@ -50,7 +57,10 @@ public class BusServerServiceImpl implements BusServerService {
         if (id.contains(splitItem)) {
         if (id.contains(splitItem)) {
             String[] split = id.split(splitItem);
             String[] split = id.split(splitItem);
             for (int i = 0; i < split.length; i++) {
             for (int i = 0; i < split.length; i++) {
+                BusServer busServer = busServerMapper.selectByPrimaryKey(split[i]);
                 int num = busServerMapper.deleteByPrimaryKey(split[i]);
                 int num = busServerMapper.deleteByPrimaryKey(split[i]);
+                // 异步删除与该服务器相关的：虚拟主机，配置关系，队列，交换机，路由键
+                asyncTaskService.serverCascadeDelete(busServer);
                 if (num > 0) {
                 if (num > 0) {
                     index = index + num;
                     index = index + num;
                 }
                 }
@@ -61,7 +71,11 @@ public class BusServerServiceImpl implements BusServerService {
                 return 0;
                 return 0;
             }
             }
         } else {
         } else {
-            return busServerMapper.deleteByPrimaryKey(id);
+            BusServer busServer = busServerMapper.selectByPrimaryKey(id);
+            int num = busServerMapper.deleteByPrimaryKey(id);
+            // 异步删除与该服务器相关的：虚拟主机，配置关系，队列，交换机，路由键
+            asyncTaskService.serverCascadeDelete(busServer);
+            return num;
         }
         }
     }
     }
 
 

@@ -447,6 +447,30 @@ public class UserMessageBindingServiceImpl implements UserMessageBindingService
     {
     {
         return userMessageBindingMapper.selectByRoutingKeyId(routingKeyId);
         return userMessageBindingMapper.selectByRoutingKeyId(routingKeyId);
     }
     }
+
+    @Override
+    public List<UserMessageBinding> selectByVirtualHostId(String virtualHostId)
+    {
+        return userMessageBindingMapper.selectByVirtualHostId(virtualHostId);
+    }
+
+    @Override
+    public int deleteByVirtualHostId(String virtualHostId)
+    {
+        return userMessageBindingMapper.deleteByVirtualHostId(virtualHostId);
+    }
+
+    @Override
+    public List<UserMessageBinding> selectByServerId(String serverId)
+    {
+        return userMessageBindingMapper.selectByServerId(serverId);
+    }
+
+    @Override
+    public int deleteByServerId(String serverId)
+    {
+        return userMessageBindingMapper.deleteByServerId(serverId);
+    }
 }
 }
 
 
 
 

@@ -5,12 +5,15 @@ import com.github.pagehelper.PageInfo;
 import com.sunyo.wlpt.message.bus.service.domain.VirtualHost;
 import com.sunyo.wlpt.message.bus.service.domain.VirtualHost;
 import com.sunyo.wlpt.message.bus.service.mapper.VirtualHostMapper;
 import com.sunyo.wlpt.message.bus.service.mapper.VirtualHostMapper;
 import com.sunyo.wlpt.message.bus.service.service.VirtualHostService;
 import com.sunyo.wlpt.message.bus.service.service.VirtualHostService;
+import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.transaction.annotation.Transactional;
 
 
 import javax.annotation.Resource;
 import javax.annotation.Resource;
+import java.io.IOException;
 import java.util.List;
 import java.util.List;
+import java.util.concurrent.TimeoutException;
 
 
 /**
 /**
  * @author 子诚
  * @author 子诚
@@ -23,9 +26,13 @@ public class VirtualHostServiceImpl implements VirtualHostService {
     @Resource
     @Resource
     private VirtualHostMapper virtualHostMapper;
     private VirtualHostMapper virtualHostMapper;
 
 
+    @Lazy
+    @Resource
+    private AsyncTaskService asyncTaskService;
+
     @Override
     @Override
     @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
     @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
-    public int deleteByPrimaryKey(String id)
+    public int deleteByPrimaryKey(String id) throws IOException, TimeoutException
     {
     {
         // 判断删除的个数，需被删除的个数是否一致
         // 判断删除的个数，需被删除的个数是否一致
         int index = 0;
         int index = 0;
@@ -34,7 +41,10 @@ public class VirtualHostServiceImpl implements VirtualHostService {
         if (id.contains(splitItem)) {
         if (id.contains(splitItem)) {
             String[] split = id.split(splitItem);
             String[] split = id.split(splitItem);
             for (int i = 0; i < split.length; i++) {
             for (int i = 0; i < split.length; i++) {
+                VirtualHost virtualHost = virtualHostMapper.selectByPrimaryKey(split[i]);
                 int num = virtualHostMapper.deleteByPrimaryKey(split[i]);
                 int num = virtualHostMapper.deleteByPrimaryKey(split[i]);
+                // 异步删除与该虚拟主机相关的队列，交换机，路由键，配置关系
+                asyncTaskService.virtualHostCascadeDelete(virtualHost);
                 if (num > 0) {
                 if (num > 0) {
                     index = index + num;
                     index = index + num;
                 }
                 }
@@ -46,7 +56,11 @@ public class VirtualHostServiceImpl implements VirtualHostService {
             }
             }
 
 
         } else {
         } else {
-            return virtualHostMapper.deleteByPrimaryKey(id);
+            VirtualHost virtualHost = virtualHostMapper.selectByPrimaryKey(id);
+            int num = virtualHostMapper.deleteByPrimaryKey(id);
+            // 异步删除与该虚拟主机相关的队列，交换机，路由键，配置关系
+            asyncTaskService.virtualHostCascadeDelete(virtualHost);
+            return num;
         }
         }
 
 
     }
     }
@@ -108,4 +122,15 @@ public class VirtualHostServiceImpl implements VirtualHostService {
         return virtualHostMapper.selectVirtualHostExist(virtualHost);
         return virtualHostMapper.selectVirtualHostExist(virtualHost);
     }
     }
 
 
+    @Override
+    public List<VirtualHost> selectByServerId(String serverId)
+    {
+        return virtualHostMapper.selectByServerId(serverId);
+    }
+
+    @Override
+    public int deleteByServerId(String serverId)
+    {
+        return virtualHostMapper.deleteByServerId(serverId);
+    }
 }
 }

@@ -40,6 +40,16 @@
         from bus_exchange
         from bus_exchange
         where id = #{id,jdbcType=VARCHAR}
         where id = #{id,jdbcType=VARCHAR}
     </select>
     </select>
+
+    <!-- 获取交换机列表，根据虚拟主机id -->
+    <select id="selectByVirtualHostId" parameterType="java.lang.String" resultMap="BaseResultMap">
+        <!--@mbg.generated-->
+        select
+        <include refid="Base_Column_List"/>
+        from bus_exchange
+        where virtual_host_id = #{virtualHostId,jdbcType=VARCHAR}
+    </select>
+
     <!-- 获取交换机列表 -->
     <!-- 获取交换机列表 -->
     <select id="selectBusExchangeList" parameterType="com.sunyo.wlpt.message.bus.service.domain.BusExchange"
     <select id="selectBusExchangeList" parameterType="com.sunyo.wlpt.message.bus.service.domain.BusExchange"
             resultMap="ExchangeAndHostMap">
             resultMap="ExchangeAndHostMap">
@@ -101,6 +111,14 @@
         from bus_exchange
         from bus_exchange
         where id = #{id,jdbcType=VARCHAR}
         where id = #{id,jdbcType=VARCHAR}
     </delete>
     </delete>
+
+    <delete id="deleteByVirtualHostId" parameterType="java.lang.String">
+        <!--@mbg.generated-->
+        delete
+        from bus_exchange
+        where virtual_host_id = #{virtualHostId,jdbcType=VARCHAR}
+    </delete>
+
     <insert id="insert" parameterType="com.sunyo.wlpt.message.bus.service.domain.BusExchange">
     <insert id="insert" parameterType="com.sunyo.wlpt.message.bus.service.domain.BusExchange">
         <!--@mbg.generated-->
         <!--@mbg.generated-->
         insert into bus_exchange (id, exchange_name, virtual_host_id,
         insert into bus_exchange (id, exchange_name, virtual_host_id,

@@ -28,12 +28,28 @@
       from bus_queue
       from bus_queue
       where id = #{id,jdbcType=VARCHAR}
       where id = #{id,jdbcType=VARCHAR}
   </select>
   </select>
+
+  <select id="selectByVirtualHostId" parameterType="java.lang.String" resultMap="BaseResultMap">
+      select
+      <include refid="Base_Column_List"/>
+      from bus_queue
+      where virtual_host_id = #{virtualHostId,jdbcType=VARCHAR}
+  </select>
+
   <delete id="deleteByPrimaryKey" parameterType="java.lang.String">
   <delete id="deleteByPrimaryKey" parameterType="java.lang.String">
       <!--@mbg.generated-->
       <!--@mbg.generated-->
       delete
       delete
       from bus_queue
       from bus_queue
       where id = #{id,jdbcType=VARCHAR}
       where id = #{id,jdbcType=VARCHAR}
   </delete>
   </delete>
+
+  <delete id="deleteByVirtualHostId" parameterType="java.lang.String">
+      <!--@mbg.generated-->
+      delete
+      from bus_queue
+      where virtual_host_id = #{virtualHostId,jdbcType=VARCHAR}
+  </delete>
+
   <insert id="insert" parameterType="com.sunyo.wlpt.message.bus.service.domain.BusQueue">
   <insert id="insert" parameterType="com.sunyo.wlpt.message.bus.service.domain.BusQueue">
       <!--@mbg.generated-->
       <!--@mbg.generated-->
       insert into bus_queue (id, queue_name, user_id,
       insert into bus_queue (id, queue_name, user_id,

@@ -42,6 +42,22 @@
       where routing_key_id = #{routingKeyId,jdbcType=VARCHAR}
       where routing_key_id = #{routingKeyId,jdbcType=VARCHAR}
   </select>
   </select>
 
 
+    <select id="selectByServerId" parameterType="java.lang.String" resultMap="BaseResultMap">
+        <!--@mbg.generated-->
+        select
+        <include refid="Base_Column_List"/>
+        from user_message_binding
+        where server_id = #{serverId,jdbcType=VARCHAR}
+    </select>
+
+  <select id="selectByVirtualHostId" parameterType="java.lang.String" resultMap="BaseResultMap">
+      <!--@mbg.generated-->
+      select
+      <include refid="Base_Column_List"/>
+      from user_message_binding
+      where virtual_host_id = #{virtualHostId,jdbcType=VARCHAR}
+  </select>
+
   <delete id="deleteByPrimaryKey" parameterType="java.lang.String">
   <delete id="deleteByPrimaryKey" parameterType="java.lang.String">
       <!--@mbg.generated-->
       <!--@mbg.generated-->
       delete
       delete
@@ -49,6 +65,20 @@
       where id = #{id,jdbcType=VARCHAR}
       where id = #{id,jdbcType=VARCHAR}
   </delete>
   </delete>
 
 
+<!--  根据服务器id，删除配置关系-->
+    <delete id="deleteByServerId" parameterType="java.lang.String">
+        <!--@mbg.generated-->
+        delete
+        from user_message_binding
+        where server_id = #{serverId,jdbcType=VARCHAR}
+    </delete>
+    <!--  根据虚拟主机id，删除配置关系-->
+    <delete id="deleteByVirtualHostId" parameterType="java.lang.String">
+        <!--@mbg.generated-->
+        delete
+        from user_message_binding
+        where virtual_host_id = #{virtualHostId,jdbcType=VARCHAR}
+    </delete>
     <!--  根据交换机id，删除配置关系-->
     <!--  根据交换机id，删除配置关系-->
     <delete id="deleteByExchangeId" parameterType="java.lang.String">
     <delete id="deleteByExchangeId" parameterType="java.lang.String">
         <!--@mbg.generated-->
         <!--@mbg.generated-->

@@ -32,6 +32,16 @@
         from virtual_host
         from virtual_host
         where id = #{id,jdbcType=VARCHAR}
         where id = #{id,jdbcType=VARCHAR}
     </select>
     </select>
+
+    <!--  根据服务器id,查询虚拟主机列表  -->
+    <select id="selectByServerId" parameterType="java.lang.String" resultMap="BaseResultMap">
+        <!--@mbg.generated-->
+        select
+        <include refid="Base_Column_List"/>
+        from virtual_host
+        where server_id = #{serverId,jdbcType=VARCHAR}
+    </select>
+
     <!--  查询虚拟主机列表，选择性  -->
     <!--  查询虚拟主机列表，选择性  -->
     <select id="selectVirtualHostList" parameterType="com.sunyo.wlpt.message.bus.service.domain.VirtualHost"
     <select id="selectVirtualHostList" parameterType="com.sunyo.wlpt.message.bus.service.domain.VirtualHost"
             resultMap="HostAndServerMap">
             resultMap="HostAndServerMap">
@@ -108,6 +118,14 @@
         from virtual_host
         from virtual_host
         where id = #{id,jdbcType=VARCHAR}
         where id = #{id,jdbcType=VARCHAR}
     </delete>
     </delete>
+
+    <delete id="deleteByServerId" parameterType="java.lang.String">
+        <!--@mbg.generated-->
+        delete
+        from virtual_host
+        where  server_id = #{serverId,jdbcType=VARCHAR}
+    </delete>
+
     <insert id="insert" parameterType="com.sunyo.wlpt.message.bus.service.domain.VirtualHost">
     <insert id="insert" parameterType="com.sunyo.wlpt.message.bus.service.domain.VirtualHost">
         <!--@mbg.generated-->
         <!--@mbg.generated-->
         insert into virtual_host (id, virtual_host_name, server_id,
         insert into virtual_host (id, virtual_host_name, server_id,