百度面试经验和流程

迈不过友情╰ 2022-04-15 03:15 296阅读 0赞

笔者小菜鸡一枚，今天有幸去百度面试，感觉大公司就是不一样，所以感觉有必要总结一下面试经验，以及面试中遇到的一些问题，以便大家参考：

##### 1.我面试地点是百度科技园，第一关就是不知道如何进门，尴尬，首先要联系你的面试邀请人，他会帮你去搞一个面试邀请短信发到你的手机上，你凭这个短信才能进入科技园，然后进入大厅，去前台，点击短信中的链接 去打印一个二维码，再告知的面试官，让他下来接你。 #####

##### 2. 一般他会把你领到一个开放的会议室，或者叫休息区更合适,接着你把简历交给他，他一般会说简单介绍自己一下吧，或者说说你的上一家的工作。接着你就巴啦巴拉的说就完了。这个时候面试官会边听你讲，边看你的简历。如果你讲的东西他感兴趣，他就会问你一些问题,以下是我被问到的一些问题： #####

### 1.说一下你对spring的理解（aop和ioc） ###

IoC（Inversion of Control）

(1). IoC（Inversion of Control）是指容器控制程序对象之间的关系，而不是传统实现中，由程序代码直接操控。控制权由应用代码中转到了外部容器，控制权的转移是所谓反转。 对于Spring而言，就是由Spring来控制对象的生命周期和对象之间的关系；IoC还有另外一个名字——“依赖注入（Dependency Injection）”。从名字上理解，所谓依赖注入，即组件之间的依赖关系由容器在运行期决定，即由容器动态地将某种依赖关系注入到组件之中。

(2). 在Spring的工作方式中，所有的类都会在spring容器中登记，告诉spring这是个什么东西，你需要什么东西，然后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转。

(3). 在系统运行中，动态的向某个对象提供它所需要的其他对象。

(4). 依赖注入的思想是通过反射机制实现的，在实例化一个类时，它通过反射调用类中set方法将事先保存在HashMap中的类属性注入到类中。 总而言之，在传统的对象创建方式中，通常由调用者来创建被调用者的实例，而在Spring中创建被调用者的工作由Spring来完成，然后注入调用者，即所谓的依赖注入or控制反转。 注入方式有两种：依赖注入和设置注入； IoC的优点：降低了组件之间的耦合，降低了业务对象之间替换的复杂性，使之能够灵活的管理对象。

AOP（Aspect Oriented Programming）

(1). AOP面向方面编程基于IoC，是对OOP的有益补充；

(2). AOP利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了 多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即方面。所谓“方面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的 逻辑或责任封装起来，比如日志记录，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。

(3). AOP代表的是一个横向的关 系，将“对象”比作一个空心的圆柱体，其中封装的是对象的属性和行为；则面向方面编程的方法，就是将这个圆柱体以切面形式剖开，选择性的提供业务逻辑。而 剖开的切面，也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原，不留痕迹，但完成了效果。

(4). 实现AOP的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；二是采用静态织入的方式，引入特定的语法创建“方面”，从而使得编译器可以在编译期间织入有关“方面”的代码。

(5). Spring实现AOP：JDK动态代理和CGLIB代理 JDK动态代理：其代理对象必须是某个接口的实现，它是通过在运行期间创建一个接口的实现类来完成对目标对象的代理；其核心的两个类是InvocationHandler和Proxy。 CGLIB代理：实现原理类似于JDK动态代理，只是它在运行期间生成的代理对象是针对目标类扩展的子类。CGLIB是高效的代码生成包，底层是依靠ASM（开源的java字节码编辑类库）操作字节码实现的，性能比JDK强；需要引入包asm.jar和cglib.jar。 使用AspectJ注入式切面和@AspectJ注解驱动的切面实际上底层也是通过动态代理实现的。

(6). AOP使用场景：

Authentication 权限检查

Caching 缓存

Context passing 内容传递

Error handling 错误处理

Lazy loading　延迟加载

Debugging　　调试

logging, tracing, profiling and monitoring　日志记录，跟踪，优化，校准

Performance optimization　性能优化，效率检查

Persistence　　持久化

Resource pooling　资源池

Synchronization　同步

Transactions 事务管理

另外Filter的实现和struts2的拦截器的实现都是AOP思想的体现。

### 2.spring的几种注入方式 ###

在Spring容器中为一个bean配置依赖注入有三种方式：

##### · 使用属性的setter方法注入 这是最常用的方式； #####

##### · 使用构造器注入； #####

##### · 使用Filed注入（用于注解方式）. #####

使用属性的setter方法注入

首先要配置被注入的bean，在该bean对应的类中，应该有要注入的对象属性或者基本数据类型的属性。例如：为UserBiz类注入UserDAO，同时为UserBiz注入基本数据类型String，那么这时，就要为UserDAO对象和String类型设置setter方法.，用于进行依赖注入。

如何配置该bean呢？

<bean id="userBiz" class="com.text.biz.impl.UserBizImpl">
    
    <property name="userDao">
    
    <ref>userDao</ref>
    
    </property>
    
    </bean>

以上就是一个使用属性的setter方法的方式进行依赖注入。

使用构造器注入

第一，在PersonBiz类中注入PersonDAO和一个String类型的数据；在该类中，不用为PersonDAO属性和String数据类型的属性设置setter方法，但是需要生成该类的构造方法；如下：

public class PersonBizImpl implements PersonBiz { 
    
    // 声明"依赖对象"PersonDAO
    
    PersonDAO personDao = null;
    
    // 声明"依赖的基本数据类型"
    
    String str = null;
    
    // 生成无参构造方法
    
    public PersonBizImpl() { 
    
    super();
    
    }
    
    // 生成带参构造方法
    
    public PersonBizImpl(PersonDAO personDao, String str) { 
    
    super();
    
    this.personDao = personDao;
    
    this.str = str;
    
    }
    
    public void addPerson() { 
    
    this.personDao.addPerson();
    
    System.out.println(str);
    
    }
    
    }

第二，在配置文件中配置该类的bean，并配置构造器，在配置构造器中用到了节点，该节点有四个属性：

· index是索引，指定注入的属性，从0开始，如：0代表personDao，1代表str属性；

· type是指该属性所对应的类型，如Persondao对应的是com.aptech.dao.PersonDAO；

· ref 是指引用的依赖对象；

· value 当注入的不是依赖对象，而是基本数据类型时，就用value；

如下：

<bean id="personDao" class="com.aptech.dao.impl.PersonDAOImpl"></bean>
    
    <bean id="personBiz" class="com.aptech.biz.impl.PersonBizImpl">
    
    <constructorarg index="0" type="com.aptech.dao.PersonDAO"ref="personDao"></constructor-arg>
    
    <constructor-arg index="1" value="Spring学习"></constructor-arg>
    
    </bean>

使用字段(Filed)注入（用注解方式）

在Spring中，注入依赖对象可以采用手工装配或自动装配，在实际应用开发中建议使用手工装配，因为自动装配会产生许多未知情况，开发人员无法预见最终的装配结果。

手工装配依赖对象又分为两种方式：

一种是在XML文件中，通过在bean节点下配置；如上面讲到的使用属性的setter方法注入依赖对象和使用构造器方法注入依赖对象都是这种方式。

另一种就是在java代码中使用注解的方式进行装配，在代码中加入@Resource或者@Autowired、

怎样使用注解的方式来为某个bena注入依赖对象呢？

首先，我们需要在Spring容器的配置文件applicationContext.Xml文件中配置以下信息,该信心是一个Spring配置文件的模板：

注意：只有配置了红色部分的代码才可以引入注解的命名空间，否则报错。 以上的配置隐式的注册了多个对注释进行解析的处理器：AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor、PersistenceAnnotationBeanPostProcessor等。

其次，在配置文件中打开context:annotation-config节点，告诉Spring容器可以用注解的方式注入依赖对象；其在配置文件中的代码如下：

第三，在配置文件中配置bean对象，如下：

第四，在需要依赖注入的BIZ类中，声明一个依赖对象，不用生成该依赖对象的setter方法，并且为该对象添加注解：

public class UserBizImpl implements UserBiz { 
    
    @Resource(name="userDao")
    
    private UserDAO userDao = null;
    
    public void addUser() { 
    
    this.userDao.addUser();
    
    }
    
    }

其中，在Java代码中可以使用@Autowired或@Resource注解方式进行Spring的依赖注入。两者的区别是：@Autowired默认按类型装配，@Resource默认按名称装配，当找不到与名称匹配的bean时，才会按类型装配。

