devbox
天景科技苑
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SpringBoot MySQL BinLog 监听数据变化(多库多表)

作者：天景科技苑 | 2024-08-21 12:21:02

赞

踩

SpringBoot MySQL BinLog 监听数据变化(多库多表)

开始

1：引入mysql-binlog-connector-java.jar

  1.     <!-- binlog -->
  2.         <dependency>
  3.             <groupId>com.zendesk</groupId>
  4.             <artifactId>mysql-binlog-connector-java</artifactId>
  5.             <version>0.27.1</version>
  6.         </dependency>
  7.         <!-- guava -->
  8.         <dependency>
  9.             <groupId>com.google.guava</groupId>
  10.             <artifactId>guava</artifactId>
  11.             <version>31.1-jre</version>
  12.         </dependency>

2：配置文件

  1. #用户必须要有权限
  2. binlog:
  3.   # 服务器地址
  4.   host: localhost
  5.   port: 3306
  6.   username: root
  7.   password: 123456
  8.   # 监听数据库与表,隔开，格式[库.表,,,]
  9.   dbTable: 库.表,库1.表1,库1.表2
  10.   serverId: 1

注：1：mysql8.0之后binlog是默认开启的

        2：需要一个mysql查看binlog的权限用户

获取配置文件参数 BinLogConfig

  1. /**
  2.  * @Description binlog配置
  3.  * @Author WangKun
  4.  * @Date 2024/8/8 15:01
  5.  * @Version
  6.  */
  7. @Data
  8. @Component
  9. public class BinLogConfig {
  10.  
  11.     /**
  12.      * mysql服务地址
  13.      **/
  14.     @Value("${binlog.host}")
  15.     private String host;
  16.  
  17.     /**
  18.      * mysql数据库端口号
  19.      **/
  20.     @Value("${binlog.port}")
  21.     private int port;
  22.  
  23.     /**
  24.      * 查看BinLog权限用户名
  25.      **/
  26.     @Value("${binlog.username}")
  27.     private String username;
  28.  
  29.     /**
  30.      * 查看BinLog权限密码
  31.      **/
  32.     @Value("${binlog.password}")
  33.     private String password;
  34.  
  35.     /**
  36.      * 库表
  37.      **/
  38.     @Value("${binlog.dbTable}")
  39.     private String dbTable;
  40.  
  41.     /**
  42.      * 服务标识
  43.      **/
  44.     @Value("${binlog.serverId}")
  45.     private Integer serverId;
  46.  
  47.     /**
  48.      * 获取所有库表，并转化
  49.      **/
  50.     private List<String> tables;
  51.  
  52.     public List<String> getTables() {
  53.         if (StringUtils.hasText(dbTable)){
  54.             tables = Arrays.asList(dbTable.split(BinLogUtils.COMMA));
  55.         }
  56.         return tables;
  57.     }
  58.  
  59. }

BinLog与字段类型实体对象

  1. /**
  2.  * @Description Binlog实体对象
  3.  * @Author WangKun
  4.  * @Date 2024/8/8 16:56
  5.  * @Version
  6.  */
  7. @Data
  8. public class BinLog implements Serializable {
  9.  
  10.     /**
  11.      * 库表
  12.      **/
  13.     private String dbTable;
  14.     /**
  15.      * 事件类型
  16.      **/
  17.     private EventType eventType;
  18.     /**
  19.      * 存储字段-之前的值
  20.      **/
  21.     private Map<String, Serializable> before;
  22.     /**
  23.      * 存储字段-之后的值
  24.      **/
  25.     private Map<String, Serializable> after;
  26.     /**
  27.      * 存储字段--类型
  28.      **/
  29.     private Map<String, Field> fields;
  30.  
  31.  
  32. }
  1. /**
  2.  * @Description 字段
  3.  * @Author WangKun
  4.  * @Date 2024/8/8 16:33
  5.  * @Version
  6.  */
  7. @AllArgsConstructor
  8. @Data
  9. public class Field implements Serializable {
  10.  
  11.     /**
  12.      * 数据库
  13.      **/
  14.     public String schema;
  15.  
  16.     /**
  17.      * 表
  18.      **/
  19.     public String table;
  20.  
  21.     /**
  22.      * 列索引位置
  23.      **/
  24.     public int inx;
  25.     /**
  26.      * 列名
  27.      **/
  28.     public String colName;
  29.     /**
  30.      * 类型
  31.      **/
  32.     public String dataType;
  33.  
  34.  
  35. }

