每天学到的技术点3

1.TEXT与BLOB的区别，二者之间的主要差别是BLOB能用来保存二进制数据，比如照片；而TEXT只能保存字符数据，比如一遍文章或日记。（OK）
2.表索引的前缀长度，前缀索引兼顾索引大小和查询速度

3.varchar(255)的原因，对于变长字段varchar会用额外一两个字节保存长度，当长度小于255个字节时，
使用一个字节记录字符串的长度。如果大于255就使用两个字节保存字符串长度
3.1.通常情况下使用varchar(20)和varchar(255)保持'hello'占用的空间都是一样的，但使用长度较短的列却有巨大的优势。较大的列使用更多的内存，
因为MySQL通常会分配固定大小的内存块来保存值，这对排序或使用基于内存的临时表尤其不好。同样的事情也会发生在使用文件排序或者基于磁盘的临时表的时候。
3.2.767字节，767字节是MySQLVersion 5.6和InnoDB表(和以前的版本)的限制长度。MyISAM表的长度为1000字节。在MySQLVersion 5.7及以上版本中，这个限制已经增加到3072字节。
3.3.767/3 = 255，这个也是为什么varchar(255)取255的原因，
3.4.SET @@global.innodb_large_prefix = 1;这将使限制增加到3072 bytes
3.5.innodb引擎的每个索引列长度限制为767字节(bytes),所有组成索引列的长度和不能大于3072字节（1024*3）

4.SpringBoot配置加载，各配置文件优先级对比（OK）
private static final String DEFAULT_SEARCH_LOCATIONS = "classpath:/,classpath:/config/,file:./,file:./config/";

5.泛型，即“参数化类型”，泛型只在编译阶段有效，编译之后程序会采取去泛型化的措施，分别为：泛型类、泛型接口、泛型方法
5.1.在实例化泛型类时，必须指定T的具体类型
5.2.使用泛型的时候如果传入泛型实参，则会根据传入的泛型实参做相应的限制，此时泛型才会起到本应起到的限制作用。
5.3.泛型通配符（？），
5.4.同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。
5.5.泛型方法，是在调用方法的时候指明泛型的具体类型
5.6.泛型上下边界， Generic<T extends Number>
5.7.类型通配符下限为Box<? super Number>形式
5.8.E - Element (在集合中使用，因为集合中存放的是元素)T - Type（Java 类）K - Key（键）V - Value（值）N - Number（数值类型）？ - 表示不确定的java类型
链接：https://www.jianshu.com/p/615aefb187e5

6.spring的scope为prototype,spring的bean的作用域有singleton，prototype，session，request等,proxyMode = ScopedProxyMode.INTERFACES
7.@Qualifier,@resource,@Autowired(按类型装配,默认情况下它要求依赖对象必须存在，如果允许null值，可以设置它required属性为false),@Primary
8.@Bean,@Component,@Service,@Repository,@Controller,@Configuration
8.1.Spring管理Bean方式有两种，一种是注册Bean，一种装配Bean。
可以通过三种方式实现bean管理，一使用自动配置的方式、二使用JavaConfig的方式、三使用XML配置的方式。
8.2.@Bean 需要在配置类中使用，即类上需要加上@Component或者@Configuration注解， 通常加上@Configuration。@Bean是一个方法级别上的注解，主要用在@Configuration注解的类里，也可以用在@Component注解的类里。添加的bean的id为方法名
8.3.@Bean：表示一个方法实例化、配置或者初始化一个Spring IoC容器管理的新对象。
@Component: 自动被comonent扫描。 表示被注解的类会自动被component扫描
@Repository: 用于持久层，主要是数据库存储库。
@Service: 表示被注解的类是位于业务层的业务component。
@Controller:表明被注解的类是控制component，主要用于展现层 。
8.4.@Bean注解告诉Spring这个方法将会返回一个对象，这个对象要注册为Spring应用上下文中的bean。通常方法体中包含了最终产生bean实例的逻辑。@DependsOn（@Bean顺序依赖）
8.5.@Component注解表明一个类会作为组件类，并告知Spring要为这个类创建bean。
8.6.@Component（@Controller、@Service、@Repository）通常是通过类路径扫描来自动侦测以及自动装配到Spring容器中。而@Bean注解通常是我们在标有该注解的方法中定义产生这个bean的逻辑。@Component 作用于类，@Bean作用于方法。

9. Spring中的byName与byType(OK)

10.@Resource的作用相当于@Autowired，均可标注在字段或属性的setter方法上。(OK)