比如：我们用@Autowired为上面的代码UserDAO接口的实例对象进行注解，它会到Spring容器中去寻找与UserDAO对象相匹配的类型，如果找到该类型则将该类型注入到userdao字段中；

如果用@Resource进行依赖注入，它先会根据指定的name属性去Spring容器中寻找与该名称匹配的类型，例如：@Resource(name=“userDao”)，如果没有找到该名称，则会按照类型去寻找，找到之后，会对字段userDao进行注入。

通常我们使用@Resource。

使用注解注入依赖对象不用再在代码中写依赖对象的setter方法或者该类的构造方法，并且不用再配置文件中配置大量的依赖对象，使代码更加简洁，清晰，易于维护。

在Spring IOC编程的实际开发中推荐使用注解的方式进行依赖注入。

~~  
依赖注入—自动装配 Spring中提供了自动装配依赖对象的机制，但是在实际应用中并不推荐使用自动装配，因为自动装配会产生未知情况，开发人员无法预见最终的装配结果。 自动装配是在配置文件中实现的，如下： 只需要配置一个autowire属性即可完成自动装配，不用再配置文件中写,但是在类中还是要生成依赖对象的setter方法。 Autowire的属性值有如下几个： · byType 按类型装配 可以根据属性类型，在容器中寻找该类型匹配的bean，如有多个，则会抛出异常，如果没有找到，则属性值为null； · byName 按名称装配 可以根据属性的名称在容器中查询与该属性名称相同的bean，如果没有找到，则属性值为null； · constructor 与byType方式相似，不同之处在与它应用于构造器参数，如果在容器中没有找到与构造器参数类型一致的bean，那么将抛出异常； · autodetect 通过bean类的自省机制(introspection)来决定是使用constructor还是byType的方式进行自动装配。如果发现默认的构造器，那么将使用byType的方式。

### 3.spring常用的注解 ###

Spring常用注解  
使用注解来构造IoC容器  
用注解来向Spring容器注册Bean。需要在applicationContext.xml中注册<context:component-scan base-package=”pagkage1\[,pagkage2,…,pagkageN\]”/>。

如：在base-package指明一个包

1 <context:component-scan base-package=“cn.gacl.java”/>  
表明cn.gacl.java包及其子包中，如果某个类的头上带有特定的注解【@Component/@Repository/@Service/@Controller】，就会将这个对象作为Bean注册进Spring容器。也可以在<context:component-scan base-package=” ”/>中指定多个包，如：

1 <context:component-scan base-package="cn.gacl.dao.impl,cn.gacl.service.impl,cn.gacl.action"/>

多个包逗号隔开。

1、@Component  
@Component  
是所有受Spring 管理组件的通用形式，@Component注解可以放在类的头上，@Component不推荐使用。

2、@Controller  
@Controller对应表现层的Bean，也就是Action，例如：

1 @Controller
    2 @Scope("prototype")
    3 public class UserAction extends BaseAction<User>{ 
    4 ……
    5 }

使用@Controller注解标识UserAction之后，就表示要把UserAction交给Spring容器管理，在Spring容器中会存在一个名字为"userAction"的action，这个名字是根据UserAction类名来取的。注意：如果@Controller不指定其value【@Controller】，则默认的bean名字为这个类的类名首字母小写，如果指定value【@Controller(value=“UserAction”)】或者【@Controller(“UserAction”)】，则使用value作为bean的名字。

这里的UserAction还使用了@Scope注解，@Scope(“prototype”)表示将Action的范围声明为原型，可以利用容器的scope="prototype"来保证每一个请求有一个单独的Action来处理，避免struts中Action的线程安全问题。spring 默认scope 是单例模式(scope=“singleton”)，这样只会创建一个Action对象，每次访问都是同一Action对象，数据不安全，struts2 是要求每次次访问都对应不同的Action，scope=“prototype” 可以保证当有请求的时候都创建一个Action对象

3、@ Service  
@Service对应的是业务层Bean，例如：

1 @Service("userService")
    2 public class UserServiceImpl implements UserService { 
    3 ………
    4 }

@Service(“userService”)注解是告诉Spring，当Spring要创建UserServiceImpl的的实例时，bean的名字必须叫做"userService"，这样当Action需要使用UserServiceImpl的的实例时,就可以由Spring创建好的"userService"，然后注入给Action：在Action只需要声明一个名字叫“userService”的变量来接收由Spring注入的"userService"即可，具体代码如下：

1 // 注入userService
    2 @Resource(name = "userService")
    3 private UserService userService;

注意：在Action声明的“userService”变量的类型必须是“UserServiceImpl”或者是其父类“UserService”，否则由于类型不一致而无法注入，由于Action中的声明的“userService”变量使用了@Resource注解去标注，并且指明了其name = “userService”，这就等于告诉Spring，说我Action要实例化一个“userService”，你Spring快点帮我实例化好，然后给我，当Spring看到userService变量上的@Resource的注解时，根据其指明的name属性可以知道，Action中需要用到一个UserServiceImpl的实例，此时Spring就会把自己创建好的名字叫做"userService"的UserServiceImpl的实例注入给Action中的“userService”变量，帮助Action完成userService的实例化，这样在Action中就不用通过“UserService userService = new UserServiceImpl();”这种最原始的方式去实例化userService了。如果没有Spring，那么当Action需要使用UserServiceImpl时，必须通过“UserService userService = new UserServiceImpl();”主动去创建实例对象，但使用了Spring之后，Action要使用UserServiceImpl时，就不用主动去创建UserServiceImpl的实例了，创建UserServiceImpl实例已经交给Spring来做了，Spring把创建好的UserServiceImpl实例给Action，Action拿到就可以直接用了。Action由原来的主动创建UserServiceImpl实例后就可以马上使用，变成了被动等待由Spring创建好UserServiceImpl实例之后再注入给Action，Action才能够使用。这说明Action对“UserServiceImpl”类的“控制权”已经被“反转”了，原来主动权在自己手上，自己要使用“UserServiceImpl”类的实例，自己主动去new一个出来马上就可以使用了，但现在自己不能主动去new“UserServiceImpl”类的实例，new“UserServiceImpl”类的实例的权力已经被Spring拿走了，只有Spring才能够new“UserServiceImpl”类的实例，而Action只能等Spring创建好“UserServiceImpl”类的实例后，再“恳求”Spring把创建好的“UserServiceImpl”类的实例给他，这样他才能够使用“UserServiceImpl”，这就是Spring核心思想“控制反转”，也叫“依赖注入”，“依赖注入”也很好理解，Action需要使用UserServiceImpl干活，那么就是对UserServiceImpl产生了依赖，Spring把Acion需要依赖的UserServiceImpl注入(也就是“给”)给Action，这就是所谓的“依赖注入”。对Action而言，Action依赖什么东西，就请求Spring注入给他，对Spring而言，Action需要什么，Spring就主动注入给他。

4、@ Repository  
@Repository对应数据访问层Bean ，例如：

1 @Repository(value="userDao")
    2 public class UserDaoImpl extends BaseDaoImpl<User> {
    3 ………
    4 }

@Repository(value=“userDao”)注解是告诉Spring，让Spring创建一个名字叫“userDao”的UserDaoImpl实例。

当Service需要使用Spring创建的名字叫“userDao”的UserDaoImpl实例时，就可以使用@Resource(name = “userDao”)注解告诉Spring，Spring把创建好的userDao注入给Service即可。

1 // 注入userDao，从数据库中根据用户Id取出指定用户时需要用到
    2 @Resource(name = "userDao")
    3 private BaseDao<User> userDao;

### 4.使用spring要引入哪些jar包 ###

<dependencies>
      
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.2.4.RELEASE</version>
    </dependency>
      
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>4.2.4.RELEASE</version>
    </dependency>
      
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>4.2.4.RELEASE</version>
    </dependency>
      
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-expression</artifactId>
        <version>4.2.4.RELEASE</version>
    </dependency>
    
    	<dependency>
    		<groupId>junit</groupId>
    		<artifactId>junit</artifactId>
    		<version>4.9</version>
    		<scope>test</scope>
    	</dependency>
      </dependencies>

### 5.spring如何解决循环注入问题 ###

第一种，解决setter对象的依赖，就是说在A类需要设置B类，B类需要设置C类，C类需要设置A类，这时就出现一个死循环，

