• 一个注解解决ShardingJdbc不支持复杂SQL

    背景介绍

    公司最近做分库分表业务，接入了 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.     }
    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. }

    写了个测试 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 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 dataSourceMap;
    6.  
    7.     public WrapShardingDataSource(ShardingSphereDataSource dataSource, Map 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.  
    21.     @Override
    22.     public Connection getConnection() throws SQLException {
    23.         return getTargetDataSource().getConnection();
    24.     }
    25.  
    26.     @Override
    27.     public Connection getConnection(final String username, final String password) throws SQLException {
    28.         return getConnection();
    29.     }
    30.  
    31.  
    32.  
    33.     @Override
    34.     public void close() throws Exception {
    35.         DataSource targetDataSource = getTargetDataSource();
    36.         if (targetDataSource instanceof AutoCloseable) {
    37.             ((AutoCloseable) targetDataSource).close();
    38.         }
    39.     }
    40.  
    41.     @Override
    42.     public int getLoginTimeout() throws SQLException {
    43.         DataSource targetDataSource = getTargetDataSource();
    44.         return targetDataSource ==null ? 0 : targetDataSource.getLoginTimeout();
    45.     }
    46.  
    47.     @Override
    48.     public void setLoginTimeout(final int seconds) throws SQLException {
    49.         DataSource targetDataSource = getTargetDataSource();
    50.         targetDataSource.setLoginTimeout(seconds);
    51.     }
    52. }
    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. }
    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. }

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

    ThreadLocal:

    1. public final class DynamicDataSourceContextHolder {
    2.  
    3.     /**
    4.      * 为什么要用链表存储(准确的是栈)
    5.      * 
    6.      * 为了支持嵌套切换，如ABC三个service都是不同的数据源
    7.      * 其中A的某个业务要调B的方法，B的方法需要调用C的方法。一级一级调用切换，形成了链。
    8.      * 传统的只设置当前线程的方式不能满足此业务需求，必须使用栈，后进先出。
    9.      * 
  •      */
  •     private static final ThreadLocal<Deque<String>> LOOKUP_KEY_HOLDER = new NamedThreadLocal>("dynamic-datasource") {
  •         @Override
  •         protected Deque<String> initialValue() {
  •             return new ArrayDeque<>();
  •         }
  •     };
  •  
  •     private DynamicDataSourceContextHolder() {
  •     }
  •  
  •     /**
  •      * 获得当前线程数据源
  •      *
  •      * @return 数据源名称
  •      */
  •     public static String peek() {
  •         return LOOKUP_KEY_HOLDER.get().peek();
  •     }
  •  
  •     /**
  •      * 设置当前线程数据源
  •      * 
  •      * 如非必要不要手动调用，调用后确保最终清除
  •      * 
  •      *
  •      * @param ds 数据源名称
  •      */
  •     public static String push(String ds) {
  •         String dataSourceStr = StringUtils.isEmpty(ds) ? "" : ds;
  •         LOOKUP_KEY_HOLDER.get().push(dataSourceStr);
  •         return dataSourceStr;
  •     }
  •  
  •     /**
  •      * 清空当前线程数据源
  •      * 
  •      * 如果当前线程是连续切换数据源 只会移除掉当前线程的数据源名称
  •      * 
  •      */
  •     public static void poll() {
  •         Deque<String> deque = LOOKUP_KEY_HOLDER.get();
  •         deque.poll();
  •         if (deque.isEmpty()) {
  •             LOOKUP_KEY_HOLDER.remove();
  •         }
  •     }
  •  
  •     /**
  •      * 强制清空本地线程
  •      * 
  •      * 防止内存泄漏，如手动调用了push可调用此方法确保清除
  •      * 
  •      */
  •     public static void clear() {
  •         LOOKUP_KEY_HOLDER.remove();
  •     }
  • }
    •  

    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. }
     

    最后，我们给之前写的 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. }
     

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

    
                

                    

                

                
  • 

                    相关阅读:
    
                    
MySQL5.7读写分离                            
    
每天五分钟机器学习：神经网络和支持向量机的基础——感知机模型                            
    
刷题笔记20——各种顺序的二叉树构造                            
    
RabbitMQ:hello结构                            
    
图解MySQL中的JOIN类型                            
    
cadence SPB17.4 - 中文UI设置                            
    
计数排序算法                            
    
SpringCloud 常见问题                            
    
Spring Security 6.1.x 系列 （1）—— 初识Spring Security                            
    
一文看懂推荐系统：特征交叉01：Factorized Machine (FM) 因式分解机                            
    
                        
                
    • 
                
  • 
                    原文地址：https://blog.csdn.net/ch98000/article/details/126781038
                
    •