前言

本文主要探讨基于 DSL（domain specific language） 之上的插件设计，他们是领域的附属，为领域提供额外的服务，但领域不依赖于他们。

1. 论述

领域应当尽可能地去专注他的核心业务规则，应当尽可能地与其他辅助性的代码解耦，一些通用的功能可以耦合进框架或者设计为中间件；但还存在有一些是与核心功能无关的，且又与业务逻辑密不可分，譬如特定的监控、特定的埋点、为领域定制的稳定性保障等，把他们定义为插件再合适不过，其依赖关系如前言所述。

2. 设计方案

暂不讨论特定的插件要实现哪些特定的能力，后续系列中将逐步展开构建一个完整的 DSL 具体需要哪些插件及其实现方案，这里我想展开思考的是怎样设计一个比较通用的 DSL 插件方案。

论述中对插件的定义与 AOP 的思想相当吻合，也当首选使用 AOP 来实现，但这其中还存在一个问题，我希望插件只专注其自身职责的表达，至于哪些节点需要接入哪些插件应当在 DSL 中配置（即我期望插件与 DSL 之间只存在配置关系），而配置应当支持动态更新，因此这就导致了 AOP 的代理对象事先是不确定的，需要去动态生成。

最后落到实现上，插件这块我需要去攻克两个核心技术点：

1、怎样去更新 AOP 的代理及切点表达式？

2、怎样去更新 IOC 容器？

3. 实现方案

3.1 配置入口

若不考虑动态更新，那么入口要实现的基本功能有两个：1、按需引入，这很简单，用一个 Conditional 即可；2、加载一个表达式类型的通知器，示例如下：

  1. @Configuration
  2. @ConditionalOnBean(DSL.class)
  3. public class PluginConfig {
  4.     @Bean
  5.     public AspectJExpressionPointcutAdvisor pluginAdvisor() {
  6.         AspectJExpressionPointcutAdvisor advisor = new AspectJExpressionPointcutAdvisor();
  7.         advisor.setExpression(DSL.getExpression());
  8.         advisor.setAdvice(new PluginAdvice());
  9.         return advisor;
  10.     }
  11. }
  13. public class PluginAdvice implements MethodInterceptor {
  14.     @Override
  15.     public Object invoke(MethodInvocation invocation) throws Throwable {
  16.         System.out.println("do plugin_work start...");
  17.         Object resObj = invocation.proceed();
  18.         System.out.println("do plugin_work end...");
  19.         return resObj;
  20.     }
  21. }

测试：

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class DefaultTest {
  5.     @ExtensionNode
  6.     private Engine engine;
  8.     @Test
  9.     public void test() {
  10.         DslUtils.setDslA();
  11.         engine.launch();
  12.     }
  13. }

3.2 监听 DLS 变更

怎么监听配置的更新是所有的配置中心都需要去深入设计的（后续系列中探讨），此处暂用伪代码代替：

  1. @Configuration
  2. public class PluginListenerImpl implements DslListener {
  4.     @Override
  5.     public void refresh(DslContext dslContext) {
  6.         // do something...
  7.     }
  8. }

3.3 更新切点表达式

3.1 中我们已经注入了一个表达式通知器的 Bean：AspectJExpressionPointcutAdvisor，因此仅仅更新表达式的字符串非常简单，但查看查看源码会发现起匹配作用的是他的内部对象 AspectJExpressionPointcut，而他在首次执行匹配时会构建一个 PointcutExpression 并保存起来：

  1. private PointcutExpression obtainPointcutExpression() {
  2. 	if (getExpression() == null) {
  3. 		throw new IllegalStateException("Must set property 'expression' before attempting to match");
  4. 	}
  5. 	if (this.pointcutExpression == null) {
  6. 		this.pointcutClassLoader = determinePointcutClassLoader();
  7. 		this.pointcutExpression = buildPointcutExpression(this.pointcutClassLoader);
  8. 	}
  9. 	return this.pointcutExpression;
  10. }