spring的解决方案是，初始化A类时把A类的初始化Bean放到缓存中，然后set B类，再把B类的初始化Bean放到缓存中，

然后set C类，初始化C类需要A类和B类的Bean，这时不需要初始化，只需要从缓存中取出即可.

该种仅对single作用的Bean起作用，因为prototype作用的Bean，Spring不对其做缓存

第二种，解决构造器中对其它类的依赖，创建A类需要构造器中初始化B类，创建B类需要构造器中初始化C类，创建C类需要构造器中又要初始化A类，因而形成一个死循环，Spring的解决方案是，把创建中的Bean放入到一个“当前创建Bean池”中，在初始化类的过程中，如果发现Bean类已存在，就抛出一个“BeanCurrentInCreationException”的异常

### 6.mysql数据库的常见优化手段有哪些 ###

Mysql的优化，大体可以分为三部分：索引的优化，sql语句的优化，表的优化

##### 1.索引的优化 #####

只要列中含有NULL值，就最好不要在此例设置索引，复合索引如果有NULL值，此列在使用时也不会使用索引  
尽量使用短索引，如果可以，应该制定一个前缀长度  
对于经常在where子句使用的列，最好设置索引，这样会加快查找速度  
对于有多个列where或者order by子句的，应该建立复合索引  
对于like语句，以%或者‘-’开头的不会使用索引，以%结尾会使用索引  
尽量不要在列上进行运算（函数操作和表达式操作）  
尽量不要使用not in和<>操作

##### 2.sql语句的优化 #####

查询时，能不要*就不用*，尽量写全字段名  
大部分情况连接效率远大于子查询  
多使用explain和profile分析查询语句  
查看慢查询日志，找出执行时间长的sql语句优化  
多表连接时，尽量小表驱动大表，即小表 join 大表  
在千万级分页时使用limit  
对于经常使用的查询，可以开启缓存

##### 3.表的优化 #####

表的字段尽可能用NOT NULL  
字段长度固定的表查询会更快  
把数据库的大表按时间或一些标志分成小表  
将表分区

### 7.mysql和redis的区别 ###

MySQL是关系型数据库，是持久化存储的，查询检索的话，会涉及到磁盘IO操作，为了提高性能，可以使用缓存技术，而memcached就是内存数据库，数据存储在内存中（当然也可以进行持久化存储），可以用作缓存数据库。用户首先去memcached查询数据，如果未查询到（即缓存未命中），才去MySQL中查询数据，查询到的数据会更新到缓存数据库中，提供给下次可能进行的查询。提高了数据查询方面的性能。

Redis和memcached都是缓存数据库，可以大大提升高数据量的web访问速度。但是memcached只是提供了简单的数据结构string，而Redis的value可以是string、list、set、hash、sorted set这些，功能更加强大。

web应用中一般采用MySQL+Redis的方式，web应用每次先访问Redis，如果没有找到数据，才去访问MySQL。

Redis是内存数据库，数据保存在内存中，访问速度快。MySQL是关系型数据库，功能强大，存储在磁盘中，数据访问速度慢。像memcached，MongoDB，Redis等，都属于No sql系列。

8.mysql如何建立索引，以及依据，如何判断索引是否生效

在mysql中使用索引的原则有以下几点：

1、 对于查询频率高的字段创建索引；

2、 对排序、分组、联合查询频率高的字段创建索引；

3、 索引的数目不宜太多  
原因：a、每创建一个索引都会占用相应的物理控件；  
　　 b、过多的索引会导致insert、update、delete语句的执行效率降低；

4、若在实际中，需要将多个列设置索引时，可以采用多列索引  
如：某个表(假设表名为Student)，存在多个字段(StudentNo, StudentName, Sex, Address, Phone, BirthDate)，其中需要对StudentNo,StudentName字段进行查询，对Sex字段进行分组，对BirthDate字段进行排序，此时可以创建多列索引  
index index\_name (StudentNo, StudentName, Sex, BirthDate); \#index\_name为索引名  
在上面的语句中只创建了一个索引，但是对4个字段都赋予了索引的功能。  
创建多列索引，需要遵循BTree类型，  
即第一列使用时，才启用索引。  
在上面的创建语句中，只有mysql语句在使用到StudentNo字段时，索引才会被启用。  
如: select \* from Student where StudentNo = 1000; \#使用到了StudentNo字段，索引被启用。  
可以使用explain检测索引是否被启用  
如:explain select \* from Student where StudentNo = 1000;

5、选择唯一性索引  
唯一性索引的值是唯一的，可以更快速的通过该索引来确定某条记录。例如，学生表中学号是具有唯一性的字段。为该字段建立唯一性索引可以很快的确定某个学生的信息。如果使用姓名的话，可能存在同名现象，从而降低查询速度。

6、尽量使用数据量少的索引  
如果索引的值很长，那么查询的速度会受到影响。例如，对一个CHAR(100)类型的字段进行全文检索需要的时间肯定要比对CHAR(10)类型的字段需要的时间要多。

7、尽量使用前缀来索引  
如果索引字段的值很长，最好使用值的前缀来索引。例如，TEXT和BLOG类型的字段，进行全文检索会很浪费时间。如果只检索字段的前面的若干个字符，这样可以提高检索速度。

8、删除不再使用或者很少使用的索引.  
表中的数据被大量更新，或者数据的使用方式被改变后，原有的一些索引可能不再需要。数据库管理员应当定期找出这些索引，将它们删除，从而减少索引对更新操作的影响  
使用方法，在select语句前加上explain就可以了：

EXPLAIN SELECT surname,first_name form a,b WHERE a.id=b.id

EXPLAIN列的解释：

table：显示这一行的数据是关于哪张表的。

type：这是重要的列，显示连接使用了何种类型。从最好到最差的连接类型为const、eq\_reg、ref、range、index和ALL。

possible\_keys：显示可能应用在这张表中的索引。如果为空，没有可能的索引。可以为相关的域从WHERE语句中选择一个合适的语句。

key： 实际使用的索引。如果为NULL，则没有使用索引。很少的情况下，MySQL会选择优化不足的索引。这种情况下，可以在SELECT语句中使用USE INDEX（indexname）来强制使用一个索引或者用IGNORE INDEX（indexname）来强制MySQL忽略索引。

key\_len：使用的索引的长度。在不损失精确性的情况下，长度越短越好。

ref：显示索引的哪一列被使用了，如果可能的话，是一个常数。

rows：MySQL认为必须检查的用来返回请求数据的行数。

Extra：关于MySQL如何解析查询的额外信息。

extra列返回的描述的意义：

Distinct: 一旦MySQL找到了与行相联合匹配的行，就不再搜索了。
    
    Not exists: MySQL优化了LEFT JOIN，一旦它找到了匹配LEFT JOIN标准的行，就不再搜索了。
    
    Range checked for each Record（index map:#）: 没有找到理想的索引，因此对于从前面表中来的每一个行组合，MySQL检查使用哪个索引，并用它来从表中返回行。这是使用索引的最慢的连接之一。
    
    Using filesort: 看到这个的时候，查询就需要优化了。MySQL需要进行额外的步骤来发现如何对返回的行排序。它根据连接类型以及存储排序键值和匹配条件的全部行的行指针来排序全部行。
    
    Using index: 列数据是从仅仅使用了索引中的信息而没有读取实际的行动的表返回的，这发生在对表的全部的请求列都是同一个索引的部分的时候。
    
    Using temporary: 看到这个的时候，查询需要优化了。这里，MySQL需要创建一个临时表来存储结果，这通常发生在对不同的列集进行ORDER BY上，而不是GROUP BY上。
    
    Where used: 使用了WHERE从句来限制哪些行将与下一张表匹配或者是返回给用户。如果不想返回表中的全部行，并且连接类型ALL或index，这就会发生，或者是查询有问题不同连接类型的解释（按照效率高低的顺序排序）。
    
    system: 表只有一行：system表。这是const连接类型的特殊情况。
    
    const: 表中的一个记录的最大值能够匹配这个查询（索引可以是主键或惟一索引）。因为只有一行，这个值实际就是常数，因为MySQL先读这个值然后把它当做常数来对待。
    
    eq_ref: 在连接中，MySQL在查询时，从前面的表中，对每一个记录的联合都从表中读取一个记录，它在查询使用了索引为主键或惟一键的全部时使用。
    
    ref: 这个连接类型只有在查询使用了不是惟一或主键的键或者是这些类型的部分（比如，利用最左边前缀）时发生。对于之前的表的每一个行联合，全部记录都将从表中读出。这个类型严重依赖于根据索引匹配的记录多少—越少越好。
    
    range: 这个连接类型使用索引返回一个范围中的行，比如使用>或<查找东西时发生的情况。
    
    index: 这个连接类型对前面的表中的每一个记录联合进行完全扫描（比ALL更好，因为索引一般小于表数据）。
    
    ALL: 这个连接类型对于前面的每一个记录联合进行完全扫描，这一般比较糟糕，应该尽量避免。

