- 1 java基础
- 1.1 public,private,protected,以及默认时候的区别？
- 1.2 hashcode 和 equals 方法的联系？
- 1.3 如果类中有大量的成员信息，equals比较率低怎么解决？
- 1.4 什么是重写和重载？
- 1.5 简述 java 的反射机制
- 1.6 java 中接口和抽象类的区别
- 1.7 ==和 equals()的区别?
- 1.8 String,StringBuffer,StringBuilder
- 2 java 集合
- 3 Sping
- 3.1 简述 Spring 的初始化流程
- 3.2 简述 SpringAOP 原理
- 3.3 IOC作用以及优点
- 3.4 IOC实现机制是什么？
- 3.5 IOC与DI的区别？
- 3.6 BeanFactory作用？
- 3.7 BeanFactory与ApplicationContext有什么区别？
- 3.8 BeanDefinition？
- 3.8 BeanDefinition？
- 3.9 BeanFactory与FactoryBean有什么区别?
- 3.10Spring IOC容器的加载的过程？
- 3.11Spring IOC中有哪些扩展点 ？
- 3.12 什么是SpringBean 与javaBean有什么区别
- 3.13配置Bean有哪些方法？
- 3.14 Bean的作用域
- 3.15 单例bean的优势，或则单例设计模式的优点？
- 3.16Spring的Bean是线程安全的吗?*
- 3.17Spring如何处理线程安全问题?
- 3.18spring实例化Bean方式有几种？
- 3.19什么是bean的装配？什么是bean的自动装配？
- 3.20Bean生命周期有哪些回调方法？
- 3.21Bean生命周期的几种形态？
- 3.22Spring中Bean生命周期？
- 3.23Spring如何解决Bean的循环依赖？*****
- 3.24spring是如何在并发的情况下避免获取不完整的Bean?
- 3.25BeanDefinition的加载过程？
- 3.26如何在所有的BeanDefinition注册完之后做扩展？
- 3.27Spring容器启动时候，为什么先加载BeanFactoryPostProcess?
- 3.28Bean的生产顺序是由什么决定的？
- 3.29 BeanDefianition的注册顺序是由什么决定的？
- 3.30 Spring有哪几种配置方式？
- 3.31javaConfig是如何替代Spring.xml的?
- 3.1 mybatis执行流程
- 4 java web
- 4.1 session与cookie的区别以及联系
- 4.2 GET与POST的区别？
- 4.3 怎么解post重复提交的问题？
- 5 JVM
- 6 MySql数据库
- 6.1 简述乐观锁以及悲观锁的区别以及使用场景
- 6.2 简述 mysql 常见索引数据，介绍一下覆盖索引
- 7 并发&多线程
public：对所有类都可见，可以使用在类，接口，方法，变量；
protected：对同包的类和子类可见，使用用在变量方法；
default：同包可见，使用对象：类，接口，方法，变量；
private:在同一类中可见，使用在变量，方法中；
1、 都是object中的方法，在使用的时候一般都会被重写
a) 不重写：hashcode()：返回的是对象的地址值。
equals()：是用来比较两个对象的地址值是否相等
b) 重写；hashcode()：返回的是根据对象的成员变量计算出的一个整数
equals()：比较对象的成员信息是否相等
2、类中重写了hashcode()与equals()方法比较对象是否相等？
结论；如果hashcode相等两个对象不一定相等，如果equals比较相等，则hashcode一定相等。
通hash与equals搭配使用可以提高比较的效率(hashmap与hashset就是用的和这种比较)
可以通过hashcode比较如果不相等，则两个类一定不相等，如果hashcode相同然后调用equals比较，
这样既可以判断对象是否相同，也可以提高效率。
hashset保证元素的唯一性：首先比较hashcode值是否相同，如果不同则直接添加，如果相同则比较equals，
如果不同则添加
结论：如果hashset中储存对象，为了保证元素的唯一性，则必须重写hashcode与equals方法，new出来的对象，
地址值肯定不相同，所以可以添加进hashset中但是重写了equals方法后，会比较成员属性是否相同，
如果相同就判断为相同的属性。
重写：子类继承父类以后，如果子类对父类的功能不满意，可以重写父类的方法
两同：方法名相同，参数列表相同
两小: 子类方法的返回值类型 <= 父类方法的返回值类型【这个大小是继承关系，不是值的大小】
子类方法抛出的异常类型 <= 父类方法抛出的异常类型
一大：子类方法的修饰符范围 >= 父类方法的修饰符范围–指的是访问控制符
重载：在同一个类中出现方法名相同但参数列表不同方法的现象
方便外界调用体现程序的灵活性
1、java反射允许机制，允许程序在运行期间借助反射的api获取任何类的信息，并能直接操作任意对象的属性和方法。
2、在类加载完成之后，在堆内存的方法区中就会产生一个Class对象(一个类只有一个Class对象)，这个对象包含了完整的类的结构信息，我们可以通过这个对象看到类的结构，这个对象就像一面镜子，透过这个镜子看到这个类的结构，这个现象就被称为反射。
1、 抽象类可以有普通属性与方法，接口只有抽象方法和默认方法。
2、 抽象类只能单继承，接口可以多实现。
3、 抽象类可以有构造函数，接口不能有构造函数
4、 抽象类子类是由extends关键字来继承的，而接口是使用implement关键字来实现这个接口的。
比较基本类型，比较的是值是否相等，比较引用类型的时候比较的是地址值是否相等
equals：object类中的方法，如果没有重写默认的是比较==
如果重写了equals方法比较的是类中的成员信息是否相等。
String是不可变的，字符串拼接时会创造很多对象，这些对象还需要JVM回收。适用于不经常变化的值。
StringBuilder和StringBuffer都是可变的，适用于经常要变化的值，如字符串拼接等。
StringBuilder是线程不安全的，适用于单线程。
StringBuffer是线程安全的，因为有synchronize修饰，适用于多线程。
- 通过@Aspact注解定义一个切面类型的类；
- 通过@Pointcut注解定义切扩展逻辑的位置，称为切入点
切入扩展逻辑的位置~例如权限控制,日志记录,事务处理的位置； - 通知方法定义在目标方法执行前后需要扩展的逻辑
ICO控制反转：就是将创建对象的权力交给Spring来管理，如果我们需要对象就需要通过getBean方法从Ioc容器中获取，当然@Autoware还创建Bean的时候可以自动注入一些属性。
优点：集中管理对象，方便维护。
Ioc实现机制通过beanfactory.getBean()简单工厂和反射机制实现的。
方便理解：如果直接new一个对象耦合性太高，针对这个问题，可以采用简单工厂去实现。
简单工厂：beanfactory.getBean(“完整类路径”)，工厂内部拿到类路径通过反射创建对象。
IOC控制反转用来解决耦合性的设计思想，把对象创建的权力交给Spring，由Spring去统一维护对象与对象之间的依赖关系。
当需要对象的时候通过DI的方式获取，那么DI就是IOC的一种实现。
1、BeanFactory是spring中非常核心的顶层接口。
2、它是一个工厂主要的作用就是用来生产Bean
3、它实现了简单工厂的设计模式，通过调用getBean()方法传入标识去生产Bean
4、它有非常多的实现类，功能最强大的就是DefaultListableBeanFactory，spring底层就是使用了这个工厂生产Bean的。
5、BeanFactory它也是一个容器，spring容器(管理某个对象的生命周期）
区别
1、ApplicationContext提供了getBean的方法，实现了BeanFactory，他的getBean方法内部是return BranFactory.getBean()所以实际上它不是生产的Bean，而是通知BeanFactory去生产Bean。ApplicationContext的getBean是门面方法。
2、在应用中通常使用ApplicationContext，因为它的功能比较丰富比如它可以自动把Bean注册成BeanDefinition而BeanFactory需要手动的注册Bean,才能getBean。
3、会加载环境变量，支持多语言，实现事件监听，注册很多对外的扩展点。
共同点
ApplicationContext与BeanFactory都可以作为Spring容器，因为他们都可以管理Bean的生命周期。
解释：Context.close()可以销毁Bean,BeanFactory.destory()可以销毁Bean
它主要负责存储Bean的定义信息决定了Bean的生产方式。
ApplicationContext在创建spring容器的时候，需要先去配置Bean
配置Bean的方式：xml,@Component,@Scope,@Bean
AbstractBeanDefinition()实现类负责将Bean的定义信息存储起来。
BeanFactory与FactoryBean有什么区别?
3.9 BeanFactory与FactoryBean有什么区别?BeanFactory是一个工厂，用来生产和管理Bean的;
FactoryBean是一个特殊的Bean,所以它是由BeanFactory来管理的
FactoryBean是一个接口，它必须被bean去实现。如果一个Bean去实现了FactoryBean
那么返回的再是原来的那个bean,而是通过FactoryBean这个接口的getObject（）这个工厂方法
产生的Bean，这里可以返回任意一个对象。实现了FactoryBean接口相当于可以偷梁换柱。
注意：1、如果想要获取原来的bean可以通过getBean(“&xxx”)拿到
2、被FactoryBean修饰之后会变成懒加载。
容器创建：在new ApplicationContext()的时候就会开启IOC加载
IOC的加载过程就是Bean的创建过程。Bean创建过程有4种形态
- 概念态
Bean进行了配置(xml配置，注解配置)但是IOC容器还没有开始加载。
1、先调用Bea工厂的后置处理器(invokeBeanFactoryPostProcessors()–>对外提供的扩展接口)通过这个方法可以将Bean注册为概念态。
过程：
1）先扫描包，拿到所有的.class文件，
2）解析类上面有没有@Componet的注解，如果有的话，就把这个Bean注册为BeanDefinition以便工厂生产。 - 定义态
配置Bean的定义信息：全类名，是否懒加载，自动装配的方式等…把它读取为
BeanDefinition称之为定义态。
注册为BeanDefinition之后就交给BeanFactory去生产Bean
1）生产之前先去判断这个Bean是单例的，并且不是懒加载，不是抽象的才会在Ioc加载的时候进行生产
然后判断这个Bean是否已经存在这个Ioc容器中，如果找到了，就直接返回。
Bean的所有信息都是存在Map中,Key就是Bean名,value就是属性。 - 纯净态
1）创建：通过反射机制实例化这个Bean
拿到完整类路径通过反射得到的对象，我们称之为纯净态，因为它里面的依赖注入还没有赋值的。 - 成熟态
依赖注入，初始化完成，然后加入Ioc容器中。Key就是Bean的名字，Value就是Bean
总结：
- 实例化ApplicationContext对象
- 调用Bean工厂的后置处理器解析类
- 扫描包如果有@Component注解，有的话就注册为BeanDefinition对象存储起来
以便后续BeanFactory调用
4.判断这个Bean是否单例，是否懒加载，是否为抽象，还有去IOC容器中查看这个Bean是否存在
5.通过反射机制实例化Bean,依赖注入完成，实现回调接口，如果需要代理则完成代理然后放在Ioc容器中(单例池)。
扩展点就是Bean生命周期中的钩子方法。
注册过程中：
注册配置：invokeBeanFactoryPostProcessor
如果没有配置Bean的定义信息可以通过BeanDefinitionRegistryPostProcessor扩展接口来动态注册BeanDefinition。
子接口：BeanDefinitionRegistryPostProcessor:Bean定义的注册后置处理器
父接口：BeanFactoryPostProcessor:BeanFactory工厂的后置处理器：在注册BeanDefinition的时候可以对
BeanFactory进行扩展。
生产过程中：Bean的生命周期过程中会调用9次Bean的后置处理
初始化阶段：SetxxxxAway接口
生命周期回调：初始化initMethod方法，和销毁destoryMethod方法 6种
SpringBean：由SpingIoc容器管理的对象称之为springBean，bean是被SpringIoc容器实例化和管理的
JavaBean：java的类就是javaBean,有属性方法以及构造函数等。
区别：javaBean是我们自己通过new创建的，springbean是ioc容器创建管理的。
1、通过xml配置
2、通过@Conmponent（@Controller,@Service,@Repostory） 前提必须配置扫描包
3、javaConfig:@Bean
2和3的区别：
@Component通过反射生产Bean ;
@Bean标注在方法上，必须返回一个对象，返回的这个对象交给IOC容器。
4、Impot 3.0之后推出的 3种方式
1）@import直接导入，静态带入
2）通过实现importSelector接口种的selectimports方法 返回一个数组(完整的类路径)
3）importBeanDefinitionRegistrar它提供了BeanDefinitiongistory注册器，可以动态的注册Bean
设置方法：在配置文件中通过scope设置，还可以通过@Scope注解设置
1、单例
2、多例
3、request:在web应用下，一个请求创建一个Bean对象
4、session:一次会话创建一个Bean
5、application:全局共享一个对象
单例：1、这个对象只会创建一次。减少内存消耗，提高性能。spring通过反射或者代理来创建Bean都是耗能的操作。
2、减少了JVM垃圾回收的负担。
3、可以快速的获取对象。
无状态的：不存储数据
有状态：存储数据
不是线程安全的。因为springBean是单例bean,有共享变量并且在并发的条件下会出现线程不安全的问题。
但是把变量申明在方法中就是线程安全的。调用方法实际上就是把方法中的Bean赋值一份到自己的工作内存所以是线程安全的。
1、可以把Bean设置为原型bean,这样每次去拿Bean的时候都会new一个Bean,这是线程安全的。
2、将成员变量放在ThreadLock中。绑定在线程上。
3、使用同步锁，在代码块中加入同步锁 synchrizoied锁 会降低性能。
4、将成员变量申明在方法中。
1、构造器方式(反射）@Component----spring去控制实例化
2、静态工厂的方式。配置一个Factory-method的属性指定一个方法，在实例化的时候Spring就会调用配置的方法去实例化这个Bean。
3、实例工厂(@Bean) factory-bean+factory-method 来实现。spring创建Bean就是通过这个方法。
4、FactoryBean的方式。实现FactoryBean接口，重写getObject()方法，在该方法中可以定义任意类型。
@Autoware 来进行手动指定需要自动注入的属性
1、默认no
2、Byname：通过bean的名称进行自动装配 按set方法的名字
3、ByType： 通过参数的数据类型，去IOC容器查找相应的类型利用set方法自动装配。
4、构造器：利用构造器进行装配，构造器的参数通过byType进行装配 ，如果类型有多个再byName去找。
5、atuodetect:自动探针，如果有构造器通过构造器装配，如果没有就使用byType的方式自动装配
生命周期的回调方法(钩子方法)分为两种
初始化的时候：
1）注解：@PostConstruct
2）实现接口：实现InitializingBean 的afterPropertiseSet()方法
3) 通过指定属性：@Bean 的属性init-Method----指定方法名字 (不能使用Component的方式)
销毁的时候：
1) 注解：@PerDestory
2）实现接口：实现DisposableBean 的destory()方法
3) 通过指定属性：@Bean 的属性destoryMethod----指定方法名字 (不能使用Component的方式)
1、Bean的配置状态–通过xml文件，@Bean，@Component,@import 配置了的Bean
2、Bean的定义状态–BeanDefinition封装了Bean的生产方式(作用域，是否懒加载等信息)
3、刚被实例化的状态–存在二级缓存中后期解决循环依赖的问题。
4、成熟状态–经过属性注入后，会加入到单例池中(一级缓存)
Bean的生命周期指的是Bean从创建到销毁的过程，这个过程大致分为4大步
1、实例化
1）@Compontent注解标注的Bean,通过反射拿到构造函数进行实例化；
2）静态工厂：通过Factory-Method指定一个静态方法去实例化Bean；
3）实例工厂@Bean注解标志的方法实例化Bean
4）通过实现FactoryBean中的getObject()方法
2、属性赋值
1）解析自动装配(通过构造器，byType，byName，@Autoware)----->DI的体现
2) 循环依赖
3、初始化
1）调用xxxAway回调方法 --实现了接口
2）调用初始化生命周期回调—钩子函数
3）如果Bean实现了Aop,则会创建动态代理
4、销毁
1）Spring容器关闭的时候进行调用
2）调用生命周期的回调方法
Spirng循环依赖是采用三级缓存来解决的，就是利用三个Map----一定要有一个缓存，保存早期对象作为死循环的出口
一级缓存：就是Ioc容器，里面存放完整的Bean;
二级缓存：在多重循环的情况下重复创建动态代理。
三级缓存：
a、是函数接口：通过lamdba表达式把创建Bean的方法，Bean的实例名字传进入，
**不会立即调用：**如果在Bean实例化之后立即调用的话，所有的AOP不管Bean是否存在循环依赖，
都会去创建代理对象，正常的Bean其实Spring希望遵循生命周期在初始化创建动态代理，这里创建动态代理
是为了解决循环依赖。(spring不使用三级缓存行不行？)
b、ABA会在第二次getBean(A)才会去调用三级缓存(AOP创建动态代理)，如果没有实现AOP依然返回BeanA的实例
c、然后讲A放入二级缓存。(避免重复创建)
1、二级缓存能不能解决循环依赖?
a、如果只是解决死循环的依赖问题，一级缓存就可以解决。弊端：无法避免在并发环境下获取到不完整的问题
b、二级缓存也可以解决循环依赖：只不过在多重循环依赖的环境下，会多次创建动态代理。
2、spring有没有解决多例Bean的循环依赖？
a、多例不会使用缓存进行存储(多例Bean每次使用都会重新创建)
b、不缓存早期对象是无法解决的。
3、Spring有没有解决构造函数参数Bean的循环依赖？
a、构造函数的循环依赖也会报错。
b、可以通过@Lazy延迟加载来解决，利用动态代理的原理，等需要用的时候才会去创建。
Spring如何解决循环依赖
spring中循环依赖有三种情况：
1、构造器注入形成的循环依赖。也就是beanB需要在beanA的构造函数中完成初始化，beanA也需要在beanB的构造函数中完成舒适化，这种情况的结果就是两个bean都不能完成初始化，循环依赖难以解决。
2、setter注入构成的循环依赖。beanA需要在beanB的setter方法中完成初始化，beanB也需要在beanA的setter方法中完成初始化，spring设计的机制主要就是解决这种循环依赖，也是今天下文讨论的重点。
3、prototype作用域bean的循环依赖。这种循环依赖同样无法解决，因为spring不会缓存‘prototype’作用域的bean，而spring中循环依赖的解决正是通过缓存来实现的。
下面主要说明第二种情况中循环依赖的解决方案
步骤一：beanA进行初始化，并且将自己进行初始化的状态记录下来，并提前向外暴露一个单例工程方法，从而使其他bean能引用到该bean（可能读完这一句，您仍然心存疑惑，没关系，继续往下读）
步骤二：beanA中有beanB的依赖，于是开始初始化beanB。
步骤三：初始化beanB的过程中又发现beanB依赖了beanA,于是又进行beanA的初始化，这时发现beanA已经在进行初始化了，程序发现了存在的循环依赖，然后通过步骤一中暴露的单例工程方法拿到beanA的引用（注意，此时的beanA只是完成了构造函数的注入但为完成其他步骤），从而beanB拿到beanA的引用，完成注入，完成了初始化，如此beanB的引用也就可以被beanA拿到，从而beanA也就完成了初始化。
spring进行bean的加载的时候，首先进行bean的初始化（调用构造函数），然后进行属性填充。在这两步中间，spring对bean进行了一次状态的记录，也就是说spring会把指向只完成了构造函数初始化的bean的引用通过一个变量记录下来
3.24spring是如何在并发的情况下避免获取不完整的Bean?在实例化之后还没有进行属性注入以及初始化就是不完整的Bean。
如何避免：线程在实例化以及初始化这个过程加了锁，其他线程两次检查一级缓存。
为什么不锁一级缓存，一级缓存就是Ioc容器，如果上锁其他线程就不能获取已经创建好的Bean
BeanDefinition用来存储Bean的生产信息，它决定了Bean的生产方式，BeanDefinition是定义态的bean
new ApplicationContext()—>解析Bean的配置信息—>然后再注册为BeanDefianitio—>然后BeanFacory生产。
1、读取配置类：BeanDefinitionReader
2、解析配置类：ConfigurationClassParser
3、扫描：找到所有的配置类，判断是否有@Component注解，排除接口，还有抽象类如果符合注册标准，就注册为BeaDefinition
1、在invokeBeanFactoryPostProcessors注册所有的BeanDefinition之后。
2、然后可以实现BeanFactoryPostProcessor(Bean工厂的后置处理器)接口进行扩展。
1、因为BeanDefinition会在Ioc容器加载的时候先注册，而BeanFactoryPostProcess会在BeanDefianition注册完之后
做扩展，所以需要先加载BeanFactoryPostProcess。
2、解析配置类的组件，实现了BeanFactoryProcess所以需要先去加载BeanFactoryProcess。
Bean的创建顺序是由BeanDefianition的注册顺序决定的，依赖关系也会影响Bean的创建顺序。
3.29 BeanDefianition的注册顺序是由什么决定的？- @Configuration
- @Component
- @import --类
- @Bean
- @import —实现了importBeanDefiaitionRegistrar
BeanDefianitionRegistPostProcess也可以
3.30 Spring有哪几种配置方式？1、XML配置文件
2、基于注解的配置spring2.5 --需要指定扫描包，然后可以使用@Component @Autoware
3、基于java的配置
1、以前的xml
a.创建Spring容器 ClassPathXmlApplicationContextt(“xml文件”)
b.Spring xml 配置文件
c.以前配置属性在Bean标签内配置
d.扫描包：
e.引入外部配置文件方式不同
2、javaConfig
a.创建Spring容器 AnnotationConfigApplicationContext(java配置类.class)
b.java配置类
c.现在使用@Bean @Scope @Lazy等
d.@ComponentScan
e.@import注解
- 读取配置配置文件
- 交给sqlsessionFactoryBulder构建sqlsessionFactory
- sqlsessionFactory生产sqlsession
- sqlsession调用mapper接口中的方法
- 解析sql交给JDBC
- JDBC完成查询，结果集映射封装成pojo对象
- 然会pojo然后关闭资源
http是无状态的协议，对事物处理没有记忆的能力。每次客户端和服务端完成会话时，
服 务端不会存储任何会话信息，
关联：
cookie：是浏览器存储的一种数据的功能，cookie由服务器生成发送给浏览器，
浏览器把cookie以key-value的形式存储在客户端，下次请求同意时候会把cookie发送给服务器。
session:可以理解为，服务器给客户端的一种身份标识，当访问服务端的时候带上这个身份标识，
服务端就能分辨是哪个客户端访问。
至于客户端怎么保存这个身份标识，由很多种方式，默认采用的cookie的方式保存
服务器使用session把用户信息临时保存在服务器上，用户关闭这次会话session会被销毁。
区别：
1、 安全性：session比cookie安全，session存储在服务端，cookie存储在客户端
2、 存储的数据类型不同：cookie只支持存储字符串数据类型，session可以存储任意类型。
3、 有效期不同：cookie可以设置为长时间保存，session的保存时间较短，客户端关闭，或者超时，session数据被清除。
4、 存储大小不同：单个cookie保存数据不能超过4K，session能保存数数据大小高于cookie,但是当访问量过多的时候会占用服务器资源。
- 数据存放位置：get请求是把数据拼接在地址中，put是把数据封装在request body中
- 提交数据大小：get提交的数据最大是2k，post理论上没有限制
- GET产生一个TCP数据包，POST产生两个TCP数据包
- GET在浏览器回退时是无害的，POST会再次提交请求
- GET请求会被浏览器主动cache，而POST不会，除非手动设置。
- GET请求参数会被完整保留在浏览器历史记录里，而POST中的参数不会被保留
- GET只接受ASCII字符的参数的数据类型，而POST没有限制
- get比post效率高
1、解决的做法就是"用Javascript控制Form表单只能提交一次
5 JVM 6 MySql数据库 6.1 简述乐观锁以及悲观锁的区别以及使用场景乐观锁：会乐观的认为其他线程不会修改数据，只有它要去修改变量的时候才会去比较比较一下数据是否被修改。适用于读多的场景。
悲观锁：每次拿数据的时候会悲观的认为其他线程一定会修改数据，所以先加锁，这样其他想要获取数据的线程都会阻塞，适用于写多的场景。
3.简述事务的四大特性
4.mysql 为什么用 B+ 树来做索引，对比 B 树它的优点和缺点是什么？
5.简述脏读和幻读的发生场景，innodb 是如何解决幻读的？
6.数据库的事务的隔离级别有哪些？各有哪些优缺点？
7.聚簇索引和非聚簇索引有什么区别？什么情况用聚集索引？
8.什么是数据库事务，MySQL 为什么会使用 innoDB 作为默认选项？
9.Mysql 有哪些常见的存储引擎？
10.数据库有哪些常见索引？数据库设计的范式是什么？
11.简述数据库中的 ACID 分别是什么？
12.MySQL 中 Join 和 left join 的区别是什么？
13.简述 MySQL 三种日志的使用场景
14.模糊匹配查询是如何实现的？
15.SQL 优化的方案有哪些，如何定位问题并解决问题？
16.简述数据库什么情况下进行分库，什么情况下进行分表？
17.数据库索引的实现原理是什么？
18.简述什么是最左匹配原则？
19.数据库的读写分离的作用是什么？如何实现？
20.唯一索引与普通索引的区别是什么？使用索引会有哪些优缺点？
21.MySQL 的索引什么情况下会失效？
22.简述 MySQL 的主从同步机制，如果同步失败会怎么样？
23.假设建立联合索引(a,b,c)，如果对字段 a 和 c 查询，会用到这个联合索引吗？
24.数据库连接池实现原理
25.数据库的实现原理
26.事务的实现原理
27.索引有什么用？如何建索引？