因此我们还需要通过反射将这个私有字段置空，让 ClassFilter 重新执行构建，示例如下：

  1. @Configuration
  2. public class PluginListenerImpl implements DslListener {
  4.     @Autowired
  5.     private AspectJExpressionPointcutAdvisor aspectJExpressionPointcutAdvisor;
  7.     @Override
  8.     public void refresh(DslContext dslContext) throws NoSuchFieldException, IllegalAccessException {
  9.         refreshExpression(dslContext);
  10.         // next...
  11.     }
  13.     private void refreshExpression(DslContext dslContext) throws NoSuchFieldException, IllegalAccessException {
  14.         aspectJExpressionPointcutAdvisor.setExpression(dslContext.getExpression());
  15.         AspectJExpressionPointcut pointcut = (AspectJExpressionPointcut) aspectJExpressionPointcutAdvisor.getPointcut().getClassFilter();
  17.         Field f = AspectJExpressionPointcut.class
  18.                 .getDeclaredField("pointcutExpression");
  20.         f.setAccessible(true);
  21.         f.set(pointcut, null);
  22.     }
  23. }

3.3 更新动态代理

通过翻阅源码可得出 Spring AOP 主要通过：AbstractAdvisingBeanPostProcessor 、AbstractAutoProxyCreator 这两个 processor 来实现动态代理，其对应的实例为：MethodValidationPostProcessor、AnnotationAwareAspectJAutoProxyCreator，前者用于创建代理对象，后者用于标记切面（即织入代理）。由此，若我们需要去更新动态代理，我想到的最简单的方法就是对指定的节点重新执行以下这两个 processor（原理简单，就是一点点扣源码，麻烦...），其中还有一个小问题，和 3.2 中的一致，代理结果被缓存了，清空再执行即可，示例如下：


  2. @Autowired
  3. private DefaultListableBeanFactory defaultListableBeanFactory;
  5. private void refreshTypes(DslContext dslContext) throws NoSuchFieldException, IllegalAccessException {
  6.     List<Class<?>> refreshTypes = dslContext.getRefreshTypes();
  7.     for (Class<?> refreshType : refreshTypes) {
  8.         String[] beanNames = defaultListableBeanFactory.getBeanNamesForType(refreshType);
  9.         for (String beanName : beanNames) {
  10.             Object bean = defaultListableBeanFactory.getBean(beanName);
  11.             for (BeanPostProcessor processor : defaultListableBeanFactory.getBeanPostProcessors()) {
  12.                 bean = getProxyBean(bean, beanName, processor);
  13.             }
  15.         }
  16.     }
  17. }
  19. private Object getProxyBean(Object bean, String beanName, BeanPostProcessor processor) throws NoSuchFieldException, IllegalAccessException {
  20.     if (processor instanceof MethodValidationPostProcessor
  21.             || processor instanceof AnnotationAwareAspectJAutoProxyCreator) {
  22.         removeAdvisedBeanCache(processor, bean, beanName);
  23.         Object current = processor.postProcessAfterInitialization(bean, beanName);
  24.         return current == null ? bean : current;
  25.     }
  26.     return bean;
  27. }
  29. private void removeAdvisedBeanCache(BeanPostProcessor processor, Object bean, String beanName) throws NoSuchFieldException, IllegalAccessException {
  30.     if (processor instanceof AnnotationAwareAspectJAutoProxyCreator) {
  31.         AnnotationAwareAspectJAutoProxyCreator annotationAwareAspectJAutoProxyCreator = (AnnotationAwareAspectJAutoProxyCreator) processor;
  32.         Field f = AnnotationAwareAspectJAutoProxyCreator.class
  33.                 .getSuperclass()
  34.                 .getSuperclass()
  35.                 .getSuperclass()
  36.                 .getDeclaredField("advisedBeans");
  38.         f.setAccessible(true);
  39.         Map<Object, Boolean> advisedBeans = (Map<Object, Boolean>) f.get(annotationAwareAspectJAutoProxyCreator);
  40.         Object cacheKey = getCacheKey(bean.getClass(), beanName);
  41.         advisedBeans.remove(cacheKey);
  42.     }
  43. }
  45. private Object getCacheKey(Class<?> beanClass, @Nullable String beanName) {
  46.     if (StringUtils.hasLength(beanName)) {
  47.         return (FactoryBean.class.isAssignableFrom(beanClass) ?
  48.                 BeanFactory.FACTORY_BEAN_PREFIX + beanName : beanName);
  49.     } else {
  50.         return beanClass;
  51.     }
  52. }