### 9.mysql的数据库引擎有哪些，他们之间的差别是啥 ###

数据库引擎介绍

MySQL数据库引擎取决于MySQL在安装的时候是如何被编译的。要添加一个新的引擎，就必须重新编译MYSQL。在缺省情况下，MYSQL支持三个引擎：ISAM、MYISAM和HEAP。另外两种类型INNODB和BERKLEY（BDB），也常常可以使用。如果技术高超，还可以使用MySQL+API自己做一个引擎。下面介绍几种数据库引擎：  
ISAM：ISAM是一个定义明确且历经时间考验的数据表格管理方法，它在设计之时就考虑到 数据库被查询的次数要远大于更新的次数。因此，ISAM执行读取操作的速度很快，而且不占用大量的内存和存储资源。ISAM的两个主要不足之处在于，它不 支持事务处理，也不能够容错：如果你的硬盘崩溃了，那么数据文件就无法恢复了。如果你正在把ISAM用在关键任务应用程序里，那就必须经常备份你所有的实 时数据，通过其复制特性，MYSQL能够支持这样的备份应用程序。  
MyISAM：MyISAM是MySQL的ISAM扩展格式和缺省的数据库引擎。除了提供ISAM里所没有的索引和字段管理的大量功能，MyISAM还使用一种表格锁定的机制，来优化多个并发的读写操作，其代价是你需要经常运行OPTIMIZE TABLE命令，来恢复被更新机制所浪费的空间。MyISAM还有一些有用的扩展，例如用来修复数据库文件的MyISAMCHK工具和用来恢复浪费空间的 MyISAMPACK工具。MYISAM强调了快速读取操作，这可能就是为什么MySQL受到了WEB开发如此青睐的主要原因：在WEB开发中你所进行的大量数据操作都是读取操作。所以，大多数虚拟主机提供商和INTERNET平台提供商只允许使用MYISAM格式。MyISAM格式的一个重要缺陷就是不能在表损坏后恢复数据。  
HEAP：HEAP允许只驻留在内存里的临时表格。驻留在内存里让HEAP要比ISAM和MYISAM都快，但是它所管理的数据是不稳定的，而且如果在关机之前没有进行保存，那么所有的数据都会丢失。在数据行被删除的时候，HEAP也不会浪费大量的空间。HEAP表格在你需要使用SELECT表达式来选择和操控数据的时候非常有用。要记住，在用完表格之后就删除表格。  
InnoDB：InnoDB数据库引擎都是造就MySQL灵活性的技术的直接产品，这项技术就是MYSQL+API。在使用MYSQL的时候，你所面对的每一个挑战几乎都源于ISAM和MyISAM数据库引擎不支持事务处理（transaction process）也不支持外来键。尽管要比ISAM和 MyISAM引擎慢很多，但是InnoDB包括了对事务处理和外来键的支持，这两点都是前两个引擎所没有的。如前所述，如果你的设计需要这些特性中的一者 或者两者，那你就要被迫使用后两个引擎中的一个了。  
如果感觉自己的确技术高超，你还能够使用MySQL+API来创建自己的数据库引擎。这个API为你提供了操作字段、记录、表格、数据库、连接、安全帐号的功能，以及建立诸如MySQL这样DBMS所需要的所有其他无数功能。深入讲解API已经超出了本文的范围，但是你需要了解MySQL+API的存在及其可交换引擎背后的技术，这一点是很重要的。估计这个插件式数据库引擎的模型甚至能够被用来为MySQL创建本地的XML提供器（XML provider）。（任何读到本文的MySQL+API开发人员可以把这一点当作是个要求。）  
MyISAM与InnoDB的区别  
　　InnoDB和MyISAM是许多人在使用MySQL时最常用的两个表类型，这两个表类型各有优劣，视具体应用而定。基本的差别为：MyISAM类型不支持事务处理等高级处理，而InnoDB类型支持。MyISAM类型的表强调的是性能，其执行数度比InnoDB类型更快，但是不提供事务支持，而InnoDB提供事务支持已经外部键等高级数据库功能。

以下是一些细节和具体实现的差别：  
1.InnoDB不支持FULLTEXT类型的索引。  
2.InnoDB 中不保存表的具体行数，也就是说，执行select count(*) fromtable时，InnoDB要扫描一遍整个表来计算有多少行，但是MyISAM只要简单的读出保存好的行数即可。注意的是，当count(*)语句包含where条件时，两种表的操作是一样的。  
3.对于AUTO\_INCREMENT类型的字段，InnoDB中必须包含只有该字段的索引，但是在MyISAM表中，可以和其他字段一起建立联合索引。  
4.DELETE FROM table时，InnoDB不会重新建立表，而是一行一行的删除。  
5.LOAD TABLE FROMMASTER操作对InnoDB是不起作用的，解决方法是首先把InnoDB表改成MyISAM表，导入数据后再改成InnoDB表，但是对于使用的额外的InnoDB特性(例如外键)的表不适用。

另外，InnoDB表的行锁也不是绝对的，假如在执行一个SQL语句时MySQL不能确定要扫描的范围，InnoDB表同样会锁全表，例如updatetable set num=1 where name like “a%”  
两种类型最主要的差别就是Innodb支持事务处理与外键和行级锁.而MyISAM不支持.所以MyISAM往往就容易被人认为只适合在小项目中使用。  
我作为使用MySQL的用户角度出发，Innodb和MyISAM都是比较喜欢的，但是从我目前运维的数据库平台要达到需求：99.9%的稳定性，方便的扩展性和高可用性来说的话，MyISAM绝对是我的首选。

原因如下：  
1、首先我目前平台上承载的大部分项目是读多写少的项目，而MyISAM的读性能是比Innodb强不少的。  
2、MyISAM的索引和数据是分开的，并且索引是有压缩的，内存使用率就对应提高了不少。能加载更多索引，而Innodb是索引和数据是紧密捆绑的，没有使用压缩从而会造成Innodb比MyISAM体积庞大不小。  
3、从平台角度来说，经常隔1，2个月就会发生应用开发人员不小心update一个表where写的范围不对，导致这个表没法正常用了，这个时候MyISAM的优越性就体现出来了，随便从当天拷贝的压缩包取出对应表的文件，随便放到一个数据库目录下，然后dump成sql再导回到主库，并把对应的binlog补上。如果是Innodb，恐怕不可能有这么快速度，别和我说让Innodb定期用导出xxx.sql机制备份，因为我平台上最小的一个数据库实例的数据量基本都是几十G大小。  
4、从我接触的应用逻辑来说，select count(*) 和order by是最频繁的，大概能占了整个sql总语句的60%以上的操作，而这种操作Innodb其实也是会锁表的，很多人以为Innodb是行级锁，那个只是where对它主键是有效，非主键的都会锁全表的。  
5、还有就是经常有很多应用部门需要我给他们定期某些表的数据，MyISAM的话很方便，只要发给他们对应那表的frm.MYD,MYI的文件，让他们自己在对应版本的数据库启动就行，而Innodb就需要导出xxx.sql了，因为光给别人文件，受字典数据文件的影响，对方是无法使用的。  
6、如果和MyISAM比insert写操作的话，Innodb还达不到MyISAM的写性能，如果是针对基于索引的update操作，虽然MyISAM可能会逊色Innodb,但是那么高并发的写，从库能否追的上也是一个问题，还不如通过多实例分库分表架构来解决。  
7、如果是用MyISAM的话，merge引擎可以大大加快应用部门的开发速度，他们只要对这个merge表做一些selectcount(*)操作，非常适合大项目总量约几亿的rows某一类型(如日志，调查统计)的业务表。  
当然Innodb也不是绝对不用，用事务的项目如模拟炒股项目，我就是用Innodb的，活跃用户20多万时候，也是很轻松应付了，因此我个人也是很喜欢Innodb的，只是如果从数据库平台应用出发，我还是会首MyISAM。  
另外，可能有人会说你MyISAM无法抗太多写操作，但是我可以通过架构来弥补，说个我现有用的数据库平台容量：主从数据总量在几百T以上，每天十多亿pv的动态页面，还有几个大项目是通过数据接口方式调用未算进pv总数，(其中包括一个大项目因为初期memcached没部署,导致单台数据库每天处理9千万的查询)。而我的整体数据库服务器平均负载都在0.5-1左右。