11.@Resource如果没有指定name属性，并且按照默认的名称仍然找不到依赖对象时， @Resource注解会回退到按类型装配。但一旦指定了name属性，就只能按名称装配了。(OK)

12.@Autowired只有一个属性required，默认值为true，为true时，找不到就抛异常，为false时，找不到就赋值为null(OK)

13.Resource不允许找不到bean的情况，而Autowired允许（@Autowired(required = false)）(OK)

14.指定name的方式不一样，@Resource(name = "baseDao"),@Autowired()@Qualifier("baseDao")(OK)

15.@Lazy ,如果没有@Lazy注释，或者@Lazy 被设置为false，那么该bean 就会急切渴望被加载；除了上面两种作用域，@Lazy 还可以作用在@Autowired和@Inject注释的属性上，在这种情况下，它将为该字段创建一个惰性代理，作为使用ObjectFactory或Provider的默认方法。

16.@Value(#{})和@Value(${}) ,常量注入@Value("normal"),bean属性、系统属性、表达式注入@Value("#{}")，,配置文件属性注入@Value("${}")，读取配置文件中的值注入

17.#{变量名}可以进行预编译、类型匹配等操作，#{变量名}会转化为jdbc的类型。,${变量名}不进行数据类型匹配，直接替换。

18.JDK的动态代理，CGLIB

19.@Entity注释指名这是一个实体Bean，@Table注释指定了Entity所要映射带数据库表，其中@Table.name()用来指定映射表的表名。
如果缺省@Table注释，系统默认采用类名作为映射表的表名。

20.Hibernate持久化对象生命周期原理解析（https://www.jb51.net/article/196417.htm）
1， 临时状态（Transient）：也叫自由态，只存在于内存中，而在数据库中没有相应数据。用new创建的对象，它没有持久化，没有处于Session中，处于此状态的对象叫临时对象；
2， 持久化状态（Persistent）：与session关联并且在数据库中有相应数据。已经持久化，加入到了Session缓存中。如通过hibernate语句保存的对象。处于此状态的对象叫持久对象；
3， 游离状态（Detached）：持久化对象脱离了Session的对象。如Session缓存被清空的对象。特点：已经持久化，但不在Session缓存中。处于此状态的对象叫游离对象；游离态只能由持久态转换而来，通过close或clear方法实现。
20.1.Hibernate和SQL的关系，在操作了hibernate的方法如save()等后，并没有直接生成sql语句，去操作数据库，而是把这些更新存入Session中，只有Session缓存要被更新时，底层的sql语句才能执行，数据存入数据库；

21.Hibernate中Session对象详解，Session接口负责执行被持久化对象的CRUD操作

21.1.get方法，采用的立即加载，代码执行的时候，就马上发送 sql语句去查询，查询后返回真正的实体，当查询一个找不到的对象会返回为null（OK）

21.2.load方法，采用的是延时加载（lazy懒加载），代码执行到的时候，不发送sql语句，当真正用到对象时候才会发送sql.查询后是代理对象。（OK）

21.3.Session 具有一个缓存, 位于缓存中的对象称为持久化对象, 它和数据库中的相关记录对应。
Session 能够在某些时间点, 按照缓存中对象的变化来执行相关的 SQL 语句, 来同步更新数据库, 这一过程被称为刷新缓存(flush)。也叫一级缓存。
在 Session 接口的实现中包含一系列的 Java 集合, 这些 Java 集合构成了 Session 缓存。 只要 Session 实例没有结束生命周期, 且没有清理缓存，则存放在它缓存中的对象也不会结束生命周期。
Session 缓存可减少 Hibernate 应用程序访问数据库的频率。

21.4.flush方法：session会按照缓存中对象属性的变化来更新数据库中的记录，使数据库中记录和缓存中的对象保持一致，默认情况下，在以下时间点会刷新缓存：
①：当应用程序调用Transaction.commit()方法时，该方法会先调用flush()方法，然后提交事物
②：显示的调用flush()方法时
③：当应用程序执行一些查询(HQL, Criteria)操作时，如果缓存中持久化对象的属性已经发生了变化，会先 flush 缓存，以保证查询结果能够反映持久化对象的最新状态
如果对象使用 native 生成器生成 OID, 那么当调用 Session 的 save() 方法保存对象时, 会立即执行向数据库插入该实体的 insert 语句.
flush()方法会执行一系列的sql语句，但是不会提交事物；commit()在提交事物前，会先调用flush()方法，然后再提交事物

refresh会强制发送select语句， 以使数据库中的记录和缓存中的对象保持一致；如果在调用refresh方法前，手动的修改数据库中的记录，查询出来的结果还不是最新的，
这跟数据库的数据的隔离级别是相关的，可以在配置文件中显示的修改事物的隔离级别，

clear 清理缓存

21.5.持久化对象状态分为四种状态：持久化状态, 临时状态, 游离状态(脱管状态), 删除状态。

21.6.FlushMode
FlushMode.ALWAYS：任务一条SQL语句，都会flush一次
FlushMode.AUTO ：自动flush(默认)
FlushMode.COMMIT: 只有在commit时才flush
FlushMode.MANUAL：手动flush。
FlushMode.NEVER ：永远不flush 此选项在性能优化时可能用，比如session取数据为只读时用，这样就不需要与数据库同步了。

21.7.当hibernate缓存中的对象被改动之后，会被标记为脏数据（即与数据库不同步了）

https://www.baidu.com/s?ie=utf-8&f=8&rsv_bp=1&tn=baidu&wd=hiberate%20Session&oq=internationalization&rsv_pq=8fb1d55b00021d70&rsv_t=cbd3RjujRCFvbHsszOzmGMlF%2B19cp5q55ISzr2WjhPS6rygc30v%2FfNm71QU&rqlang=cn&rsv_enter=0&rsv_dl=tb&rsv_sug3=12&rsv_sug1=11&rsv_sug7=101&rsv_n=2&rsv_btype=t&prefixsug=hiberate%2520Session&rsp=3&inputT=8090&rsv_sug4=15627
https://www.cnblogs.com/Yly-G/p/9690408.html
https://www.cnblogs.com/weibanggang/p/9888235.html
https://blog.csdn.net/iteye_3357/article/details/81862620


22.utf8mb4，most bytes 4
22.1.Unicode(编码)，GBK包括了GB2312 的所有内容，GBK扩成了 GB18030。ISO->unicode,标准的2字节形式通常称作UCS-2,Unicode的4字节形式被称为UCS-4或UTF-32,UTF-32 或称 UCS-4 ，每字都是 4 bytes
22.2.utf8（数据存储结构），UTF-8最大的一个特点，就是它是一种变长的编码方式。它可以使用1~4个字节表示一个符号，

23.对象监听（SessionListener的原理）
23.1.HttpSession（Session监听），DispatcherServlet里的相关监听，都是有相关的类使用了观察者模式实现的
23.2.Filter，FilterConfig和FilterChain的实现类分别是ApplocationFilterConfig和ApplicationFilterChain，ContextConfig，StandardContext，都是有相关的类使用了观察者模式实现的,StandWrapperValve
23.4.拦截器,自定义一个实现了Interceptor接口的类，或者继承抽象类AbstractInterceptor。框架提供了一个已经实现了拦截器接口的适配器类HandlerInterceptorAdapter
拦截器是依赖Java反射机制来实现的。拦截器的实现，用到的是JDK实现的动态代理
许多 AOP框架, 包括 Spring AOP, 会将 advice 模拟为一个拦截器(interceptor), 并且在 join point 上维护多个 advice, 进行层层拦截.
在 Spring AOP 中, join point 总是方法的执行点, 即只有方法连接点.
在 Spring 中, 所有的方法都可以认为是 joinpoint, 但是我们并不希望在所有的方法上都添加 Advice, 而 pointcut 的作用就是提供一组规则(使用 AspectJ pointcut expression language 来描述)
来匹配joinpoint, 给满足规则的 joinpoint 添加 Advice.
因为 Spring AOP 使用运行时代理的方式来实现 aspect, 因此 adviced object 总是一个代理对象(proxied object)
注意, adviced object 指的不是原来的类, 而是织入 advice 后所产生的代理类.
在 Spring AOP 中, 一个 AOP 代理是一个 JDK 动态代理对象或 CGLIB 代理对象.
织入(Weaving),将 aspect 和其他对象连接起来, 并创建 adviced object 的过程.
AOP织入有三种方式:
编译器织入, 这要求有特殊的Java编译器.
类装载期织入, 这需要有特殊的类装载器.
动态代理织入, 在运行期为目标类添加增强(Advice)生成子类的方式.
Spring 采用动态代理织入, 而AspectJ采用编译器织入和类装载期织入.@Aspect,https://blog.csdn.net/z69183787/article/details/83311522(何时进行代理生成的，好)
https://segmentfault.com/a/1190000007469968
如果需要定义顺序，可以使用@Order注解修饰Aspect类。值越小，优先级越高。




24.ThreadLocal

25.transient

26.HttpServletRequest,
在controller中注入的request是jdk动态代理对象,ObjectFactoryDelegatingInvocationHandler的实例.当我们调用成员域request的方法的时候其实是调用了objectFactory的getObject()对象的相关方法.这里的objectFactory是RequestObjectFactory.
RequestObjectFactory的getObject其实是从RequestContextHolder的threadlocal中去取值的.
请求刚进入springmvc的dispatcherServlet的时候会把request相关对象设置到RequestContextHolder的threadlocal中去.
26.1.Web客户向Servlet容器发出Http请求
2.Servlet容器解析Web客户的Http请求
3.Servlet容器创建一个HttpRequest对象，在这个对象中封装Http请求信息
4.Servlet容器创建一个HttpResponse对象
5.Servlet容器调用HttpServlet的service方法，把HttpRequest和HttpResponse对象作为service方法的参数传给HttpServlet对象
6.HttpServlet调用HttpRequest的有关方法，获取HTTP请求信息
7.HttpServlet调用HttpResponse的有关方法，生成响应数据
8.Servlet容器把HttpServlet的响应结果传给Web客户
其中HttpServlet首先必须读取Http请求的内容，Servlet容器负责创建HttpServlet对象，并把Http请求直接封装到HttpServlet对象中。
三、创建HttpServlet步骤
1.继承HttpServlet抽象类
2.重写HttpServlet的部分方法，如doGet()或doPost()方法
3.获取HTTP请求信息。通过HttpServletRequest对象来检索HTML表单所提交的数据或URL上的查询字符串
4.生成HTTP响应结果。通过HttpServletResponse对象生成响应结果
https://blog.csdn.net/qq_41007534/article/details/99696559

27.Spring AOP，是AOP的一种实现，使用的是代理模式。实现AOP的几种方式（代码方式实现（多就会复杂，不好维护），静态代理模式（编译阶段进行，性能好，比较少使用），动态代理模式（运行阶段进行））

28.动态代理
Proxy.newProxyInstance,

29.Spring的IOC,IOC是Inversion of Control的缩写，多数书籍翻译成“控制反转”，IOC理论提出的观点大体是这样的：借助于“第三方”实现具有依赖关系的对象之间的解耦，
IOC的别名：依赖注入(DI),获得依赖对象的过程被反转了

30.spring工作原理，通过 Spring 提供的 IoC 容器，可以将对象间的依赖关系交由 Spring 进行控制，避免硬编码所造成的过度程序耦合
30.1.工厂模式解耦，在实际开发中我们可以把三层的对象都使用配置文件配置起来，当启动服务器应用加载的时候，让一个类中的方法通过读取配置文件，把这些对象创建出来并存起来。
在接下来的使用的时候，直接拿过来用就好了。那么，这个读取配置文件，创建和获取三层对象的类就是工厂。
30.2.BeanFactory 和ApplicationContext 的区别，
BeanFactory 才是 Spring 容器中的顶层接口。
ApplicationContext 是它的子接口。
BeanFactory 和 ApplicationContext 的区别：
创建对象的时间点不一样：
ApplicationContext：只要一读取配置文件，默认情况下就会创建对象。
BeanFactory：什么使用什么时候创建对象。

30.3.Spring 的依赖注入，依赖注入（Dependency Injection，缩写 DI）是 Spring 框架核心 IoC 的具体实现。当我们把对象的创建交给了 Spring 后，虽然降低了对象间的依赖关系，但是并不会消除。
当 Spring 在创建业务层对象的时候，会帮我们把持久层对象传入到业务层中，而不用我们自己去获取。
在当前类需要用到其他类的对象，由spring为我们提供，我们只需要在配置文件中说明依赖关系的维护： 就称之为依赖注入。
构造注入指的是，通过类中的构造方法给成员变量赋值。这个赋值的操作并不是我们做的，而是通过配置的方式，让 Spring 框架来为我们注入。
set 方法注入，通过类中的 setXxx() 方法给成员变量赋值
<property name="spellChecker" ref="spellChecker"/>
依赖注入的本质就是装配，装配是依赖注入的具体行为。
装配分为四种：byName, byType, constructor, autodetect。
全限定类名：就是类名全称，带包路径的用点隔开，例如: java.lang.String。
类的非限定名，也就是把类的名字的首字母换成小写
非限定类名也叫短名，就是我们平时说的类名，不带包的，例如：String。

https://blog.csdn.net/Elsa15/article/details/108647939(spring中的前置处理器和后置处理器区别)
在容器的启动阶段主要做的是一些信息收集的过程(主要依赖于工具类BeanDefinitionReader)，将收集的信息组成BeanDefinition.将BeanDefinition注册到相应的BeaneanRegistry。
Bean实例化的过程在请求方通过容器的getBean方法明确请求某个对象时候触发/隐式依赖关系调用时候也会触发该动作。此阶段做的操作主要是判断当前的请求对象是否已经被实例化过了。
根据情况进行注入，当该对象实现某些回调接口，也会根据回调函数接口装配它。
BeanFactoryPostProcess(前置处理器)实例化对象之前
BeanPostProcessor(后置处理器)实例化对象之后
实例后的对象，初始化之前BeanBeforePostProcessor
实例后的对象，初始化之后BeanAfterPostProcessor

实例化和初始化的区别:
1、实例化----实例化的过程是一个创建Bean的过程，即调用Bean的构造函数，单例的Bean放入单例池中。
2、初始化----初始化的过程是一个赋值的过程，即调用Bean的setter，设置Bean的属性。

https://blog.csdn.net/jinxin70/article/details/83796137?spm=1001.2101.3001.6650.1&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7Edefault-1.pc_relevant_default&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7Edefault-1.pc_relevant_default&utm_relevant_index=2
(Spring Bean的初始化和实例化的区别)

https://blog.csdn.net/linzherong/article/details/116094843(Spring 是如何解决循环依赖问题的)


30.4.BeanPostProcessor（Bean 后置处理器），Bean 后置处理器允许在调用初始化方法前后对 Bean 进行额外的处理。
ApplicationContext​ 会自动检测由 ​BeanPostProcessor​ 接口的实现定义的 ​bean​，注册这些​ bean​ 为后置处理器，然后通过在容器中创建​ bean​，在适当的时候调用它。


31.属性文件解析，ResourceBundle,Properties,main函数的参数就是运行时传入的参数，Yaml（yml）

32.注解
这个枚举决定了Retention注解应该如何去保持，也可理解为Rentention 搭配 RententionPolicy使用。RetentionPolicy有3个值：CLASS  RUNTIME   SOURCE
用@Retention(RetentionPolicy.CLASS)修饰的注解，表示注解的信息被保留在class文件(字节码文件)中当程序编译时，但不会被虚拟机读取在运行的时候；
用@Retention(RetentionPolicy.SOURCE )修饰的注解,表示注解的信息会被编译器抛弃，不会留在class文件中，注解的信息只会留在源文件中；
用@Retention(RetentionPolicy.RUNTIME )修饰的注解，表示注解的信息被保留在class文件(字节码文件)中当程序编译时，会被虚拟机保留在运行时，

@Target(ElementType.METHOD) 修饰的注解表示该注解只能用来修饰在方法上
@Target(ElementType.PARAMETER)，用来修饰在参数上

33. Hibernate为我们提供了实现拦截器的接口org.hibernate.Interceptor，它里面提供了许多拦截事件。通常不需要实现这个接口，因为我们实现自己的拦截器不可能每一个事件都是必须的。
所以Hibernate为我们提供了org.hibernate.Interceptor接口的一个空实现类org.hibernate.EmptyInterceptor，通常情况下我们只需继承这个空实现类，Override需要的事件方法即可。
onLoad:在实体对象初始化之前调用
onSave:在实体对象保存到数据库之前调用
onDelete:在删除实体对象之前调用
preFlsh:flush操作前执行
afterTransactionBegin:Transaction API启动Hibernate事务后调用
beforeTransactionCompletion:事务被提交前调用
onFlushDirty,修改数据
https://blog.csdn.net/tanksyg/article/details/83865323?utm_medium=distribute.pc_relevant.none-task-blog-2~default~baidujs_baidulandingword~default-0.pc_relevant_paycolumn_v3&spm=1001.2101.3001.4242.1&utm_relevant_index=3

34.Hibernate事件监听器，与Hibernate拦截器有点类似

35.数据模型可以通过继承的方式将共用的写到一个类中，如创建人和创建时间等

36.cglib的实现机制与Java 动态代理不同，它是通过继承实现的 ，它也是动态创建了一个类，但这个类的父类是被代理的类，代理类重写了父类的所有public非final方法，改为调用Callback中的相关方法，在本例中，调用CglibProxy的intercept方法。
因为jdk是基于反射,CGLIB是基于字节码.所以性能上会有差异.
在老版本CGLIB的速度是JDK速度的10倍左右,但是CGLIB启动类比JDK慢8倍左右,但是实际上JDK的速度在版本升级的时候每次都提高很多性能,而CGLIB仍止步不前.



37.ConcurrentHashMap,HashTable,HashMap,LinkedHashMap,TreeMap

38.InnoDB存储方式
InnoDB存储引擎作用：
（1）MySQL服务器上负责对表中数据的读取和写入工作的部分;
（2）MySQL目前默认存储引擎为InnoDB,读取数据为从磁盘读取到内存，写入和修改则是从内存刷新到磁盘;
（3）InnoDB是将数据分为若干页,以页作为磁盘和内存的基本交互单位，InnoDB每页大小为16KB,
    即一次最少从磁盘中读取16KB的内容到内存中，一次最少把内存中的16KB内容刷新到磁盘中。
InnoDB存储引擎结构：
（1）磁盘和内存的交互为页，是MySQL管理存储空间的基本单位;
（2）执行行格式和修改行格式的语法为：
    创建：CREATE TABLE 表名 {列的信息} ROW_FORMAT=行格式名称
    修改：ALTER TABLE 表名 ROW_FORMAT=行格式名称;
（3）InnoDB 目前定义了4种行格式：Compact行格式、Redundant行格式、Dynamic行格式和Compressed行格式;
（4）一个页一般是16KB,当记录中的数据太多,当前页放不下的时候,会把多余的数据存储到其他页中即行溢出。
PS：Compact行格式结构：记录的额外信息和记录的真实信息。
      额外信息包括：变长字段长度列表、Null值列表和记录头信息;
      记录的真实信息为：各列的真实列值，其中null值的列会被放进额外信息中的Null值列表，避免冗余。
    Redundant行格式结构：MySQL5.0以前的版本，记录的额外信息和记录的真实信息。
      额外信息为：字段长度偏移列表和记录头信息，没有Null值列表;
      记录的真实信息为：各列的真实列值，其中null值的列也会存在真实数据中，比较粗暴。
    Dynamic和Compressed行格式结构：
    MySQL版本是5.7,它的默认行格式就是Dynamic,行溢出 数据时有点儿分歧，它们不会在记录的真实数据处存储字段真实数据的前
    768个字节,而是把所有的字节都存储到其他页面中,只在记录的真实数据处存储其他页
      面的地址。
    Compact与Redundant行格式区别：
    Compact行格式的开头是变长字段长度列表,而Redundant行格式的开头是字段长度偏移列表,与变长字段长度列表有两处不同：
    （1）没有了变长两个字，意味着 Redundant行格式会把该条记录中所有列（包括隐藏列）的长度信息都按照逆序存储到字段长度
    偏移列表;
    （2）多了个偏移两个字，这意味着计算列值长度的方式不像Compact行格式那么直观,它是采用两个相邻数值的差值来计算各个列值
    的长度。
https://blog.csdn.net/txk396879586/article/details/121671372
在我使用的版本Mysql5.7.26版本中，行格式默认为Dynamic。如何进行查看某个表的行格式命令是：
show table STATUS like '表名'
https://www.liangzl.com/get-article-detail-148101.html
https://baijiahao.baidu.com/s?id=1674241270709202927&wfr=spider&for=pc


39.
1、innodb支持事务，而myisam不支持事务。
2、innodb支持外键，而myisam不支持外键。
3、innodb是行锁，而myisam是表锁（每次更新增加删除都会锁住表）。
4、innodb和myisam的索引都是基于b+树，但他们具体实现不一样，innodb的b+树的叶子节点是存放数据的，myisam的b+树的叶子节点是存放指针的。
5、innodb是聚簇索引，必须要有主键，一定会基于主键查询，但是辅助索引就会查询两次，myisam是非聚簇索引，索引和数据是分离的，索引里保存的是数据地址的指针，主键索引和辅助索引是分开的。
6、innodb不存储表的行数，所以select count( * )的时候会全表查询，而myisam会存放表的行数，select count(*）的时候会查的很快。


40.innodb数据量与层次数的关系
https://blog.csdn.net/majianfei1023/article/details/122380387

41.保存时可以进行数据ID的生成，惟一性的校验，获取数据时的按角色冲洗数据