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

一个注解解决ShardingJdbc不支持复杂SQL_seata sharding冲突

作者：酷酷是懒虫 | 2024-06-25 19:08:16

赞

踩

seata sharding冲突

背景介绍

公司最近做分库分表业务，接入了 Sharding JDBC，接入完成后，回归测试时发现好几个 SQL 执行报错，关键这几个表都还不是分片表。报错如下：

这下糟了嘛。熟悉 Sharding JDBC 的同学应该知道，有很多 SQL 它是不支持的。官方截图如下：

如果要去修改这些复杂 SQL 的话，可能要花费很多时间。那怎么办呢？只能从 Sharding JDBC 这里找突破口了，两天的研究，出来了下面这个只需要加一个注解轻松解决 Sharding Jdbc 不支持复杂 SQL 的方案。

问题复现

我本地写了一个复杂 SQL 进行测试：

  1. public List<Map<String, Object>> queryOrder(){
  2.         List<Map<String, Object>> orders = borderRepository.findOrders();
  3.         return orders;
  4.     }
  5.  
  1. public interface BOrderRepository extends JpaRepository<BOrder,Long> {
  2.  
  3.     @Query(value = "SELECT * FROM (SELECT id,CASE WHEN company_id =1 THEN '小' WHEN company_id=4 THEN '中' ELSE '大' END AS com,user_id as userId FROM b_order0) t WHERE t.com ='中'",nativeQuery =true)
  4.     List<Map<String, Object>> findOrders();
  5. }
  6.

写了个测试 controller 来调用，调用后果然报错了。

解决思路

因为查询的复杂 SQL 的表不是分片表，那能不能指定这几个复杂查询的时候不用 Sharding JDBC 的数据源呢？

  1. 在注入 Sharding JDBC 数据源的地方做处理，注入一个我们自定义的数据源
  2. 这样我们获取连接的时候就能返回原生数据源了
  3. 另外我们声明一个注解，对标识了注解的就返回原生数据源，否则还是返回 Sharding 数据源