到此可以测试以下新生成的代理类：

  1. public class PluginTest {
  3.     @Autowired
  4.     private BEngine bEngine;
  6.     @Autowired
  7.     private DslListener dslListener;
  9.     @Test
  10.     public void test() throws NoSuchFieldException, IllegalAccessException {
  11.         System.out.println("--------proxy before-----------");
  12.         System.out.println("BEngine.class:" + bEngine.getClass());
  13.         bEngine.launch();
  15.         DslContext dslContext = new DslContext();
  16.         // 初始值为 execution( void com.youclk.et.car.a.AEngine.launch() )，BEngine 并未被代理
  17.         dslContext.setExpression("execution( void com.youclk.et.car.b.BEngine.launch() )");
  18.         dslContext.setRefreshTypes(Collections.singletonList(BEngine.class));
  19.         dslListener.refresh(dslContext);
  20.     }
  22. }

结果如下：

通过这种方式更新可以不用担心多次刷新代理对象产生的副作用，因为最终变化的只是代理类所匹配切面通知而已。

3.4 更新 Spring Context

开码之前我一直认为这一步是难点，刷了一遍源码后发觉这一步异常简单（看源码还是很重要...）。DefaultListableBeanFactory 其实有提供 remove 和 register 方法用于更新 Bean，但是这两步的操作我认为太重了，而且在 remove 和 register 之间用到了这个 Bean 怎么办，因此存在极大风险。且看我们上一步做了什么，从 BeanDefinition 这个维度看我们只更新了 classType，其他的都没变，因此我考虑只要更新下 BeanDefinition，并清除对应的缓存即可，示例如下：

  1. private void refreshTypes(DslContext dslContext) throws NoSuchFieldException, IllegalAccessException {
  2.     List<Class<?>> refreshTypes = dslContext.getRefreshTypes();
  3.     for (Class<?> refreshType : refreshTypes) {
  4.         String[] beanNames = defaultListableBeanFactory.getBeanNamesForType(refreshType);
  5.         for (String beanName : beanNames) {
  6.             Object bean = defaultListableBeanFactory.getBean(beanName);
  7.             for (BeanPostProcessor processor : defaultListableBeanFactory.getBeanPostProcessors()) {
  8.                 bean = getProxyBean(bean, beanName, processor);
  9.             }
  10.             refreshBeanDefinition(beanName, bean.getClass());
  11.         }
  12.     }
  13. }
  15. private void refreshBeanDefinition(String beanName, Class<?> classType) throws NoSuchFieldException, IllegalAccessException {
  16.     RootBeanDefinition rootBeanDefinition = (RootBeanDefinition) defaultListableBeanFactory.getMergedBeanDefinition(beanName);
  17.     rootBeanDefinition.setBeanClass(classType);
  19.     ScannedGenericBeanDefinition scannedGenericBeanDefinition = (ScannedGenericBeanDefinition) defaultListableBeanFactory.getBeanDefinition(beanName);
  20.     scannedGenericBeanDefinition.setBeanClass(classType);
  22.     removeBeanDefinitionCache(beanName);
  23. }
  25. private void removeBeanDefinitionCache(String beanName) throws NoSuchFieldException, IllegalAccessException {
  26.     Field factoryBeanObjectCache_f = DefaultListableBeanFactory.class
  27.             .getSuperclass()
  28.             .getSuperclass()
  29.             .getSuperclass()
  30.             .getDeclaredField("factoryBeanObjectCache");
  31.     factoryBeanObjectCache_f.setAccessible(true);
  32.     Map<String, Object> factoryBeanObjectCache = (Map<String, Object>) factoryBeanObjectCache_f.get(defaultListableBeanFactory);
  33.     factoryBeanObjectCache.remove(beanName);
  35.     Field singletonObjects_f = DefaultListableBeanFactory.class
  36.             .getSuperclass()
  37.             .getSuperclass()
  38.             .getSuperclass()
  39.             .getSuperclass()
  40.             .getDeclaredField("singletonObjects");
  41.     singletonObjects_f.setAccessible(true);
  42.     Map<String, Object> singletonObjects = (Map<String, Object>) singletonObjects_f.get(defaultListableBeanFactory);
  43.     singletonObjects.remove(beanName);
  45.     Field singletonFactories_f = DefaultListableBeanFactory.class
  46.             .getSuperclass()
  47.             .getSuperclass()
  48.             .getSuperclass()
  49.             .getSuperclass()
  50.             .getDeclaredField("singletonFactories");
  51.     singletonFactories_f.setAccessible(true);
  52.     Map<String, Object> singletonFactories = (Map<String, Object>) singletonFactories_f.get(defaultListableBeanFactory);
  53.     singletonFactories.remove(beanName);
  55.     Field earlySingletonObjects_f = DefaultListableBeanFactory.class
  56.             .getSuperclass()
  57.             .getSuperclass()
  58.             .getSuperclass()
  59.             .getSuperclass()
  60.             .getDeclaredField("earlySingletonObjects");
  61.     earlySingletonObjects_f.setAccessible(true);
  62.     Map<String, Object> earlySingletonObjects = (Map<String, Object>) earlySingletonObjects_f.get(defaultListableBeanFactory);
  63.     earlySingletonObjects.remove(beanName);
  64. }