一般来说，MyISAM适合：  
(1)做很多count 的计算；  
(2)插入不频繁，查询非常频繁；  
(3)没有事务。

InnoDB适合：  
(1)可靠性要求比较高，或者要求事务；  
(2)表更新和查询都相当的频繁，并且表锁定的机会比较大的情况指定数据引擎的创建  
让所有的灵活性成为可能的开关是提供给ANSI SQL的MySQL扩展——TYPE参数。MySQL能够让你在表格这一层指定数据库引擎，所以它们有时候也指的是table formats。下面的示例代码表明了如何创建分别使用MyISAM、ISAM和HEAP引擎的表格。要注意，创建每个表格的代码是相同的，除了最后的 TYPE参数，这一参数用来指定数据引擎。

以下为引用的内容：

复制代码代码如下:

CREATE TABLE tblMyISAM (  
id INT NOT NULL AUTO\_INCREMENT,  
PRIMARY KEY (id),  
value\_a TINYINT  
) TYPE=MyISAM  
CREATE TABLE tblISAM (  
id INT NOT NULL AUTO\_INCREMENT,  
PRIMARY KEY (id),  
value\_a TINYINT  
) TYPE=ISAM  
CREATE TABLE tblHeap (  
id INT NOT NULL AUTO\_INCREMENT,  
PRIMARY KEY (id),  
value\_a TINYINT  
) TYPE=Heap

你也可以使用ALTER TABLE命令，把原有的表格从一个引擎移动到另一个引擎。下面的代码显示了如何使用ALTER TABLE把MyISAM表格移动到InnoDB的引擎：

以下为引用的内容：

复制代码代码如下:

ALTER TABLE tblMyISAM CHANGE TYPE=InnoDB

MySQL用三步来实现这一目的。首先，这个表格的一个副本被创建。然后，任何输入数据的改变都被排入队列，同时这个副本被移动到另一个引擎。最后，任何排入队列的数据改变都被送交到新的表格里，而原来的表格被删除。

复制代码代码如下:

ALTER TABLE捷径

如果只是想把表格从ISAM更新为MyISAM，你可以使用MySQL\_convert\_table\_format命令，而不需要编写ALTER TABLE表达式。

你可以使用SHOW TABLE命令（这是MySQL对ANSI标准的另一个扩展）来确定哪个引擎在管理着特定的表格。SHOW TABLE会返回一个带有多数据列的结果集，你可以用这个结果集来查询获得所有类型的信息：数据库引擎的名称在Type字段里。下面的示例代码说明了 SHOW TABLE的用法：

复制代码代码如下:

SHOW TABLE STATUS FROM tblInnoDB

你可以用SHOW CREATE TABLE \[TableName\]来取回SHOW TABLE能够取回的信息。  
一般情况下，MySQL会默认提供多种存储引擎，可以通过下面的查看:  
（1）看你的MySQL现在已提供什么存储引擎: mysql> show engines；  
（2）看你的MySQL当前默认的存储引擎: mysql> show variables like ‘%storage\_engine%’；  
（3）你要看某个表用了什么引擎(在显示结果里参数engine后面的就表示该表当前用的存储引擎): mysql> show create table 表名；  
最后，如果你想使用没有被编译成MySQL也没有被激活的引擎，那是没有用的，MySQL不会提示这一点。而它只会给你提供一个缺省格式（MyISAM）的表格。除了使用缺省的表格格式外，还有办法让MySQL给出错误提示，但是就现在而言，如果不能肯定特定的数据库引擎是否可用的话，你要使用SHOW TABLE来检查表格格式。  
更多的选择意味着更好的性能  
用于特定表格的引擎都需要重新编译和追踪，考虑到这种的额外复杂性，为什么你还是想要使用非缺省的数据库引擎呢？答案很简单：要调整数据库来满足你的要求。  
可以肯定的是，MyISAM的确快，但是如果你的逻辑设计需要事务处理，你就可以自由使用支持事务处理的引擎。进一步讲，由于MySQL能够允许你在表格这一层应用数据库引擎，所以你可以只对需要事务处理的表格来进行性能优化，而把不需要事务处理的表格交给更加轻便的MyISAM引擎。对于 MySQL而言，灵活性才是关键。

性能测试  
所有的性能测试在：Micrisoft window xp sp2 ， Intel® Pentinum® M processor 1.6oGHz 1G 内存的电脑上测试。  
测试方法：连续提交10个query， 表记录总数：38万 ， 时间单位 s  
引擎类型MyISAMInnoDB 性能相差  
count 0.00083573.01633609  
查询主键 0.005708 0.157427.57  
查询非主键 24.01 80.37 3.348  
更新主键 0.008124 0.8183100.7  
更新非主键 0.004141 0.02625 6.338  
插入 0.004188 0.369488.21  
（1）加了索引以后，对于MyISAM查询可以加快：4 206.09733倍，对InnoDB查询加快510.72921倍，同时对MyISAM更新速度减慢为原来的1/2，InnoDB的更新速度减慢为原来的1/30。要看情况决定是否要加索引，比如不查询的log表，不要做任何的索引。  
（2）如果你的数据量是百万级别的，并且没有任何的事务处理，那么用MyISAM是性能最好的选择。  
（3）InnoDB表的大小更加的大，用MyISAM可省很多的硬盘空间。

在我们测试的这个38w的表中，表占用空间的情况如下：

引擎类型MyISAM InnoDB  
数据 53,924 KB 58,976 KB  
索引 13,640 KB 21,072 KB

占用总空间 67,564 KB 80,048 KB

另外一个176W万记录的表， 表占用空间的情况如下：  
引擎类型MyIsam InnorDB  
数据 56,166 KB 90,736 KB  
索引 67,103 KB 88,848 KB

占用总空间 123,269 KB179,584 KB

其他  
MySQL 官方对InnoDB是这样解释的：InnoDB给MySQL提供了具有提交、回滚和崩溃恢复能力的事务安全（ACID兼容）存储引擎。InnoDB锁定在行级并且也在SELECT语句提供一个Oracle风格一致的非锁定读，这些特色增加了多用户部署和性能。没有在InnoDB中扩大锁定的需要，因为在InnoDB中行级锁定适合非常小的空间。InnoDB也支持FOREIGN KEY强制。在SQL查询中，你可以自由地将InnoDB类型的表与其它MySQL的表的类型混合起来，甚至在同一个查询中也可以混合。  
InnoDB是为处理巨大数据量时的最大性能设计，它的CPU效率可能是任何其它基于磁盘的关系数据库引擎所不能匹敌的。  
InnoDB存储引擎被完全与MySQL服务器整合，InnoDB存储引擎为在主内存中缓存数据和索引而维持它自己的缓冲池。InnoDB存储它的表＆索引在一个表空间中，表空间可以包含数个文件（或原始磁盘分区）。这与MyISAM表不同，比如在MyISAM表中每个表被存在分离的文件中。InnoDB 表可以是任何尺寸，即使在文件尺寸被限制为2GB的操作系统上。  
InnoDB默认地被包含在MySQL二进制分发中。Windows Essentials installer使InnoDB成为Windows上MySQL的默认表。  
InnoDB被用来在众多需要高性能的大型数据库站点上产生。著名的Internet新闻站点Slashdot.org运行在InnoDB上。 Mytrix, Inc.在InnoDB上存储超过1TB的数据，还有一些其它站点在InnoDB上处理平均每秒800次插入/更新的.

### 10.mysql的分类分表 ###

Mysql分表分为垂直切分和水平切分

垂直切分是指数据表列的拆分，把一张列比较多的表拆分为多张表

通常我们按以下原则进行垂直拆分:

把不常用的字段单独放在一张表;

把text，blob（binary large object，二进制大对象）等大字段拆分出来放在附表中;

经常组合查询的列放在一张表中;

垂直拆分更多时候就应该在数据表设计之初就执行的步骤，然后查询的时候用jion关键起来即可。

水平拆分是指数据表行的拆分，把一张的表的数据拆成多张表来存放。

水平拆分原则

通常情况下，我们使用hash、取模等方式来进行表的拆分