具体实现

  1. 编写一个 autoConfig 类，来替换 ShardingSphereAutoConfiguration 类
  1. /**
  2.  * 动态数据源核心自动配置类
  3.  *
  4.  *
  5.  */
  6. @Configuration
  7. @ComponentScan("org.apache.shardingsphere.spring.boot.converter")
  8. @EnableConfigurationProperties(SpringBootPropertiesConfiguration.class)
  9. @ConditionalOnProperty(prefix = "spring.shardingsphere", name = "enabled", havingValue = "true", matchIfMissing = true)
  10. @AutoConfigureBefore(DataSourceAutoConfiguration.class)
  11. public class DynamicDataSourceAutoConfiguration implements EnvironmentAware {
  12.  
  13.     private String databaseName;
  14.  
  15.     private final SpringBootPropertiesConfiguration props;
  16.  
  17.     private final Map<String, DataSource> dataSourceMap = new LinkedHashMap<>();
  18.  
  19.     public DynamicDataSourceAutoConfiguration(SpringBootPropertiesConfiguration props) {
  20.         this.props = props;
  21.     }
  22.  
  23.     /**
  24.      * Get mode configuration.
  25.      *
  26.      * @return mode configuration
  27.      */
  28.     @Bean
  29.     public ModeConfiguration modeConfiguration() {
  30.         return null == props.getMode() ? null : new ModeConfigurationYamlSwapper().swapToObject(props.getMode());
  31.     }
  32.  
  33.     /**
  34.      * Get ShardingSphere data source bean.
  35.      *
  36.      * @param rules rules configuration
  37.      * @param modeConfig mode configuration
  38.      * @return data source bean
  39.      * @throws SQLException SQL exception
  40.      */
  41.     @Bean
  42.     @Conditional(LocalRulesCondition.class)
  43.     @Autowired(required = false)
  44.     public DataSource shardingSphereDataSource(final ObjectProvider<List<RuleConfiguration>> rules, final ObjectProvider<ModeConfiguration> modeConfig) throws SQLException {
  45.         Collection<RuleConfiguration> ruleConfigs = Optional.ofNullable(rules.getIfAvailable()).orElseGet(Collections::emptyList);
  46.         DataSource dataSource = ShardingSphereDataSourceFactory.createDataSource(databaseName, modeConfig.getIfAvailable(), dataSourceMap, ruleConfigs, props.getProps());
  47.         return new WrapShardingDataSource((ShardingSphereDataSource) dataSource,dataSourceMap);
  48.     }
  49.  
  50.     /**
  51.      * Get data source bean from registry center.
  52.      *
  53.      * @param modeConfig mode configuration
  54.      * @return data source bean
  55.      * @throws SQLException SQL exception
  56.      */
  57.     @Bean
  58.     @ConditionalOnMissingBean(DataSource.class)
  59.     public DataSource dataSource(final ModeConfiguration modeConfig) throws SQLException {
  60.         DataSource dataSource = !dataSourceMap.isEmpty() ? ShardingSphereDataSourceFactory.createDataSource(databaseName, modeConfig, dataSourceMap, Collections.emptyList(), props.getProps())
  61.                 : ShardingSphereDataSourceFactory.createDataSource(databaseName, modeConfig);
  62.         return new WrapShardingDataSource((ShardingSphereDataSource) dataSource,dataSourceMap);
  63.     }
  64.  
  65.     /**
  66.      * Create transaction type scanner.
  67.      *
  68.      * @return transaction type scanner
  69.      */
  70.     @Bean
  71.     public TransactionTypeScanner transactionTypeScanner() {
  72.         return new TransactionTypeScanner();
  73.     }
  74.  
  75.     @Override
  76.     public final void setEnvironment(final Environment environment) {
  77.         dataSourceMap.putAll(DataSourceMapSetter.getDataSourceMap(environment));
  78.         databaseName = DatabaseNameSetter.getDatabaseName(environment);
  79.     }
  80.  
  81.     @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
  82.     @Bean
  83.     @ConditionalOnProperty(prefix = "spring.datasource.dynamic.aop", name = "enabled", havingValue = "true", matchIfMissing = true)
  84.     public Advisor dynamicDatasourceAnnotationAdvisor() {
  85.         DynamicDataSourceAnnotationInterceptor interceptor = new DynamicDataSourceAnnotationInterceptor(true);
  86.         DynamicDataSourceAnnotationAdvisor advisor = new DynamicDataSourceAnnotationAdvisor(interceptor, DS.class);
  87.         return advisor;
  88.     }
  89.  
  90. }
  91.
  1. 自定义数据源
  1. public class WrapShardingDataSource extends AbstractDataSourceAdapter implements AutoCloseable{
  2.  
  3.     private ShardingSphereDataSource dataSource;
  4.  
  5.     private Map<String, DataSource> dataSourceMap;
  6.  
  7.     public WrapShardingDataSource(ShardingSphereDataSource dataSource, Map<String, DataSource> dataSourceMap) {
  8.         this.dataSource = dataSource;
  9.         this.dataSourceMap = dataSourceMap;
  10.     }
  11.  
  12.     public DataSource getTargetDataSource(){
  13.         String peek = DynamicDataSourceContextHolder.peek();
  14.         if(StringUtils.isEmpty(peek)){
  15.             return dataSource;
  16.         }
  17.         return dataSourceMap.get(peek);
  18.     }
  19.  
  20.     @Override
  21.     public Connection getConnection() throws SQLException {
  22.         return getTargetDataSource().getConnection();
  23.     }
  24.  
  25.     @Override
  26.     public Connection getConnection(final String username, final String password) throws SQLException {
  27.         return getConnection();
  28.     }
  29.  
  30.     @Override
  31.     public void close() throws Exception {
  32.         DataSource targetDataSource = getTargetDataSource();
  33.         if (targetDataSource instanceof AutoCloseable) {
  34.             ((AutoCloseable) targetDataSource).close();
  35.         }
  36.     }
  37.  
  38.     @Override
  39.     public int getLoginTimeout() throws SQLException {
  40.         DataSource targetDataSource = getTargetDataSource();
  41.         return targetDataSource ==null ? 0 : targetDataSource.getLoginTimeout();
  42.     }
  43.  
  44.     @Override
  45.     public void setLoginTimeout(final int seconds) throws SQLException {
  46.         DataSource targetDataSource = getTargetDataSource();
  47.         targetDataSource.setLoginTimeout(seconds);
  48.     }
  49. }
  50.
  1. 声明指定数据源注解
  1. @Target({ElementType.TYPE, ElementType.METHOD})
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Documented
  4. public @interface DS {
  5.  
  6.     /**
  7.      * 数据源名
  8.      */
  9.     String value();
  10. }
  11.
  1. 另外使用 AOP 的方式拦截使用了注解的类或方法，并且要将这些用了注解的方法存起来，在获取数据源连接的时候取出来进行判断。这就还要用到 ThreadLocal。