BinLog事件类型枚举（新增，修改，删除）

  1. /**
  2.  * @Description BinLog事件枚举
  3.  * @Author WangKun
  4.  * @Date 2024/8/19 15:23
  5.  * @Version
  6.  */
  7. @Getter
  8. @AllArgsConstructor
  9. public enum BinLogEventEnum {
  10.  
  11.     WRITE("WRITE"),UPDATE("UPDATE"),DELETE("DELETE");
  12.  
  13.     /**
  14.      * 获取key
  15.      **/
  16.     private final String key;
  17.  
  18. }

BinLog工具与BinLog数据操作工具

  1. /**
  2.  * @Description Binlog工具
  3.  * @Author WangKun
  4.  * @Date 2024/8/8 17:09
  5.  * @Version
  6.  */
  7. @Slf4j
  8. public class BinLogUtils {
  9.  
  10.     /**
  11.      * 逗号
  12.      **/
  13.     public final static String COMMA = ",";
  14.     /**
  15.      * 点
  16.      **/
  17.     public final static String POINT = ".";
  18.  
  19.     /**
  20.      * 双斜线
  21.      **/
  22.     public final static String D_SLASH = "\\";
  23.  
  24.  
  25.  
  26.     public static final long QUEUE_SLEEP = 1000;
  27.  
  28.     /**
  29.      * @param db
  30.      * @param table
  31.      * @Description 拼接DB与Table
  32.      * @Throws
  33.      * @Return java.lang.String
  34.      * @Date 2024-08-12 16:09:10
  35.      * @Author WangKun
  36.      **/
  37.     public static String getDbTable(String db, String table) {
  38.         return db + "-" + table;
  39.     }
  40.  
  41. }
  1. /**
  2.  * @Description BinLog数据工具
  3.  * @Author WangKun
  4.  * @Date 2024/8/12 16:40
  5.  * @Version
  6.  */
  7. @Slf4j
  8. public class BinLogDataUtils {
  9.  
  10.  
  11.     /**
  12.      * @param db
  13.      * @param table
  14.      * @Description 获取columns集合
  15.      * @Throws
  16.      * @Return java.util.Map<java.lang.String, com.harmonywisdom.binlog.entity.Field>
  17.      * @Date 2024-08-12 16:10:08
  18.      * @Author WangKun
  19.      **/
  20.     public static Map<String, Field> getColumnsMap(String db, String table) {
  21.         PreparedStatement ps = null;
  22.         ResultSet rs = null;
  23.         Connection connection = null;
  24.         try {
  25.             //获取数据源
  26.             DataSource dataSource = SpringUtil.getBean(DataSource.class);
  27.             connection = dataSource.getConnection();
  28.             // 执行sql获取表数据
  29.             String preSql = "SELECT TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME, DATA_TYPE, ORDINAL_POSITION FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = ? and TABLE_NAME = ?";
  30.             ps = connection.prepareStatement(preSql);
  31.             ps.setString(1, db);
  32.             ps.setString(2, table);
  33.             rs = ps.executeQuery();
  34.             Map<String, Field> map = new HashMap<>(rs.getRow());
  35.             while (rs.next()) {
  36.                 String column = rs.getString("COLUMN_NAME");
  37.                 int idx = rs.getInt("ORDINAL_POSITION");
  38.                 if (column != null && idx >= 1) {
  39.                     // sql的位置从1开始
  40.                     map.put(column, new Field(rs.getString("TABLE_SCHEMA"), rs.getString("TABLE_NAME"), idx - 1, column, rs.getString("DATA_TYPE")));
  41.                 }
  42.             }
  43.             ps.close();
  44.             rs.close();
  45.             connection.close();
  46.             return map;
  47.         } catch (SQLException e) {
  48.             log.error("加载BinLog监控配置库.表字段错误, db_table={}.{} ", db, table, e);
  49.         } finally {
  50.             try {
  51.                 if (ps != null) {
  52.                     ps.close();
  53.                 }
  54.                 if (rs != null) {
  55.                     rs.close();
  56.                 }
  57.                 if (connection != null) {
  58.                     connection.close();
  59.                 }
  60.             } catch (SQLException e) {
  61.                 log.error("加载BinLog监控配置库.表字段错误关闭连接失败, db_table={}.{} ", db, table, e);
  62.             }
  63.         }
  64.         return null;
  65.     }
  66.  
  67.     /**
  68.      * @param row
  69.      * @param dbTable
  70.      * @param columMap
  71.      * @param eventType
  72.      * @Description 新增或删除操作数据格式化
  73.      * @Throws
  74.      * @Return com.harmonywisdom.binlog.entity.BinLog
  75.      * @Date 2024-08-12 16:53:07
  76.      * @Author WangKun
  77.      **/
  78.     private static BinLog insertOrDeletedColum(Serializable[] row, String dbTable, Map<String, Field> columMap, EventType eventType) {
  79.         if (null == row || null == columMap || row.length != columMap.size()) {
  80.             return null;
  81.         }
  82.         // 初始化Item
  83.         BinLog item = new BinLog();
  84.         item.setEventType(eventType);
  85.         item.setFields(columMap);
  86.         Map<String, Serializable> beOrAf = new HashMap<>();
  87.         columMap.forEach((key, colum) -> {
  88.             Serializable serializable = row[colum.inx];
  89.             if (serializable instanceof byte[]) {
  90.                 beOrAf.put(key, new String((byte[]) serializable));
  91.             } else {
  92.                 beOrAf.put(key, serializable);
  93.             }
  94.         });
  95.         // 写操作放after，删操作放before
  96.         if (isWrite(eventType)) {
  97.             item.setAfter(beOrAf);
  98.         }
  99.         if (isDelete(eventType)) {
  100.             item.setBefore(beOrAf);
  101.         }
  102.         return item;
  103.     }
  104.  
  105.     /**
  106.      * @param mapEntry
  107.      * @param columMap
  108.      * @param eventType
  109.      * @Description 更新操作数据格式化
  110.      * @Throws
  111.      * @Return com.harmonywisdom.binlog.entity.BinLog
  112.      * @Date 2024-08-12 16:52:46
  113.      * @Author WangKun
  114.      **/
  115.     private static BinLog updateColum(Map.Entry<Serializable[], Serializable[]> mapEntry, Map<String, Field> columMap, EventType eventType) {
  116.         if (null == mapEntry || null == columMap) {
  117.             return null;
  118.         }
  119.         BinLog item = new BinLog();
  120.         item.setEventType(eventType);
  121.         item.setFields(columMap);
  122.         Map<String, Serializable> be = new HashMap<>();
  123.         Map<String, Serializable> af = new HashMap<>();
  124.         columMap.forEach((key, colum) -> {
  125.             Serializable serializableKey = mapEntry.getKey()[colum.inx];
  126.             Serializable serializableValue = mapEntry.getValue()[colum.inx];
  127.             if (serializableKey instanceof byte[]) {
  128.                 be.put(key, new String((byte[]) serializableKey));
  129.             } else {
  130.                 be.put(key, serializableKey);
  131.             }
  132.             if (serializableValue instanceof byte[]) {
  133.                 af.put(key, new String((byte[]) serializableValue));
  134.             } else {
  135.                 af.put(key, serializableValue);
  136.             }
  137.         });
  138.         item.setBefore(be);
  139.         item.setAfter(af);
  140.         return item;
  141.     }
  142.  
  143.     /**
  144.      * @param data
  145.      * @param dbTableIdCols
  146.      * @param dbTableCols
  147.      * @param eventType
  148.      * @param queue
  149.      * @Description 更新数据
  150.      * @Throws
  151.      * @Return void
  152.      * @Date 2024-08-14 17:35:49
  153.      * @Author WangKun
  154.      **/
  155.     public static void updateData(UpdateRowsEventData data, Map<Long, String> dbTableIdCols, Map<String, Map<String, Field>> dbTableCols, EventType eventType, BlockingQueue<BinLog> queue) {
  156.         for (Map.Entry<Serializable[], Serializable[]> row : data.getRows()) {
  157.             if (dbTableIdCols.containsKey(data.getTableId())) {
  158.                 String dbTable = dbTableIdCols.get(data.getTableId());
  159.                 BinLog item = updateColum(row, dbTableCols.get(dbTable), eventType);
  160.                 item.setDbTable(dbTable);
  161.                 try {
  162.                     queue.put(item);
  163.                 } catch (InterruptedException e) {
  164.                     log.error("BinLog 更新数据添加阻塞队列异常：{}", e.getMessage(), e);
  165.                 }
  166.             }
  167.         }
  168.     }
  169.  
  170.     /**
  171.      * @param eventType
  172.      * @param rows
  173.      * @param tableId
  174.      * @param dbTableIdCols
  175.      * @param dbTableCols
  176.      * @param queue
  177.      * @Description 新增与删除数据
  178.      * @Throws
  179.      * @Return void
  180.      * @Date 2024-08-13 17:30:30
  181.      * @Author WangKun
  182.      **/
  183.     public static void insertOrDeletedData(EventType eventType, List<Serializable[]> rows, long tableId, Map<Long, String> dbTableIdCols, Map<String, Map<String, Field>> dbTableCols, BlockingQueue<BinLog> queue) {
  184.         for (Serializable[] row : rows) {
  185.             if (dbTableIdCols.containsKey(tableId)) {
  186.                 String dbTable = dbTableIdCols.get(tableId);
  187.                 BinLog item = insertOrDeletedColum(row, dbTable, dbTableCols.get(dbTable), eventType);
  188.                 item.setDbTable(dbTable);
  189.                 try {
  190.                     queue.put(item);
  191.                 } catch (InterruptedException e) {
  192.                     log.error("BinLog 新增或者删除数据添加阻塞队列异常：{}", e.getMessage(), e);
  193.                 }
  194.             }
  195.         }
  196.     }
  197.  
  198. }