测试下是否完成了我的预期：

  1. @Autowired
  2. private ApplicationContext applicationContext;
  4. @Test
  5. public void testRefreshBeanDefinition() throws NoSuchFieldException, IllegalAccessException {
  6.     System.out.println("--------refresh before-----------");
  7.     System.out.println("BEngine.class:" + applicationContext.getBean(bEngine.getClass()).getClass());
  8.     refresh();
  9.     System.out.println("--------refresh after-----------");
  10.     System.out.println("BEngine.class:" + applicationContext.getBean(bEngine.getClass()).getClass());
  11. }
  13. private void refresh() throws NoSuchFieldException, IllegalAccessException {
  14.     DslContext dslContext = new DslContext();
  15.     //初始值为 execution( void com.youclk.et.car.a.AEngine.launch() )，BEngine 并未被代理
  16.     dslContext.setExpression("execution( void com.youclk.et.car.b.BEngine.launch() )");
  17.     dslContext.setRefreshTypes(Collections.singletonList(BEngine.class));
  18.     dslListener.refresh(dslContext);
  19. }

结果如下：

两次获取到的 classType 不同，说明更新成功。

3.5 更新 IOC 容器

这是最关键的一步，从操作数量上来看也是最重的一步，我们来回顾下，到此我们已经刷新了代理、刷新了切面通知、并将变更提交到了 Spring Context 中，我们还缺最后一步：更新目标对象所有的依赖注入。