比如一张有400W的用户表users，为提高其查询效率我们把其分成4张表users1，users2，users3，users4

通过用ID取模的方法把数据分散到四张表内Id%4= \[0,1,2,3\]

然后查询,更新,删除也是通过取模的方法来查询

部分业务逻辑也可以通过地区，年份等字段来进行归档拆分;

进行拆分后的表，这时我们就要约束用户查询行为。比如我们是按年来进行拆分的,这个时候在页面设计上就约束用户必须要先选择年,然后才能进行查询。

### 11.redis如何做mybatis二级缓存 ###

1.  介绍

使用mybatis时可以使用二级缓存提高查询速度，进而改善用户体验。

使用redis做mybatis的二级缓存可是内存可控<如将单独的服务器部署出来用于二级缓存>，管理方便。

1.  使用思路

2.1 配置redis.xml 设置redis服务连接各参数

2.1 在配置文件中使用 标签，设置开启二级缓存；

2.2 在mapper.xml 中使用 将cache映射到指定的RedisCacheClass类中；

2.3 映射类RedisCacheClass 实现 MyBatis包中的Cache类，并重写其中各方法；

在重写各方法体中，使用redisFactory和redis服务建立连接，将缓存的数据加载到指定的redis内存中(putObject方法)或将redis服务中的数据从缓存中读取出来(getObject方法)；

在redis服务中写入和加载数据时需要借用spring-data-redis.jar中JdkSerializationRedisSerializer.class中的序列化(serialize)和反序列化方法(deserialize),此为包中封装的redis默认的序列化方法；

2.4 映射类中的各方法重写完成后即可实现mybatis数据二级缓存到redis服务中；

1.  代码实践

3.1 配置redis.xml

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context" xmlns:task="http://www.springframework.org/schema/task" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd" >
        
        <context:annotation-config /> 
           
        <task:annotation-driven/>
        
        <context:component-scan base-package="demo.util,demo.salesorder,demo.person" />
        
        <mvc:annotation-driven />
        
        <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
            <property name="locations">
                <list>
                    <value>classpath:sysconfig/jdbc.properties</value>
                    <value>classpath:sysconfig/redis.properties</value>
                </list>
            </property>
        </bean>
        
        <bean id="defaultDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close" p:driverClassName="${jdbc.driverClassName}" p:url="${jdbc.databaseurl}" p:username="${jdbc.username}" p:password="${jdbc.password}" >
            <property name="maxActive">
                <value>${jdbc.maxActive}</value>
            </property>  
            <property name="initialSize">
                <value>${jdbc.initialSize}</value>
            </property>  
            <property name="maxWait">
                <value>${jdbc.maxWait}</value>
            </property>  
            <property name="maxIdle">
                <value>${jdbc.maxIdle}</value>
            </property>
            <property name="minIdle">
                <value>${jdbc.minIdle}</value>
            </property>
            
            <property name="timeBetweenEvictionRunsMillis">
                <value>18000000</value>
            </property>
            <property name="minEvictableIdleTimeMillis">
                <value>10800000</value>
            </property>
            <property name="validationQuery">
                <value>SELECT 1</value>
            </property>
            <property name="testOnBorrow">
                <value>true</value>
            </property>
        </bean>
        
        
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="dataSource" ref="defaultDataSource" />
            <property name="typeAliasesPackage" value="demo.salesorder,demo.person" />
             
            <property name="configLocation" value="classpath:sysconfig/mybatis-config.xml" />
        </bean>
        
        
        
        <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            <property name="basePackage" value="demo.*.data" />
            <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
        </bean>
        
        
        
        
        <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">  
            <property name="maxIdle" value="${redis.maxIdle}" />  
            <property name="maxTotal" value="${redis.maxActive}" />  
            <property name="maxWaitMillis" value="${redis.maxWait}" />  
            <property name="testOnBorrow" value="${redis.testOnBorrow}" />  
        </bean>
        
        
        <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
            <property name="hostName" value="${redis.host}" />
            <property name="port" value="${redis.port}" />
            <property name="password" value="${redis.pass}" />
            <property name="timeout" value="${redis.timeout}" />
            <property name="poolConfig" ref="poolConfig" />
        </bean>      
        
        <bean id="redisCacheTransfer" class="demo.redis.RedisCacheTransfer">
            <property name="jedisConnectionFactory" ref="jedisConnectionFactory"/>
        </bean>      
        
        <bean class="demo.util.UTF8StringBeanPostProcessor"></bean>          
    </beans>

3.2 mybatis.xml 配置开启二级缓存

<?xml version="1.0" encoding="UTF-8" ?>  
    <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
        
        <settings>
    
            
            <setting name="cacheEnabled" value="true"/>
    
            
            <setting name="lazyLoadingEnabled" value="false"/>
    
            
            <setting name="multipleResultSetsEnabled" value="true"/>
    
            
            <setting name="aggressiveLazyLoading" value="true"/>
    
        </settings>
    </configuration>

3.在mapper.xml中映射缓存类RedisCacheClass

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    
    <mapper namespace="demo.person.data.UserMapper">
    <cache type="demo.redis.cache.RedisCache"/> 
    
    <select id="getPersonList" parameterType="map" resultType="Person">
       select *    
        from person
       <where>
           1=1
           <if test="user_name!=null">
               and user_name=#{user_name}
           </if>    
       </where>
    </select>
    <insert id="addPerson" parameterType="Person" keyProperty="id" useGeneratedKeys="true">
       insert into person(
           login_id,
           user_name,
           gender,
           birthday,
           remark
       )values(
           #{login_id},
           #{user_name},
           #{gender},
           #{birthday},
           #{remark}
       )
    </insert>
    
    </mapper>

3.4 实现Mybatis中的Cache接口

Cache.class源码：

/* * Copyright 2009-2012 the original author or authors. * http://www.apache.org/licenses/LICENSE-2.0*/
    package org.apache.ibatis.cache;
    
    import java.util.concurrent.locks.ReadWriteLock;
    
    public interface Cache { 
    
      String getId();
    
      int getSize();
    
      void putObject(Object key, Object value);
    
      Object getObject(Object key);
    
      Object removeObject(Object key);
    
      void clear();
    
      ReadWriteLock getReadWriteLock();
    
    }

RedisCache.java

package demo.redis.cache;
    
    import java.util.concurrent.locks.ReadWriteLock;
    import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    import org.apache.ibatis.cache.Cache;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.data.redis.connection.jedis.JedisConnection;
    import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
    import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
    import org.springframework.data.redis.serializer.RedisSerializer;
    
    import redis.clients.jedis.exceptions.JedisConnectionException;
    
    
    public class RedisCache implements Cache //实现类
    { 
        private static final Logger logger = LoggerFactory.getLogger(RedisCache.class);
    
        private static JedisConnectionFactory jedisConnectionFactory;
    
        private final String id;
    
        /** * The {@code ReadWriteLock}. */
        private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    
        public RedisCache(final String id) { 
            if (id == null) { 
                throw new IllegalArgumentException("Cache instances require an ID");
            }
            logger.debug("MybatisRedisCache:id=" + id);
            this.id = id;
        }
    
        @Override
        public void clear()
        { 
            JedisConnection connection = null;
            try
            { 
                connection = jedisConnectionFactory.getConnection(); //连接清除数据
                connection.flushDb();
                connection.flushAll();
            }
            catch (JedisConnectionException e)
            { 
                e.printStackTrace();
            }
            finally
            { 
                if (connection != null) { 
                    connection.close();
                }
            }
        }
    
        @Override
        public String getId()
        { 
            return this.id;
        }
    
        @Override
        public Object getObject(Object key)
        { 
            Object result = null;
            JedisConnection connection = null;
            try
            { 
                connection = jedisConnectionFactory.getConnection();
                RedisSerializer<Object> serializer = new JdkSerializationRedisSerializer(); //借用spring_data_redis.jar中的JdkSerializationRedisSerializer.class
                result = serializer.deserialize(connection.get(serializer.serialize(key))); //利用其反序列化方法获取值
            }
            catch (JedisConnectionException e)
            { 
                e.printStackTrace();
            }
            finally
            { 
                if (connection != null) { 
                    connection.close();
                }
            }
            return result;
        }
    
        @Override
        public ReadWriteLock getReadWriteLock()
        { 
            return this.readWriteLock;
        }
    
        @Override
        public int getSize()
        { 
            int result = 0;
            JedisConnection connection = null;
            try
            { 
                connection = jedisConnectionFactory.getConnection();
                result = Integer.valueOf(connection.dbSize().toString());
            }
            catch (JedisConnectionException e)
            { 
                e.printStackTrace();
            }
            finally
            { 
                if (connection != null) { 
                    connection.close();
                }
            }
            return result;
        }
    
        @Override
        public void putObject(Object key, Object value)
        { 
            JedisConnection connection = null;
            try
            { 
                logger.info(">>>>>>>>>>>>>>>>>>>>>>>>putObject:"+key+"="+value);
                connection = jedisConnectionFactory.getConnection();
                RedisSerializer<Object> serializer = new JdkSerializationRedisSerializer(); //借用spring_data_redis.jar中的JdkSerializationRedisSerializer.class
                connection.set(serializer.serialize(key), serializer.serialize(value)); //利用其序列化方法将数据写入redis服务的缓存中
                
            }
            catch (JedisConnectionException e)
            { 
                e.printStackTrace();
            }
            finally
            { 
                if (connection != null) { 
                    connection.close();
                }
            }
        }
    
        @Override
        public Object removeObject(Object key)
        { 
            JedisConnection connection = null
            Object result = null;
            try
            { 
                connection = jedisConnectionFactory.getConnection();
                RedisSerializer<Object> serializer = new JdkSerializationRedisSerializer();
                result =connection.expire(serializer.serialize(key), 0);
            }
            catch (JedisConnectionException e)
            { 
                e.printStackTrace();
            }
            finally
            { 
                if (connection != null) { 
                    connection.close();
                }
            }
            return result;
        }
    
        public static void setJedisConnectionFactory(JedisConnectionFactory jedisConnectionFactory) { 
            RedisCache.jedisConnectionFactory = jedisConnectionFactory;
        }
    
    }