aop 拦截器：

  1. public class DynamicDataSourceAnnotationInterceptor implements MethodInterceptor {
  2.  
  3.     private final DataSourceClassResolver dataSourceClassResolver;
  4.  
  5.     public DynamicDataSourceAnnotationInterceptor(Boolean allowedPublicOnly) {
  6.         dataSourceClassResolver = new DataSourceClassResolver(allowedPublicOnly);
  7.     }
  8.  
  9.     @Override
  10.     public Object invoke(MethodInvocation invocation) throws Throwable {
  11.         String dsKey = determineDatasourceKey(invocation);
  12.         DynamicDataSourceContextHolder.push(dsKey);
  13.         try {
  14.             return invocation.proceed();
  15.         } finally {
  16.             DynamicDataSourceContextHolder.poll();
  17.         }
  18.     }
  19.  
  20.     private String determineDatasourceKey(MethodInvocation invocation) {
  21.         String key = dataSourceClassResolver.findKey(invocation.getMethod(), invocation.getThis());
  22.         return key;
  23.     }
  24. }
  25.

aop 切面定义：

  1. /**
  2.  * aop Advisor
  3.  */
  4. public class DynamicDataSourceAnnotationAdvisor extends AbstractPointcutAdvisor implements BeanFactoryAware {
  5.  
  6.     private final Advice advice;
  7.  
  8.     private final Pointcut pointcut;
  9.  
  10.     private final Class<? extends Annotation> annotation;
  11.  
  12.     public DynamicDataSourceAnnotationAdvisor(MethodInterceptor advice,
  13.                                                Class<? extends Annotation> annotation) {
  14.         this.advice = advice;
  15.         this.annotation = annotation;
  16.         this.pointcut = buildPointcut();
  17.     }
  18.  
  19.     @Override
  20.     public Pointcut getPointcut() {
  21.         return this.pointcut;
  22.     }
  23.  
  24.     @Override
  25.     public Advice getAdvice() {
  26.         return this.advice;
  27.     }
  28.  
  29.     @Override
  30.     public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
  31.         if (this.advice instanceof BeanFactoryAware) {
  32.             ((BeanFactoryAware) this.advice).setBeanFactory(beanFactory);
  33.         }
  34.     }
  35.  
  36.     private Pointcut buildPointcut() {
  37.         Pointcut cpc = new AnnotationMatchingPointcut(annotation, true);
  38.         Pointcut mpc = new AnnotationMethodPoint(annotation);
  39.         return new ComposablePointcut(cpc).union(mpc);
  40.     }
  41.  
  42.     /**
  43.      * In order to be compatible with the spring lower than 5.0
  44.      */
  45.     private static class AnnotationMethodPoint implements Pointcut {
  46.  
  47.         private final Class<? extends Annotation> annotationType;
  48.  
  49.         public AnnotationMethodPoint(Class<? extends Annotation> annotationType) {
  50.             Assert.notNull(annotationType, "Annotation type must not be null");
  51.             this.annotationType = annotationType;
  52.         }
  53.  
  54.         @Override
  55.         public ClassFilter getClassFilter() {
  56.             return ClassFilter.TRUE;
  57.         }
  58.  
  59.         @Override
  60.         public MethodMatcher getMethodMatcher() {
  61.             return new AnnotationMethodMatcher(annotationType);
  62.         }
  63.  
  64.         private static class AnnotationMethodMatcher extends StaticMethodMatcher {
  65.             private final Class<? extends Annotation> annotationType;
  66.  
  67.             public AnnotationMethodMatcher(Class<? extends Annotation> annotationType) {
  68.                 this.annotationType = annotationType;
  69.             }
  70.  
  71.             @Override
  72.             public boolean matches(Method method, Class<?> targetClass) {
  73.                 if (matchesMethod(method)) {
  74.                     return true;
  75.                 }
  76.                 // Proxy classes never have annotations on their redeclared methods.
  77.                 if (Proxy.isProxyClass(targetClass)) {
  78.                     return false;
  79.                 }
  80.                 // The method may be on an interface, so let's check on the target class as well.
  81.                 Method specificMethod = AopUtils.getMostSpecificMethod(method, targetClass);
  82.                 return (specificMethod != method && matchesMethod(specificMethod));
  83.             }
  84.  
  85.             private boolean matchesMethod(Method method) {
  86.                 return AnnotatedElementUtils.hasAnnotation(method, this.annotationType);
  87.             }
  88.         }
  89.     }
  90. }
  91.  
  1.  
  2. /**
  3.  * 数据源解析器
  4.  *
  5.  */
  6. public class DataSourceClassResolver {
  7.  
  8.     private static boolean mpEnabled = false;
  9.  
  10.     private static Field mapperInterfaceField;
  11.  
  12.     static {
  13.         Class<?> proxyClass = null;
  14.         try {
  15.             proxyClass = Class.forName("com.baomidou.mybatisplus.core.override.MybatisMapperProxy");
  16.         } catch (ClassNotFoundException e1) {
  17.             try {
  18.                 proxyClass = Class.forName("com.baomidou.mybatisplus.core.override.PageMapperProxy");
  19.             } catch (ClassNotFoundException e2) {
  20.                 try {
  21.                     proxyClass = Class.forName("org.apache.ibatis.binding.MapperProxy");
  22.                 } catch (ClassNotFoundException ignored) {
  23.                 }
  24.             }
  25.         }
  26.         if (proxyClass != null) {
  27.             try {
  28.                 mapperInterfaceField = proxyClass.getDeclaredField("mapperInterface");
  29.                 mapperInterfaceField.setAccessible(true);
  30.                 mpEnabled = true;
  31.             } catch (NoSuchFieldException e) {
  32.                 e.printStackTrace();
  33.             }
  34.         }
  35.     }
  36.  
  37.     /**
  38.      * 缓存方法对应的数据源
  39.      */
  40.     private final Map<Object, String> dsCache = new ConcurrentHashMap<>();
  41.     private final boolean allowedPublicOnly;
  42.  
  43.     /**
  44.      * 加入扩展, 给外部一个修改aop条件的机会
  45.      *
  46.      * @param allowedPublicOnly 只允许公共的方法, 默认为true
  47.      */
  48.     public DataSourceClassResolver(boolean allowedPublicOnly) {
  49.         this.allowedPublicOnly = allowedPublicOnly;
  50.     }
  51.  
  52.     /**
  53.      * 从缓存获取数据
  54.      *
  55.      * @param method       方法
  56.      * @param targetObject 目标对象
  57.      * @return ds
  58.      */
  59.     public String findKey(Method method, Object targetObject) {
  60.         if (method.getDeclaringClass() == Object.class) {
  61.             return "";
  62.         }
  63.         Object cacheKey = new MethodClassKey(method, targetObject.getClass());
  64.         String ds = this.dsCache.get(cacheKey);
  65.         if (ds == null) {
  66.             ds = computeDatasource(method, targetObject);
  67.             if (ds == null) {
  68.                 ds = "";
  69.             }
  70.             this.dsCache.put(cacheKey, ds);
  71.         }
  72.         return ds;
  73.     }
  74.  
  75.     /**
  76.      * 查找注解的顺序
  77.      * 1\. 当前方法
  78.      * 2\. 桥接方法
  79.      * 3\. 当前类开始一直找到Object
  80.      * 4\. 支持mybatis-plus, mybatis-spring
  81.      *
  82.      * @param method       方法
  83.      * @param targetObject 目标对象
  84.      * @return ds
  85.      */
  86.     private String computeDatasource(Method method, Object targetObject) {
  87.         if (allowedPublicOnly && !Modifier.isPublic(method.getModifiers())) {
  88.             return null;
  89.         }
  90.         //1\. 从当前方法接口中获取
  91.         String dsAttr = findDataSourceAttribute(method);
  92.         if (dsAttr != null) {
  93.             return dsAttr;
  94.         }
  95.         Class<?> targetClass = targetObject.getClass();
  96.         Class<?> userClass = ClassUtils.getUserClass(targetClass);
  97.         // JDK代理时,  获取实现类的方法声明.  method: 接口的方法, specificMethod: 实现类方法
  98.         Method specificMethod = ClassUtils.getMostSpecificMethod(method, userClass);
  99.  
  100.         specificMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);
  101.         //2\. 从桥接方法查找
  102.         dsAttr = findDataSourceAttribute(specificMethod);
  103.         if (dsAttr != null) {
  104.             return dsAttr;
  105.         }
  106.         // 从当前方法声明的类查找
  107.         dsAttr = findDataSourceAttribute(userClass);
  108.         if (dsAttr != null && ClassUtils.isUserLevelMethod(method)) {
  109.             return dsAttr;
  110.         }
  111.         //since 3.4.1 从接口查找，只取第一个找到的
  112.         for (Class<?> interfaceClazz : ClassUtils.getAllInterfacesForClassAsSet(userClass)) {
  113.             dsAttr = findDataSourceAttribute(interfaceClazz);
  114.             if (dsAttr != null) {
  115.                 return dsAttr;
  116.             }
  117.         }
  118.         // 如果存在桥接方法
  119.         if (specificMethod != method) {
  120.             // 从桥接方法查找
  121.             dsAttr = findDataSourceAttribute(method);
  122.             if (dsAttr != null) {
  123.                 return dsAttr;
  124.             }
  125.             // 从桥接方法声明的类查找
  126.             dsAttr = findDataSourceAttribute(method.getDeclaringClass());
  127.             if (dsAttr != null && ClassUtils.isUserLevelMethod(method)) {
  128.                 return dsAttr;
  129.             }
  130.         }
  131.         return getDefaultDataSourceAttr(targetObject);
  132.     }
  133.  
  134.     /**
  135.      * 默认的获取数据源名称方式
  136.      *
  137.      * @param targetObject 目标对象
  138.      * @return ds
  139.      */
  140.     private String getDefaultDataSourceAttr(Object targetObject) {
  141.         Class<?> targetClass = targetObject.getClass();
  142.         // 如果不是代理类, 从当前类开始, 不断的找父类的声明
  143.         if (!Proxy.isProxyClass(targetClass)) {
  144.             Class<?> currentClass = targetClass;
  145.             while (currentClass != Object.class) {
  146.                 String datasourceAttr = findDataSourceAttribute(currentClass);
  147.                 if (datasourceAttr != null) {
  148.                     return datasourceAttr;
  149.                 }
  150.                 currentClass = currentClass.getSuperclass();
  151.             }
  152.         }
  153.         // mybatis-plus, mybatis-spring 的获取方式
  154.         if (mpEnabled) {
  155.             final Class<?> clazz = getMapperInterfaceClass(targetObject);
  156.             if (clazz != null) {
  157.                 String datasourceAttr = findDataSourceAttribute(clazz);
  158.                 if (datasourceAttr != null) {
  159.                     return datasourceAttr;
  160.                 }
  161.                 // 尝试从其父接口获取
  162.                 return findDataSourceAttribute(clazz.getSuperclass());
  163.             }
  164.         }
  165.         return null;
  166.     }
  167.  
  168.     /**
  169.      * 用于处理嵌套代理
  170.      *
  171.      * @param target JDK 代理类对象
  172.      * @return InvocationHandler 的 Class
  173.      */
  174.     private Class<?> getMapperInterfaceClass(Object target) {
  175.         Object current = target;
  176.         while (Proxy.isProxyClass(current.getClass())) {
  177.             Object currentRefObject = AopProxyUtils.getSingletonTarget(current);
  178.             if (currentRefObject == null) {
  179.                 break;
  180.             }
  181.             current = currentRefObject;
  182.         }
  183.         try {
  184.             if (Proxy.isProxyClass(current.getClass())) {
  185.                 return (Class<?>) mapperInterfaceField.get(Proxy.getInvocationHandler(current));
  186.             }
  187.         } catch (IllegalAccessException ignore) {
  188.         }
  189.         return null;
  190.     }
  191.  
  192.     /**
  193.      * 通过 AnnotatedElement 查找标记的注解, 映射为  DatasourceHolder
  194.      *
  195.      * @param ae AnnotatedElement
  196.      * @return 数据源映射持有者
  197.      */
  198.     private String findDataSourceAttribute(AnnotatedElement ae) {
  199.         AnnotationAttributes attributes = AnnotatedElementUtils.getMergedAnnotationAttributes(ae, DS.class);
  200.         if (attributes != null) {
  201.             return attributes.getString("value");
  202.         }
  203.         return null;
  204.     }
  205. }
  206.