因为我们需要将修改后的 Bean 重新注入所有依赖他的 Bean 中，这其中可能涉及到众多的修改操作，因此第一步我们要获取所有的依赖注入关系，他们维护在：AutowiredAnnotationBeanPostProcessor.injectionMetadataCache 中；由于一次提交可能涉及到多个目标对象的更新，他们之间又有存在依赖的可能性，因此第二步先把那一堆新的 bean 刷到 metadataCache，最后筛选出所有与更新相关的依赖，重新注入一遍，示例如下：

  1. private AutowiredAnnotationBeanPostProcessor autowiredAnnotationBeanPostProcessor;
  3. private void refreshTypes(DslContext dslContext) throws Exception {
  4.     List<Class<?>> refreshTypes = dslContext.getRefreshTypes();
  5.     HashMap<String, String> refreshBeans = new HashMap<>();
  6.     for (Class<?> refreshType : refreshTypes) {
  7.         String[] beanNames = defaultListableBeanFactory.getBeanNamesForType(refreshType);
  8.         for (String beanName : beanNames) {
  9.             Object bean = defaultListableBeanFactory.getBean(beanName);
  10.             for (BeanPostProcessor processor : defaultListableBeanFactory.getBeanPostProcessors()) {
  11.                 if (processor instanceof AutowiredAnnotationBeanPostProcessor) {
  12.                     autowiredAnnotationBeanPostProcessor = (AutowiredAnnotationBeanPostProcessor) processor;
  13.                     continue;
  14.                 }
  15.                 bean = getProxyBean(bean, beanName, processor);
  16.             }
  17.             refreshBeanDefinition(beanName, bean.getClass());
  18.             refreshBeans.put(beanName, getRealName(bean.getClass().getName()));
  19.         }
  20.     }
  21.     refreshIoc(refreshBeans);
  22. }
  24. private void refreshIoc(HashMap<String, String> refreshBeans) throws Exception {
  25.     for (String refreshBeanName : refreshBeans.keySet()) {
  26.         resetInjectionMetadataCache(refreshBeanName);
  27.     }
  28.     Set<Object> beans = getReInjectionBeans(refreshBeans);
  29.     for (Object bean : beans) {
  30.         defaultListableBeanFactory.autowireBeanProperties(bean, 0, false);
  31.     }
  32. }
  34. private void resetInjectionMetadataCache(String refreshBeanName) {
  35.     autowiredAnnotationBeanPostProcessor.resetBeanDefinition(refreshBeanName);
  36.     autowiredAnnotationBeanPostProcessor.determineCandidateConstructors(refreshBeanName.getClass(), refreshBeanName);
  38.     RootBeanDefinition rootBeanDefinition = (RootBeanDefinition) defaultListableBeanFactory.getMergedBeanDefinition(refreshBeanName);
  39.     Object bean = defaultListableBeanFactory.getBean(refreshBeanName);
  40.     autowiredAnnotationBeanPostProcessor.postProcessMergedBeanDefinition(rootBeanDefinition, bean.getClass(), refreshBeanName);
  41. }
  43. private Set<Object> getReInjectionBeans(HashMap<String, String> refreshBeans) throws Exception {
  44.     Field injectionMetadataCache_f = AutowiredAnnotationBeanPostProcessor.class.getDeclaredField("injectionMetadataCache");
  45.     injectionMetadataCache_f.setAccessible(true);
  46.     Map<String, InjectionMetadata> factoryBeanObjectCache = (Map<String, InjectionMetadata>) injectionMetadataCache_f.get(autowiredAnnotationBeanPostProcessor);
  48.     Set<Object> injectedBeanNames = new HashSet<>();
  50.     for (String beanName : factoryBeanObjectCache.keySet()) {
  51.         Collection<InjectionMetadata.InjectedElement> injectedElements = getInjectedElements(factoryBeanObjectCache.get(beanName));
  52.         if (injectedElements == null) {
  53.             continue;
  54.         }
  55.         for (InjectionMetadata.InjectedElement injectedElement : injectedElements) {
  56.             if (refreshBeans.values().contains(getRealName(getResourceType(injectedElement).getName()))) {
  57.                 injectedBeanNames.add(defaultListableBeanFactory.getBean(beanName));
  58.             }
  59.         }
  61.     }
  63.     return injectedBeanNames;
  64. }
  66. private Collection<InjectionMetadata.InjectedElement> getInjectedElements(InjectionMetadata injectionMetadata) throws Exception {
  67.     Field injectedElements_f = InjectionMetadata.class.getDeclaredField("injectedElements");
  68.     injectedElements_f.setAccessible(true);
  69.     Collection<InjectionMetadata.InjectedElement> injectedElements = (Collection<InjectionMetadata.InjectedElement>) injectedElements_f.get(injectionMetadata);
  70.     return injectedElements;
  72. }
  74. private Class<?> getResourceType(InjectionMetadata.InjectedElement injectedElement) throws Exception {
  75.     Method getResourceType_m = InjectionMetadata.InjectedElement.class.getDeclaredMethod("getResourceType");
  76.     getResourceType_m.setAccessible(true);
  77.     return (Class<?>) getResourceType_m.invoke(injectedElement);
  78. }
  80. private String getRealName(String instanceName) {
  81.     int index = instanceName.indexOf("$");
  82.     if (index > 0) {
  83.         instanceName = instanceName.substring(0, index);
  84.     }
  85.     return instanceName;
  86. }

最后再来测试一波：

  1. @Test
  2. public void test() throws Exception {
  3.     bEngine.launch();
  4.     refresh();
  5.     bEngine.launch();
  6. }

正如预期效果：

结语

灵明无著，物来顺应，未来不迎，当下不杂，既过不恋~ 请关注公众号：