BinLog监听

  1. /**
  2.  * @Description 监听（@FunctionalInterface确保该接口只有以一个抽象方法）
  3.  * @Author WangKun
  4.  * @Date 2024/8/8 17:31
  5.  * @Version
  6.  */
  7. @FunctionalInterface
  8. public interface BinLogListener {
  9.  
  10.     void onEvent(BinLog binLog);
  11.  
  12. }
  1. /**
  2.  * @Description MySQL监听
  3.  * @Author WangKun
  4.  * @Date 2024/8/8 17:32
  5.  * @Version
  6.  */
  7. @Slf4j
  8. public class MySQLBinLogListener implements BinaryLogClient.EventListener {
  9.  
  10.  
  11.     /**
  12.      * BinLog连接信息
  13.      **/
  14.     private final BinaryLogClient client;
  15.  
  16.     /**
  17.      * 阻塞队列，存放信息
  18.      **/
  19.     private final BlockingQueue<BinLog> queue;
  20.  
  21.     /**
  22.      * 线程池
  23.      **/
  24.     private final ExecutorService executorService;
  25.  
  26.     /**
  27.      * 存放每张数据表对应的listener器,允许将多个值存储在单个键下（每张表一个监听器）
  28.      **/
  29.     private final Multimap<String, BinLogListener> listeners;
  30.  
  31.     /**
  32.      * 存放监控所有库表结构
  33.      **/
  34.     private final Map<String, Map<String, Field>> dbTableCols;
  35.  
  36.     /**
  37.      * 存放改变的库表结构
  38.      **/
  39.     private final Map<Long, String> dbTableIdCols;
  40.  
  41.     /**
  42.      * @param conf
  43.      * @Description 监听器初始化配置
  44.      * @Throws
  45.      * @Return
  46.      * @Date 2024-08-13 16:53:18
  47.      * @Author WangKun
  48.      **/
  49.     public MySQLBinLogListener(BinLogConfig conf) {
  50.         BinaryLogClient client = new BinaryLogClient(conf.getHost(), conf.getPort(), conf.getUsername(), conf.getPassword());
  51.         EventDeserializer eventDeserializer = new EventDeserializer();
  52.         // 序列化
  53.         eventDeserializer.setCompatibilityMode(
  54.                 EventDeserializer.CompatibilityMode.DATE_AND_TIME_AS_LONG,
  55.                 EventDeserializer.CompatibilityMode.CHAR_AND_BINARY_AS_BYTE_ARRAY
  56.         );
  57.         client.setEventDeserializer(eventDeserializer);
  58.         client.setServerId(conf.getServerId());
  59.         this.client = client;
  60.         this.queue = new ArrayBlockingQueue<>(ThreadPoolConfig.queueCapacity);
  61.         this.listeners = ArrayListMultimap.create();
  62.         this.dbTableCols = new ConcurrentHashMap<>();
  63.         this.dbTableIdCols = new ConcurrentHashMap<>();
  64.         // 开启线程池
  65.         this.executorService = ThreadPoolUtils.create().setPrefixName("Binlog-Listener-Thread").setCorePoolSize(6).build();
  66.     }
  67.  
  68.     /**
  69.      * @param event
  70.      * @Description 监听处理, 只支持MySQL中BinLog的ROW模式的
  71.      * @Throws
  72.      * @Return void
  73.      * @Date 2024-08-13 16:54:01
  74.      * @Author WangKun
  75.      **/
  76.     @Override
  77.     public void onEvent(Event event) {
  78.         EventType eventType = event.getHeader().getEventType();
  79.         // 装配库表结构
  80.         if (eventType == EventType.TABLE_MAP) {
  81.             TableMapEventData tableData = event.getData();
  82.             String dbTable = BinLogUtils.getDbTable(tableData.getDatabase(), tableData.getTable());
  83.             if (dbTableCols.containsKey(dbTable)) {
  84.                 dbTableIdCols.put(tableData.getTableId(), dbTable);
  85.             }
  86.         }
  87.         //新增数据
  88.         if (EventType.isWrite(eventType)) {
  89.             WriteRowsEventData data = event.getData();
  90.             BinLogDataUtils.insertOrDeletedData(eventType, data.getRows(), data.getTableId(), dbTableIdCols, dbTableCols, queue);
  91.         } else if (EventType.isUpdate(eventType)) {
  92.             // 更新数据
  93.             UpdateRowsEventData data = event.getData();
  94.             BinLogDataUtils.updateData(data, dbTableIdCols, dbTableCols, eventType, queue);
  95.         } else if (EventType.isDelete(eventType)) {
  96.             // 删除数据
  97.             DeleteRowsEventData data = event.getData();
  98.             BinLogDataUtils.insertOrDeletedData(eventType, data.getRows(), data.getTableId(), dbTableIdCols, dbTableCols, queue);
  99.         }
  100.     }
  101.  
  102.     /**
  103.      * @param db
  104.      * @param table
  105.      * @param listener
  106.      * @Description 注册监听
  107.      * @Throws
  108.      * @Return void
  109.      * @Date 2024-08-13 17:32:44
  110.      * @Author WangKun
  111.      **/
  112.     public void registerListener(String db, String table, BinLogListener listener) {
  113.         String dbTable = BinLogUtils.getDbTable(db, table);
  114.         // 连接获取字段集合
  115.         Map<String, Field> cols = BinLogDataUtils.getColumnsMap(db, table);
  116.         // 保存字段信息
  117.         dbTableCols.put(dbTable, cols);
  118.         // 保存当前注册的listener
  119.         listeners.put(dbTable, listener);
  120.     }
  121.  
  122.     /**
  123.      * @param
  124.      * @Description 开启异步多线程消费
  125.      * @Throws
  126.      * @Return void
  127.      * @Date 2024-08-13 18:02:48
  128.      * @Author WangKun
  129.      **/
  130.     @Async
  131.     public void openThreadConsumeBinLog(){
  132.         client.registerEventListener(this);
  133.         for (int i = 0; i < ThreadPoolConfig.corePoolSize*ThreadPoolConfig.CPU_NUMS; i++) {
  134.             executorService.execute(() -> {
  135.                 // 轮询监控
  136.                 while (true) {
  137.                     if (!queue.isEmpty()) {
  138.                         try {
  139.                             BinLog binLogQueue = queue.take();
  140.                             listeners.get(binLogQueue.getDbTable()).forEach(binLogListener -> binLogListener.onEvent(binLogQueue));
  141.                         } catch (InterruptedException e) {
  142.                             log.error("BinLog多线程消费异常：{}", e.getMessage(), e);
  143.                         }
  144.                     }
  145.                 }
  146.             });
  147.         }
  148.         try {
  149.             //连接(不设置时间将会使用主线程)
  150.             client.connect(BinLogUtils.QUEUE_SLEEP);
  151.         } catch (Exception e) {
  152.             log.error("BinLog多线程连接消费异常：{}", e.getMessage(), e);
  153.         }
  154.     }
  155. }
  1. /**
  2.  * @Description 初始化Binlog监听
  3.  * @Author WangKun
  4.  * @Date 2024/8/9 10:36
  5.  * @Version
  6.  */
  7. @Slf4j
  8. @RequiredArgsConstructor
  9. @Component
  10. @Order(value = 1)
  11. public class BinLogInitListener implements CommandLineRunner {
  12.  
  13.     /**
  14.      * 资源注入
  15.      **/
  16.     private final BinLogConfig config;
  17.  
  18.     /**
  19.      * @param args
  20.      * @Description 初始化
  21.      * @Throws
  22.      * @Return void
  23.      * @Date 2024-08-13 14:07:49
  24.      * @Author WangKun
  25.      **/
  26.     @Override
  27.     public void run(String... args) throws Exception {
  28.         try {
  29.             // 初始化监听器
  30.             MySQLBinLogListener mySqlBinLogListener = new MySQLBinLogListener(config);
  31.             this.getListMap().forEach((db, tables) -> {
  32.                 tables.forEach(table -> {
  33.                     mySqlBinLogListener.registerListener(db, table, info -> {
  34.                         if(info.getEventType().name().contains(BinLogEventEnum.UPDATE.getKey())){
  35.                             log.info("库.表: {}, 修改之前：{}" ,db+"."+table,info.getBefore().toString());
  36.                             log.info("库.表: {}, 修改之后：{}" ,db+"."+table,info.getAfter().toString());
  37.                         }
  38.                         if(info.getEventType().name().contains(BinLogEventEnum.WRITE.getKey())){
  39.                             log.info("库.表: {}, 新增: {}" ,db+"."+table,info.getAfter().toString());
  40.                         }
  41.                         if(info.getEventType().name().contains(BinLogEventEnum.DELETE.getKey())){
  42.                             log.info("库.表: {}, 删除: {}" ,db+"."+table,info.getBefore().toString());
  43.                         }
  44.                     });
  45.                 });
  46.             });
  47.             // 开启多线程消费
  48.             mySqlBinLogListener.openThreadConsumeBinLog();
  49.         } catch (Exception e) {
  50.             log.error("BinLog初始化监听异常：{}", e.getMessage(), e);
  51.         }
  52.     }
  53.  
  54.     /**
  55.      * @param
  56.      * @Description 初始化监听库表
  57.      * @Throws
  58.      * @Return java.util.Map<java.lang.String, java.util.List < java.lang.String>>
  59.      * @Date 2024-08-12 16:19:32
  60.      * @Author WangKun
  61.      **/
  62.     private Map<String, List<String>> getListMap() {
  63.         Map<String, List<String>> map = new ConcurrentHashMap<>();
  64.         try {
  65.             for (String key : config.getTables()) {
  66.                 // 正则转义，要加双斜线
  67.                 String[] split = key.split(BinLogUtils.D_SLASH + BinLogUtils.POINT);
  68.                 if (split.length != 2) {
  69.                     log.error("BinLog配置同步,类型错误 [库名.表名]。请正确配置:{}", key);
  70.                     throw new Exception("BinLog配置同步,类型错误 [库名.表名]。请正确配置:" + key);
  71.                 }
  72.                 map.computeIfAbsent(split[0], k -> new ArrayList<>()).add(split[1]);
  73.             }
  74.             return map;
  75.         } catch (Exception e) {
  76.             log.error("BinLog配置同步,类型错误 [库名.表名]。请正确配置:{}", e.getMessage(), e);
  77.         }
  78.         return map;
  79.     }
  80.  
  81. }

目录结构

启动IDEA，在控制台出现以下信息，成功

2024-08-19 17:40:47.129  INFO 493984 --- [       blc-localhost:3306] c.g.shyiko.mysql.binlog.BinaryLogClient  : Connected to localhost:3306 at log.000004/7294671 (sid:1, cid:800)

效果：

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/天景科技苑/article/detail/1011755
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号