ThreadLocal:

  1. public final class DynamicDataSourceContextHolder {
  2.  
  3.     /**
  4.      * 为什么要用链表存储(准确的是栈)
  5.      * <pre>
  6.      * 为了支持嵌套切换，如ABC三个service都是不同的数据源
  7.      * 其中A的某个业务要调B的方法，B的方法需要调用C的方法。一级一级调用切换，形成了链。
  8.      * 传统的只设置当前线程的方式不能满足此业务需求，必须使用栈，后进先出。
  9.      * </pre>
  10.      */
  11.     private static final ThreadLocal<Deque<String>> LOOKUP_KEY_HOLDER = new NamedThreadLocal<Deque<String>>("dynamic-datasource") {
  12.         @Override
  13.         protected Deque<String> initialValue() {
  14.             return new ArrayDeque<>();
  15.         }
  16.     };
  17.  
  18.     private DynamicDataSourceContextHolder() {
  19.     }
  20.  
  21.     /**
  22.      * 获得当前线程数据源
  23.      *
  24.      * @return 数据源名称
  25.      */
  26.     public static String peek() {
  27.         return LOOKUP_KEY_HOLDER.get().peek();
  28.     }
  29.  
  30.     /**
  31.      * 设置当前线程数据源
  32.      * <p>
  33.      * 如非必要不要手动调用，调用后确保最终清除
  34.      * </p>
  35.      *
  36.      * @param ds 数据源名称
  37.      */
  38.     public static String push(String ds) {
  39.         String dataSourceStr = StringUtils.isEmpty(ds) ? "" : ds;
  40.         LOOKUP_KEY_HOLDER.get().push(dataSourceStr);
  41.         return dataSourceStr;
  42.     }
  43.  
  44.     /**
  45.      * 清空当前线程数据源
  46.      * <p>
  47.      * 如果当前线程是连续切换数据源 只会移除掉当前线程的数据源名称
  48.      * </p>
  49.      */
  50.     public static void poll() {
  51.         Deque<String> deque = LOOKUP_KEY_HOLDER.get();
  52.         deque.poll();
  53.         if (deque.isEmpty()) {
  54.             LOOKUP_KEY_HOLDER.remove();
  55.         }
  56.     }
  57.  
  58.     /**
  59.      * 强制清空本地线程
  60.      * <p>
  61.      * 防止内存泄漏，如手动调用了push可调用此方法确保清除
  62.      * </p>
  63.      */
  64.     public static void clear() {
  65.         LOOKUP_KEY_HOLDER.remove();
  66.     }
  67. }
  68.
  1. 启动类上做如下配置：

引入我们写的自动配置类，排除 ShardingJdbc 的自动配置类。

  1. @SpringBootApplication(exclude = ShardingSphereAutoConfiguration.class)
  2. @Import({DynamicDataSourceAutoConfiguration.class})
  3. public class ShardingRunApplication {
  4.  
  5.     public static void main(String[] args) {
  6.         SpringApplication.run(ShardingRunApplication.class);
  7.     }
  8. }
  9.

最后，我们给之前写的 Repository 加上注解：

  1. public interface BOrderRepository extends JpaRepository<BOrder,Long> {
  2.  
  3.     @DS("slave0")
  4.     @Query(value = "SELECT * FROM (SELECT id,CASE WHEN company_id =1 THEN '小' WHEN company_id=4 THEN '中' ELSE '大' END AS com,user_id as userId FROM b_order0) t WHERE t.com ='中'",nativeQuery =true)
  5.     List<Map<String, Object>> findOrders();
  6. }
  7.

再次调用，查询成功！！！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/酷酷是懒虫/article/detail/757130
推荐阅读
相关标签

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

  

闽ICP备14008679号