1.  总结

通过重写Cache类中的方法，将mybatis中默认的缓存空间映射到redis空间中。

### 13.如何创建一个线程，以及多线程编程 ###

### 14.cookie和sesssion的区别 联系 ###

### 15.JWT认证的过程 ###

### 16.谈谈你对jvm的理解 ###

### 17.谈谈你对垃圾回收机制的理解 ###

### 18.像java这种带垃圾回收机制的会不会产生内存泄漏 ###

### 19.jvm的堆栈的关系 ###

### 20.写一个栈溢出和堆溢出的情况 ###

### 21.垃圾回收算法有哪些 ###

### 22.分布式事务（锁）如何实现 ###

目前几乎很多大型网站及应用都是分布式部署的，分布式场景中的数据一致性问题一直是一个比较重要的话题。分布式的CAP理论告诉我们“任何一个分布式系统都无法同时满足一致性（Consistency）、可用性（Availability）和分区容错性（Partition tolerance），最多只能同时满足两项。”所以，很多系统在设计之初就要对这三者做出取舍。在互联网领域的绝大多数的场景中，都需要牺牲强一致性来换取系统的高可用性，系统往往只需要保证“最终一致性”，只要这个最终时间是在用户可以接受的范围内即可。

在很多场景中，我们为了保证数据的最终一致性，需要很多的技术方案来支持，比如分布式事务、分布式锁等。有的时候，我们需要保证一个方法在同一时间内只能被同一个线程执行。在单机环境中，Java中其实提供了很多并发处理相关的API，但是这些API在分布式场景中就无能为力了。也就是说单纯的Java Api并不能提供分布式锁的能力。所以针对分布式锁的实现目前有多种方案。

针对分布式锁的实现，目前比较常用的有以下几种方案：

基于数据库实现分布式锁 基于缓存（redis，memcached，tair）实现分布式锁 基于Zookeeper实现分布式锁

在分析这几种实现方案之前我们先来想一下，我们需要的分布式锁应该是怎么样的？（这里以方法锁为例，资源锁同理）

可以保证在分布式部署的应用集群中，同一个方法在同一时间只能被一台机器上的一个线程执行。

这把锁要是一把可重入锁（避免死锁）

这把锁最好是一把阻塞锁（根据业务需求考虑要不要这条）

有高可用的获取锁和释放锁功能

获取锁和释放锁的性能要好

基于数据库实现分布式锁  
基于数据库表  
要实现分布式锁，最简单的方式可能就是直接创建一张锁表，然后通过操作该表中的数据来实现了。

当我们要锁住某个方法或资源时，我们就在该表中增加一条记录，想要释放锁的时候就删除这条记录。

创建这样一张数据库表：  
![在这里插入图片描述][20181120234530517.png]

当我们想要锁住某个方法时，执行以下SQL：  
![在这里插入图片描述][20181120234558734.png]  
因为我们对method\_name做了唯一性约束，这里如果有多个请求同时提交到数据库的话，数据库会保证只有一个操作可以成功，那么我们就可以认为操作成功的那个线程获得了该方法的锁，可以执行方法体内容。

当方法执行完毕之后，想要释放锁的话，需要执行以下Sql:  
![在这里插入图片描述][20181120234616430.png]

上面这种简单的实现有以下几个问题：

1、这把锁强依赖数据库的可用性，数据库是一个单点，一旦数据库挂掉，会导致业务系统不可用。

2、这把锁没有失效时间，一旦解锁操作失败，就会导致锁记录一直在数据库中，其他线程无法再获得到锁。

3、这把锁只能是非阻塞的，因为数据的insert操作，一旦插入失败就会直接报错。没有获得锁的线程并不会进入排队队列，要想再次获得锁就要再次触发获得锁操作。

4、这把锁是非重入的，同一个线程在没有释放锁之前无法再次获得该锁。因为数据中数据已经存在了。

当然，我们也可以有其他方式解决上面的问题。

数据库是单点？搞两个数据库，数据之前双向同步。一旦挂掉快速切换到备库上。  
没有失效时间？只要做一个定时任务，每隔一定时间把数据库中的超时数据清理一遍。  
非阻塞的？搞一个while循环，直到insert成功再返回成功。  
非重入的？在数据库表中加个字段，记录当前获得锁的机器的主机信息和线程信息，那么下次再获取锁的时候先查询数据库，如果当前机器的主机信息和线程信息在数据库可以查到的话，直接把锁分配给他就可以了。  
基于数据库排他锁  
除了可以通过增删操作数据表中的记录以外，其实还可以借助数据中自带的锁来实现分布式的锁。

我们还用刚刚创建的那张数据库表。可以通过数据库的排他锁来实现分布式锁。 基于MySql的InnoDB引擎，可以使用以下方法来实现加锁操作：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dldGVyX2Ryb3A_size_16_color_FFFFFF_t_70]

在查询语句后面增加for update，数据库会在查询过程中给数据库表增加排他锁（这里再多提一句，InnoDB引擎在加锁的时候，只有通过索引进行检索的时候才会使用行级锁，否则会使用表级锁。这里我们希望使用行级锁，就要给method\_name添加索引，值得注意的是，这个索引一定要创建成唯一索引，否则会出现多个重载方法之间无法同时被访问的问题。重载方法的话建议把参数类型也加上。）。当某条记录被加上排他锁之后，其他线程无法再在该行记录上增加排他锁。

我们可以认为获得排它锁的线程即可获得分布式锁，当获取到锁之后，可以执行方法的业务逻辑，执行完方法之后，再通过以下方法解锁：

![在这里插入图片描述][20181120234725692.png]

通过connection.commit()操作来释放锁。

这种方法可以有效的解决上面提到的无法释放锁和阻塞锁的问题。

阻塞锁？ for update语句会在执行成功后立即返回，在执行失败时一直处于阻塞状态，直到成功。  
锁定之后服务宕机，无法释放？使用这种方式，服务宕机之后数据库会自己把锁释放掉。  
但是还是无法直接解决数据库单点和可重入问题。

这里还可能存在另外一个问题，虽然我们对method\_name 使用了唯一索引，并且显示使用for update来使用行级锁。但是，MySql会对查询进行优化，即便在条件中使用了索引字段，但是否使用索引来检索数据是由 MySQL 通过判断不同执行计划的代价来决定的，如果 MySQL 认为全表扫效率更高，比如对一些很小的表，它就不会使用索引，这种情况下 InnoDB 将使用表锁，而不是行锁。如果发生这种情况就悲剧了。。。

还有一个问题，就是我们要使用排他锁来进行分布式锁的lock，那么一个排他锁长时间不提交，就会占用数据库连接。一旦类似的连接变得多了，就可能把数据库连接池撑爆