DSL 系列（2） - 插件的论述与实现的更多相关文章

  1. ThreeJS系列1_CinematicCameraJS插件详解

    ThreeJS系列1_CinematicCameraJS插件详解 接着上篇 ThreeJS系列1_CinematicCameraJS插件介绍 看属性的来龙去脉 看方法作用 通过调整属性查看效果 总结 ...

  2. ThreeJS系列2_effect插件集简介( 3d, vr等 )

    ThreeJS系列2_effect插件集简介( 3d, vr等 ) ThreeJS 官方案例中有一些 js库 可以替代 render 将场景中的物质变换为其他效果的物质 目录 ThreeJS系列2_e ...

  3. DSL 系列（1） - 扩展点的论述与实现

    前言 DSL 全称为 domain-specific language(领域特定语言),本系列应当会很长,其中包含些许不成熟的想法,欢迎私信指正. 1. DSL 简述 我理解的 DSL 的主要职能是 ...

  4. jenkins系列之插件配置(二)

    第一步:下面来安装nodejs插件 第二步:可以看到,Jenkins提供了丰富的插件供开发者使用,找到需要的[NodeJS Plugin],勾选后点击安装即可 我的是已经安装了 第三步: 安装完毕后, ...

  5. mybatis学习系列五--插件及类型处理器

    2 插件编写(80-81) 单个插件编写 2.1实现interceptor接口(ibatis) invocation.proceed()方法执行必须要有,否则不会无法实现拦截作用 2.2 使用@int ...

  6. 码云平台IDEA系列的插件使用

    一.IDEA插件安装 file -- setting --  Plugins -- 搜索gitee --  Search in repositories 安装后重启编译器 二.登录并拉取项目 file ...

  7. WorldWind源码剖析系列：插件列表视图类PluginListView和插件列表视图项类PluginListItem

    WorldWind中的插件类是个庞大的类,可以说从软件设计层面上统筹可扩展的插件体系的设计思想是WorldWind中的精华,值得学习和借鉴.插件体系中的所用到的类可以分为两大类,一类是插件类Plugi ...

  8. WorldWind源码剖析系列：插件类Plugin、插件信息类PluginInfo和插件编译器类PluginCompiler

    插件类Plugin是所有由插件编译器加载的插件子类的抽象父类,提供对插件的轻量级的访问控制功能. 插件信息类PluginInfo用来存储关于某个插件的信息的类,可以理解为对插件类Plugin类的进一步 ...

  9. mybatis generator插件系列--分页插件

    1.首先定义分页插件 MysqlPagePlugin.java package com.demo.mybatis.plugin; import org.mybatis.generator.api.Co ...

随机推荐

  1. codeforces 735C Tennis Championship(贪心+递推)

    Tennis Championship 题目链接:http://codeforces.com/problemset/problem/735/C ——每天在线,欢迎留言谈论. 题目大意: 给你一个 n ...

  2. PHP断言（ASSERT)的用法

    简述 编写代码时,我们总是会做出一些假设,断言就是用于在代码中捕捉这些假设,可以将断言看作是异常处理的一种高级形式.程序员断言在程序中的某个特定点该的表达式值为真.如果该表达式为假,就中断操作. 可以 ...

  3. mssql sqlserver 下文分享一种新颖的字符串截取方法

    原文地址:http://www.maomao365.com/?p=7307 摘要:    以前分割字符串时,都使用类似split函数的方式处理,下文分享一种对有规律的字符串的分隔方式,    即:1. ...

  4. linux 命令之netstat

    转自:http://www.maomao365.com/?p=699 linux 命令之netstat 在linux中netstat命令的作用是查看TCP/IP网络当前所开放端口,所对应的本地和外地端 ...

  5. 洗礼灵魂，修炼python（81）--全栈项目实战篇（9）—— 购物商城登录验证系统

    都在线购物过吧?那么你应该体验过,当没有登录账户时,点开购物车,个人中心,收藏物品等的操作时,都会直接跳转到登录账户的界面,然后如果登录一次后就不用再登录,直到用户登出. 是的,本次项目就是做一个登录 ...

  6. 信号量的基本概念与使用semget，semop

    1.信号量的基本概念 信号量是一个计数器,常用于处理进程或线程的同步问题,特别是对临界资源的同步访问. 临界资源可以简单的理解为在某一时刻只能由一个进程或线程进行操作的资源,这里的资源 可以是一段代码 ...

  7. 对于coursera上三门北大网课的评测

    今年暑假开始就选了coursera上三门北大的网课——C++程序设计.算法基础.数据结构基础,它们属于一个项目的,上的话每个月249块钱,项目里包括这三门一共有七门课.因为一开始是三门课同时上的,数据 ...

  8. ORM版学员管理系统3

    老师信息管理 思考 三种方式创建多对多外键方式及其优缺点. 通过外键创建 class Class(models.Model): id = models.AutoField(primary_key=Tr ...

  9. Teradata超长数据会截断

    1.数据库版本 Teradata 15.10 2.测试案例: create multiset table test_stg ( col1 ) CHARACTER SET LATIN not null ...

  10. dp Surf

    题目:https://vj.69fa.cn/1fc993e7e0e1e6fa7ce4640b8d46ef8d?v=1552762626 这个题目和尼克的任务这个题目很像,这个题目因为同一时刻具有选择性 ...