总结  
总结一下使用数据库来实现分布式锁的方式，这两种方式都是依赖数据库的一张表，一种是通过表中的记录的存在情况确定当前是否有锁存在，另外一种是通过数据库的排他锁来实现分布式锁。

数据库实现分布式锁的优点

直接借助数据库，容易理解。

数据库实现分布式锁的缺点

会有各种各样的问题，在解决问题的过程中会使整个方案变得越来越复杂。

操作数据库需要一定的开销，性能问题需要考虑。

使用数据库的行级锁并不一定靠谱，尤其是当我们的锁表并不大的时候。

基于缓存实现分布式锁  
相比较于基于数据库实现分布式锁的方案来说，基于缓存来实现在性能方面会表现的更好一点。而且很多缓存是可以集群部署的，可以解决单点问题。

目前有很多成熟的缓存产品，包括Redis，memcached以及我们公司内部的Tair。

这里以Tair为例来分析下使用缓存实现分布式锁的方案。关于Redis和memcached在网络上有很多相关的文章，并且也有一些成熟的框架及算法可以直接使用。

基于Tair的实现分布式锁其实和Redis类似，其中主要的实现方式是使用TairManager.put方法来实现。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dldGVyX2Ryb3A_size_16_color_FFFFFF_t_70 1]

以上实现方式同样存在几个问题：

1、这把锁没有失效时间，一旦解锁操作失败，就会导致锁记录一直在tair中，其他线程无法再获得到锁。

2、这把锁只能是非阻塞的，无论成功还是失败都直接返回。

3、这把锁是非重入的，一个线程获得锁之后，在释放锁之前，无法再次获得该锁，因为使用到的key在tair中已经存在。无法再执行put操作。

当然，同样有方式可以解决。

没有失效时间？tair的put方法支持传入失效时间，到达时间之后数据会自动删除。  
非阻塞？while重复执行。  
非可重入？在一个线程获取到锁之后，把当前主机信息和线程信息保存起来，下次再获取之前先检查自己是不是当前锁的拥有者。  
但是，失效时间我设置多长时间为好？如何设置的失效时间太短，方法没等执行完，锁就自动释放了，那么就会产生并发问题。如果设置的时间太长，其他获取锁的线程就可能要平白的多等一段时间。这个问题使用数据库实现分布式锁同样存在

总结  
可以使用缓存来代替数据库来实现分布式锁，这个可以提供更好的性能，同时，很多缓存服务都是集群部署的，可以避免单点问题。并且很多缓存服务都提供了可以用来实现分布式锁的方法，比如Tair的put方法，redis的setnx方法等。并且，这些缓存服务也都提供了对数据的过期自动删除的支持，可以直接设置超时时间来控制锁的释放。

使用缓存实现分布式锁的优点

性能好，实现起来较为方便。

使用缓存实现分布式锁的缺点

通过超时时间来控制锁的失效时间并不是十分的靠谱。

基于Zookeeper实现分布式锁  
基于zookeeper临时有序节点可以实现的分布式锁。

大致思想即为：每个客户端对某个方法加锁时，在zookeeper上的与该方法对应的指定节点的目录下，生成一个唯一的瞬时有序节点。 判断是否获取锁的方式很简单，只需要判断有序节点中序号最小的一个。 当释放锁的时候，只需将这个瞬时节点删除即可。同时，其可以避免服务宕机导致的锁无法释放，而产生的死锁问题。

来看下Zookeeper能不能解决前面提到的问题。

锁无法释放？使用Zookeeper可以有效的解决锁无法释放的问题，因为在创建锁的时候，客户端会在ZK中创建一个临时节点，一旦客户端获取到锁之后突然挂掉（Session连接断开），那么这个临时节点就会自动删除掉。其他客户端就可以再次获得锁。

非阻塞锁？使用Zookeeper可以实现阻塞的锁，客户端可以通过在ZK中创建顺序节点，并且在节点上绑定监听器，一旦节点有变化，Zookeeper会通知客户端，客户端可以检查自己创建的节点是不是当前所有节点中序号最小的，如果是，那么自己就获取到锁，便可以执行业务逻辑了。

不可重入？使用Zookeeper也可以有效的解决不可重入的问题，客户端在创建节点的时候，把当前客户端的主机信息和线程信息直接写入到节点中，下次想要获取锁的时候和当前最小的节点中的数据比对一下就可以了。如果和自己的信息一样，那么自己直接获取到锁，如果不一样就再创建一个临时的顺序节点，参与排队。

单点问题？使用Zookeeper可以有效的解决单点问题，ZK是集群部署的，只要集群中有半数以上的机器存活，就可以对外提供服务。

可以直接使用zookeeper第三方库Curator客户端，这个客户端中封装了一个可重入的锁服务。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dldGVyX2Ryb3A_size_16_color_FFFFFF_t_70 2]

Curator提供的InterProcessMutex是分布式锁的实现。acquire方法用户获取锁，release方法用于释放锁。

使用ZK实现的分布式锁好像完全符合了本文开头我们对一个分布式锁的所有期望。但是，其实并不是，Zookeeper实现的分布式锁其实存在一个缺点，那就是性能上可能并没有缓存服务那么高。因为每次在创建锁和释放锁的过程中，都要动态创建、销毁瞬时节点来实现锁功能。ZK中创建和删除节点只能通过Leader服务器来执行，然后将数据同不到所有的Follower机器上。

其实，使用Zookeeper也有可能带来并发问题，只是并不常见而已。考虑这样的情况，由于网络抖动，客户端可ZK集群的session连接断了，那么zk以为客户端挂了，就会删除临时节点，这时候其他客户端就可以获取到分布式锁了。就可能产生并发问题。这个问题不常见是因为zk有重试机制，一旦zk集群检测不到客户端的心跳，就会重试，Curator客户端支持多种重试策略。多次重试之后还不行的话才会删除临时节点。（所以，选择一个合适的重试策略也比较重要，要在锁的粒度和并发之间找一个平衡。）

总结  
使用Zookeeper实现分布式锁的优点

有效的解决单点问题，不可重入问题，非阻塞问题以及锁无法释放的问题。实现起来较为简单。

使用Zookeeper实现分布式锁的缺点

性能上不如使用缓存实现分布式锁。 需要对ZK的原理有所了解。

三种方案的比较  
上面几种方式，哪种方式都无法做到完美。就像CAP一样，在复杂性、可靠性、性能等方面无法同时满足，所以，根据不同的应用场景选择最适合自己的才是王道。

从理解的难易程度角度（从低到高）  
数据库 > 缓存 > Zookeeper

从实现的复杂性角度（从低到高）  
Zookeeper >= 缓存 > 数据库

从性能角度（从高到低）  
缓存 > Zookeeper >= 数据库

从可靠性角度（从高到低）  
Zookeeper > 缓存 > 数据库

### 23.说说hashmap的底层实现 ###

### 24.写一个sql语句查询一个只有姓名（没有重复）和手机号（有重复）表中手机号重复的人 ###

select 姓名,电话,count(*) as '条数' from 用户表
    group by 姓名,电话
    having count(*)>1

### 25.静态方法和非静态的加载时机以及之间能不能进行调用 ###

### 26.内存泄漏和堆栈溢出的关系 ###

### 27.缓存的穿透和雪崩 ###

### 28.linux常用的一些命令 ###

### 29.Linux查看一个10g大小日志文件某一天的日志记录 ###

### 30.redis做缓存如何解决双写不一致 ###

### 31.类的加载机制和顺序 ###

### 32.springmvc的工作流程 ###

[20181120234530517.png]: /images/20220415/46d3cf0a027e4009a7026f6d6c954232.png
[20181120234558734.png]: /images/20220415/1263255d958942cab1bdb9a28ff1870e.png
[20181120234616430.png]: /images/20220415/35ea1577e1ce48fd9ad70e9cdceb7664.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dldGVyX2Ryb3A_size_16_color_FFFFFF_t_70]: /images/20220415/ccfcf787809845b39c0ed85c1404d2ef.png
[20181120234725692.png]: /images/20220415/112f2406b8c44be0a7cb66a7bcc96591.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dldGVyX2Ryb3A_size_16_color_FFFFFF_t_70 1]: /images/20220415/ddd5eebd3438448f9997b73a96d6ec10.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dldGVyX2Ryb3A_size_16_color_FFFFFF_t_70 2]: /images/20220415/11c29bc6e5ea4e2e8edcaa3c744dae63.png