【面试】吃透了这些Redis知识点，面试官一定觉得你很NB（干货 | 建议珍藏） c#自定义Attribute获取接口实现纯JS ajax 聊聊DataTable下载二进制数据的序列化反序列化和Json的序列化反序列化的重要区别

【面试】吃透了这些Redis知识点，面试官一定觉得你很NB（干货 | 建议珍藏）

万字长文，干货满满。

是数据结构而非类型

很多文章都会说，redis支持5种常用的数据类型，这其实是存在很大的歧义。redis里存的都是二进制数据，其实就是字节数组（byte[]），这些字节数据是没有数据类型的，只有把它们按照合理的格式解码后，可以变成一个字符串，整数或对象，此时才具有数据类型。

这一点必须要记住。所以任何东西只要能转化成字节数组（byte[]）的，都可以存到redis里。管你是字符串、数字、对象、图片、声音、视频、还是文件，只要变成byte数组。

因此redis里的String指的并不是字符串，它其实表示的是一种最简单的数据结构，即一个key只能对应一个value。这里的key和value都是byte数组，只不过key一般是由一个字符串转换成的byte数组，value则根据实际需要而定。

在特定情况下，对value也会有一些要求，比如要进行自增或自减操作，那value对应的byte数组必须要能被解码成一个数字才行，否则会报错。

那么List这种数据结构，其实表示一个key可以对应多个value，且value之间是有先后顺序的，value值可以重复。

Set这种数据结构，表示一个key可以对应多个value，且value之间是没有先后顺序的，value值也不可以重复。

Hash这种数据结构，表示一个key可以对应多个key-value对，此时这些key-value对之间的先后顺序一般意义不大，这是一个按照名称语义来访问的数据结构，而非位置语义。

Sorted Set这种数据结构，表示一个key可以对应多个value，value之间是有大小排序的，value值不可以重复。每个value都和一个浮点数相关联，该浮点数叫score。元素排序规则是：先按score排序，再按value排序。

相信现在你对这5种数据结构有了更清晰的认识，那它们的对应命令对你来说就是小case了。

集群带来的问题与解决思路

集群带来的好处是显而易见的，比如容量增加、处理能力增强，还可以按需要进行动态的扩容、缩容。但同时也会引入一些新的问题，至少会有下面这两个。

一是数据分配：存数据时应该放到哪个节点上，取数据时应该去哪个节点上找。二是数据移动：集群扩容，新增加节点时，该节点上的数据从何处来；集群缩容，要剔除节点时，该节点上的数据往何处去。

上面这两个问题有一个共同点就是，如何去描述和存储数据与节点的映射关系。又因为数据的位置是由key决定的，所以问题就演变为如何建立起各个key和集群所有节点的关联关系。

集群的节点是相对固定和少数的，虽然有增加节点和剔除节点。但集群里存储的key，则是完全随机、没有规律、不可预测、数量庞多，还非常琐碎。

这就好比一所大学和它的所有学生之间的关系。如果大学和学生直接挂钩的话，一定会比较混乱。现实是它们之间又加入了好几层，首先有院系，其次有专业，再者有年级，最后还有班级。经过这四层映射之后，关系就清爽很多了。

这其实是一个非常重要的结论，这个世界上没有什么问题是不能通过加入一层来解决的。如果有，那就再加入一层。计算机里也是这样的。

redis在数据和节点之间又加入了一层，把这层称为槽（slot），因该槽主要和哈希有关，又叫哈希槽。

最后变成了，节点上放的是槽，槽里放的是数据。槽解决的是粒度问题，相当于把粒度变大了，这样便于数据移动。哈希解决的是映射问题，使用key的哈希值来计算所在的槽，便于数据分配。

可以这样来理解，你的学习桌子上堆满了书，乱的很，想找到某本书非常困难。于是你买了几个大的收纳箱，把这些书按照书名的长度放入不同的收纳箱，然后把这些收纳箱放到桌子上。

这样就变成了，桌子上是收纳箱，收纳箱里是书籍。这样书籍移动很方便，搬起一个箱子就走了。寻找书籍也很方便，只要数一数书名的长度，去对应的箱子里找就行了。

其实我们也没做什么，只是买了几个箱子，按照某种规则把书装入箱子。就这么简单的举动，就彻底改变了原来一盘散沙的状况。是不是有点小小的神奇呢。

一个集群只能有16384个槽，编号0-16383。这些槽会分配给集群中的所有主节点，分配策略没有要求。可以指定哪些编号的槽分配给哪个主节点。集群会记录节点和槽的对应关系。

接下来就需要对key求哈希值，然后对16384取余，余数是几key就落入对应的槽里。slot = CRC16(key) % 16384。

以槽为单位移动数据，因为槽的数目是固定的，处理起来比较容易，这样数据移动问题就解决了。

使用哈希函数计算出key的哈希值，这样就可以算出它对应的槽，然后利用集群存储的槽和节点的映射关系查询出槽所在的节点，于是数据和节点就映射起来了，这样数据分配问题就解决了。

我想说的是，一般的人只会去学习各种技术，高手更在乎如何跳出技术，寻求一种解决方案或思路方向，顺着这个方向走下去，八九不离十能找到你想要的答案。

集群对命令操作的取舍

客户端只要和集群中的一个节点建立链接后，就可以获取到整个集群的所有节点信息。此外还会获取所有哈希槽和节点的对应关系信息，这些信息数据都会在客户端缓存起来，因为这些信息相当有用。

客户端可以向任何节点发送请求，那么拿到一个key后到底该向哪个节点发请求呢？其实就是把集群里的那套key和节点的映射关系理论搬到客户端来就行了。

所以客户端需要实现一个和集群端一样的哈希函数，先计算出key的哈希值，然后再对16384取余，这样就找到了该key对应的哈希槽，利用客户端缓存的槽和节点的对应关系信息，就可以找到该key对应的节点了。

接下来发送请求就可以了。还可以把key和节点的映射关系缓存起来，下次再请求该key时，直接就拿到了它对应的节点，不用再计算一遍了。

理论和现实总是有差距的，集群已经发生了变化，客户端的缓存还没来得及更新。肯定会出现拿到一个key向对应的节点发请求，其实这个key已经不在那个节点上了。此时这个节点应该怎么办？

这个节点可以去key实际所在的节点上拿到数据再返回给客户端，也可以直接告诉客户端key已经不在我这里了，同时附上key现在所在的节点信息，让客户端再去请求一次，类似于HTTP的302重定向。

这其实是个选择问题，也是个哲学问题。结果就是redis集群选择了后者。因此，节点只处理自己拥有的key，对于不拥有的key将返回重定向错误，即-MOVED key 127.0.0.1:6381，客户端重新向这个新节点发送请求。

所以说选择是一种哲学，也是个智慧。稍后再谈这个问题。先来看看另一个情况，和这个问题有些相同点。

redis有一种命令可以一次带多个key，如MGET，我把这些称为多key命令。这个多key命令的请求被发送到一个节点上，这里有一个潜在的问题，不知道大家有没有想到，就是这个命令里的多个key一定都位于那同一个节点上吗？

就分为两种情况了，如果多个key不在同一个节点上，此时节点只能返回重定向错误了，但是多个key完全可能位于多个不同的节点上，此时返回的重定向错误就会非常乱，所以redis集群选择不支持此种情况。

如果多个key位于同一个节点上呢，理论上是没有问题的，redis集群是否支持就和redis的版本有关系了，具体使用时自己测试一下就行了。

在这个过程中我们发现了一件颇有意义的事情，就是让一组相关的key映射到同一个节点上是非常有必要的，这样可以提高效率，通过多key命令一次获取多个值。

那么问题来了，如何给这些key起名字才能让他们落到同一个节点上，难不成都要先计算个哈希值，再取个余数，太麻烦了吧。当然不是这样了，redis已经帮我们想好了。

可以来简单推理下，要想让两个key位于同一个节点上，它们的哈希值必须要一样。要想哈希值一样，传入哈希函数的字符串必须一样。那我们只能传进去两个一模一样的字符串了，那不就变成同一个key了，后面的会覆盖前面的数据。

这里的问题是我们都是拿整个key去计算哈希值，这就导致key和参与计算哈希值的字符串耦合了，需要将它们解耦才行，就是key和参与计算哈希值的字符串有关但是又不一样。

redis基于这个原理为我们提供了方案，叫做key哈希标签。先看例子，{user1000}.following，{user1000}.followers，相信你已经看出了门道，就是仅使用Key中的位于{和}间的字符串参与计算哈希值。

这样可以保证哈希值相同，落到相同的节点上。但是key又是不同的，不会互相覆盖。使用哈希标签把一组相关的key关联了起来，问题就这样被轻松愉快地解决了。

相信你已经发现了，要解决问题靠的是巧妙的奇思妙想，而不是非要用牛逼的技术牛逼的算法。这就是小强，小而强大。

最后再来谈选择的哲学。redis的核心就是以最快的速度进行常用数据结构的key/value存取，以及围绕这些数据结构的运算。对于与核心无关的或会拖累核心的都选择弱化处理或不处理，这样做是为了保证核心的简单、快速和稳定。

其实就是在广度和深度面前，redis选择了深度。所以节点不去处理自己不拥有的key，集群不去支持多key命令。这样一方面可以快速地响应客户端，另一方面可以避免在集群内部有大量的数据传输与合并。

单线程模型

redis集群的每个节点里只有一个线程负责接受和执行所有客户端发送的请求。技术上使用多路复用I/O，使用Linux的epoll函数，这样一个线程就可以管理很多socket连接。

除此之外，选择单线程还有以下这些原因：

1、redis都是对内存的操作，速度极快（10W+QPS）

2、整体的时间主要都是消耗在了网络的传输上

3、如果使用了多线程，则需要多线程同步，这样实现起来会变的复杂

4、线程的加锁时间甚至都超过了对内存操作的时间

5、多线程上下文频繁的切换需要消耗更多的CPU时间

6、还有就是单线程天然支持原子操作，而且单线程的代码写起来更简单

事务

事务大家都知道，就是把多个操作捆绑在一起，要么都执行（成功了），要么一个也不执行（回滚了）。redis也是支持事务的，但可能和你想要的不太一样，一起来看看吧。

redis的事务可以分为两步，定义事务和执行事务。使用multi命令开启一个事务，然后把要执行的所有命令都依次排上去。这就定义好了一个事务。此时使用exec命令来执行这个事务，或使用discard命令来放弃这个事务。

你可能希望在你的事务开始前，你关心的key不想被别人操作，那么可以使用watch命令来监视这些key，如果开始执行前这些key被其它命令操作了则会取消事务的。也可以使用unwatch命令来取消对这些key的监视。

redis事务具有以下特点：

1、如果开始执行事务前出错，则所有命令都不执行

2、一旦开始，则保证所有命令一次性按顺序执行完而不被打断

3、如果执行过程中遇到错误，会继续执行下去，不会停止的

4、对于执行过程中遇到错误，是不会进行回滚的

看完这些，真想问一句话，你这能叫事务吗？很显然，这并不是我们通常认为的事务，因为它连原子性都保证不了。保证不了原子性是因为redis不支持回滚，不过它也给出了不支持的理由。

不支持回滚的理由：

1、redis认为，失败都是由命令使用不当造成

2、redis这样做，是为了保持内部实现简单快速

3、redis还认为，回滚并不能解决所有问题

哈哈，这就是霸王条款，因此，好像使用redis事务的不太多

管道

客户端和集群的交互过程是串行化阻塞式的，即客户端发送了一个命令后必须等到响应回来后才能发第二个命令，这一来一回就是一个往返时间。如果你有很多的命令，都这样一个一个的来进行，会变得很慢。

redis提供了一种管道技术，可以让客户端一次发送多个命令，期间不需要等待服务器端的响应，等所有的命令都发完了，再依次接收这些命令的全部响应。这就极大地节省了许多时间，提升了效率。

聪明的你是不是意识到了另外一个问题，多个命令就是多个key啊，这不就是上面提到的多key操作嘛，那么问题来了，你如何保证这多个key都是同一个节点上的啊，哈哈，redis集群又放弃了对管道的支持。

不过可以在客户端模拟实现，就是使用多个连接往多个节点同时发送命令，然后等待所有的节点都返回了响应，再把它们按照发送命令的顺序整理好，返回给用户代码。哎呀，好麻烦呀。

协议

简单了解下redis的协议，知道redis的数据传输格式。

发送请求的协议：

*参数个数CRLF$参数1的字节数CRLF参数1的数据CRLF...$参数N的字节数CRLF参数N的数据CRLF

例如，SET name lixinjie，实际发送的数据是：

*3\r\n$3\r\nSET\r\n$4\r\nname\r\n$8\r\nlixinjie\r\n

接受响应的协议：

单行回复，第一个字节是+

错误消息，第一个字节是-

整型数字，第一个字节是:

批量回复，第一个字节是$

多个批量回复，第一个字节是*

例如，

+OK\r\n

-ERR Operation against\r\n

:1000\r\n

$6\r\nfoobar\r\n

*2\r\n$3\r\nfoo\r\n$3\r\nbar\r\n

可见redis的协议设计的非常简单。

c#自定义Attribute获取接口实现

一般的接口实现多态

定义接口

    interface Ipeople
    {
        void say();
    }

定义实现的类

  public class man : Ipeople
    {
        public void say()
        {
            MessageBox.Show("man");
        }
    }

 public class woman : Ipeople
    {
        public void say()
        {
            MessageBox.Show("woman");
        }
    }

一般实现的方法

升级版

添加自定义（这个网上好多）

实现类

调用方法

   private static void NewMethod(string tpye)
        {
            Ipeople ib = null;
            var types = AppDomain.CurrentDomain.GetAssemblies()
                        .SelectMany(a => a.GetTypes().Where(t => t.GetInterfaces().Contains(typeof(Ipeople))))
                        .ToArray();
            foreach (var v in types)
            {
                var attribute = v.GetCustomAttributes(typeof(NameAttribute), false).FirstOrDefault();
                if (attribute != null && ((NameAttribute)attribute).Name == tpye)
                {
                    ib = (Ipeople)v.Assembly.CreateInstance(v.FullName);
                    break;
                }
            }
            if (ib != null) ib.say();
        }

这个可以避免需要维护swich语句

纯JS ajax

这是一个纯js向后台进行post请求的前端实现，未考虑考虑的问题。

1.创建对象，并兼容各种浏览器

2.请求数据，这里写了两种方法，方法一最开始写的，但是后来发现灵活性不够，于是就写了第二个方法。至于怎么传递参数到服务器，我原来的做法是拼接在请求地址后面的。其实也可以

XMLHttpReq.send(null);放在这里，就是null替换成参数，比如 user=bill&pc=hw .

3.请求数据，成功后就会执行回调函数，回调函数里会收到服务器返回的数据，在回调函数里可以对数据进行处理，完成自己的要求。

//1.创建对象
var XMLHttpReq;
var _XMLHttpReq;
 function createXMLHttpRequest() {
     try {
         XMLHttpReq = new ActiveXObject("Msxml2.XMLHTTP");//IE高版本创建XMLHTTP  
     }
     catch (E) {
         try {
             XMLHttpReq = new ActiveXObject("Microsoft.XMLHTTP");//IE低版本创建XMLHTTP  
         }
         catch (E) {
             XMLHttpReq = new XMLHttpRequest();//兼容非IE浏览器，直接创建XMLHTTP对象  
         }
     }
    _XMLHttpReq=XMLHttpReq;
 }

//向服务器进行请求，并执行调用回调函数，两种方法
//方法1  固定的回调处理  主要用在同步场景
function sendAjaxRequest(url,Sys) {
     createXMLHttpRequest();                                //创建XMLHttpRequest对象  
     XMLHttpReq.open("post", url, Sys);
     XMLHttpReq.onreadystatechange = processResponse; //指定响应函数  
     XMLHttpReq.send(null);
 }
//方法2  灵活的回调处理  同步异步皆可
 function sendAjaxRequestFunc(url, Sys, func) {
     createXMLHttpRequest();                                //创建XMLHttpRequest对象  
     XMLHttpReq.open("post", url, Sys);
     XMLHttpReq.onreadystatechange =func; //指定响应函数  
     XMLHttpReq.send(null);
 }

 //固定的回调
 var _textReponse;
 function processResponse() {
     if (XMLHttpReq.readyState == 4) {
         if (XMLHttpReq.status == 200) {
             _textReponse = XMLHttpReq.responseText;
            
         }
     }
 }

//调用1 得到结果 _textReponse  在进行处理
sendAjaxRequest('xxx/xxx', false);

//调用2
sendAjaxRequestFunc('xx/xx', false, doSth);
function doSth(){
 if (_XMLHttpReq.readyState == 4) {
           if (_XMLHttpReq.status == 200) {
              //得到结果进行处理
               var data =_XMLHttpReq.responseText;

            }
      }

}

聊聊DataTable下载

从服务器下载datatable到本地，有多种处理方式，下面介绍三种。

方式一，将datatable转为txt下载。

步骤：

1.将datatable内容下载到服务器txt中

2.将服务器的txt下载到本地来

3.删除服务器上的txt

方式二，datatable绑定到控件GridView后下载

步骤：

1.关闭控件分页功能并绑定数据到控件

2.下载控件内容到本地

3.打开控件分页功能并重新绑定数据

方式三，datatable转为Excel下载

步骤：

1.将datatable内容下载到服务器Excel中

2.将服务器中的Excel下载到本地

3.删除服务器上的Excel

如果大家有其他好的方式，不妨分享下，最好有源码，哈哈哈~~~~

//datatable转为txt 
public void DataTableToTxt(string filePath,DataTable ds) {
            FileStream fs = new FileStream(filePath, FileMode.Create);
            StreamWriter sw = new StreamWriter(fs);
            //开始写入
            for (int j=0; j < ds.Columns.Count; j++) {
                sw.Write(ds.Columns[j].ColumnName);
                sw.Write("\t");
            }
            sw.Write("\r\n");
                for (int i = 0; i < ds.Rows.Count; i++)
                {
                    for (int j = 0; j < ds.Columns.Count; j++)
                    {
                        sw.Write(ds.Rows[i][j].ToString() == "&nbsp;" ? "" : ds.Rows[i][j].ToString());
                        sw.Write("\t");
                    }
                    sw.Write("\r\n");
                }
            //清空缓冲区
            sw.Flush();
            //关闭流
            sw.Close();
            fs.Close();
        }

//下载控件内容
public void GridviewToExcel(Control control, string FileType, string FileName)
        {
            HttpContext.Current.Response.Charset = "GB2312";//设置了类型为中文防止乱码的出现 
            HttpContext.Current.Response.ContentEncoding = System.Text.Encoding.GetEncoding("gb2312");//注意编码
            HttpContext.Current.Response.AppendHeader("Content-Disposition",
                 "attachment;filename=" + HttpUtility.UrlEncode(FileName, System.Text.Encoding.UTF8).ToString());//将http头添加到输出流
            HttpContext.Current.Response.ContentType = FileType;//image/JPEG;text/HTML;image/GIF;vnd.ms-excel/msword 

            control.Page.EnableViewState = false;//服务器端只做出一次响应
            StringWriter tw = new StringWriter();//实现将信息写入字符串(下面的信息会写到这里)
            HtmlTextWriter hw = new HtmlTextWriter(tw);//用于将标记字符和文本写入到ASP.NET服务器控件输出流
            control.RenderControl(hw);//将服务器控件的内容输出到所提供的 HtmlTextWriter 对象中
       

            HttpContext.Current.Response.Write("<html><head><meta http-equiv=Content-Type content=\"text/html; charset=gb2312\">");
            HttpContext.Current.Response.Write(tw.ToString());
            HttpContext.Current.Response.Write("</body></html>");
            HttpContext.Current.Response.End();
        }
//调用
GridviewToExcel(grd, "application/vnd.ms-excel.numberformat:@", "xx.xls");

//datatable 转excel
public void DataTabletoExcel(System.Data.DataTable tmpDataTable, string strFileName)
        {
            if (tmpDataTable == null)

                return;
            int rowNum = tmpDataTable.Rows.Count;
            int columnNum = tmpDataTable.Columns.Count;
            int rowIndex = 1;
            int columnIndex = 0;
            Microsoft.Office.Interop.Excel.Application xlApp = new Microsoft.Office.Interop.Excel.Application();
            xlApp.DefaultFilePath = "";
            xlApp.DisplayAlerts = true;
            xlApp.SheetsInNewWorkbook = 1;
            Microsoft.Office.Interop.Excel.Workbook xlBook = xlApp.Workbooks.Add(true);
            Microsoft.Office.Interop.Excel.Worksheet xlSheet = (Microsoft.Office.Interop.Excel.Worksheet)xlBook.ActiveSheet;
            //将DataTable的列名导入Excel表第一行
            foreach (DataColumn dc in tmpDataTable.Columns)
            {
                columnIndex++;
                xlApp.Cells[rowIndex, columnIndex] = dc.ColumnName;

            }

            //将DataTable中的数据导入Excel中
            xlSheet.Range[xlSheet.Cells[1, 1], xlSheet.Cells[rowNum + 1, columnNum+1]].NumberFormatLocal = "@";//将格式设置成文本
            for (int i = 0; i < rowNum; i++)
            {              
                rowIndex++;
                columnIndex = 0;
                for (int j = 0; j < columnNum; j++)
                {
                    columnIndex++;
                    xlApp.Cells[rowIndex, columnIndex] = tmpDataTable.Rows[i][j].ToString();

                }

            }    
            //xlBook.SaveCopyAs(HttpUtility.UrlDecode(strFileName, System.Text.Encoding.UTF8));
            xlBook.SaveCopyAs(strFileName);
        }
DataTabletoExcel(ds, Server.MapPath("") + "\\xx.xlsx");

//文件下载 参数 文件名  文件路径 
public void DownFileToLocal(string FileName,string FilePath) {
            FileInfo fileInfo = new FileInfo(FilePath);
            HttpContext.Current.Response.Clear();
            HttpContext.Current.Response.ClearContent();
            HttpContext.Current.Response.ClearHeaders();
            HttpContext.Current.Response.AddHeader("Content-Disposition", "attachment;filename=" + FileName);
            HttpContext.Current.Response.AddHeader("Content-Length", fileInfo.Length.ToString());
            HttpContext.Current.Response.AddHeader("Content-Transfer-Encoding", "binary");
            HttpContext.Current.Response.ContentType = "application/octet-stream";
            HttpContext.Current.Response.ContentEncoding = System.Text.Encoding.GetEncoding("gb2312");
            HttpContext.Current.Response.WriteFile(fileInfo.FullName);
            HttpContext.Current.Response.Flush();
            HttpContext.Current.Response.End();
        }

二进制数据的序列化反序列化和Json的序列化反序列化的重要区别

　　前言：最近一个一个很奇怪的问题，很明白的说，就是没看懂，参照下面的代码：

 /// <summary>
        /// 反序列化对象
        /// </summary>
        /// <typeparam name="T">指定对象类型</typeparam>
        /// <param name="data">字节数组</param>
        /// <param name="isClearData">压缩完成后，是否清除待压缩字节数组里面的内容</param>
        /// <returns>指定类型的对象</returns>
        public static T DeserializeByBytes<T>(byte[] data, bool isClearData = true)
        {
            T t = default(T);
            if (data == null)
                return t;
            try
            {
                BinaryFormatter formatter = new BinaryFormatter();
                using (MemoryStream ms = new MemoryStream(data))
                {
                    t = (T)formatter.Deserialize(ms);
                }
                formatter = null;
                if (isClearData)
                    Array.Clear(data, 0, data.Length);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return t;
        }

        [Serializable]
        public class parent
        {
            public string a;

        }
        [Serializable]
        public class children : parent
        {
            public string b;
        }

        public static DeserializeBytes(byte[] byteData)
        {
            //byteData数据，其实是：{ a = "1", b = "2" } 也就是children对象得到的二进制数据流

            parent a = Program.DeserializeByBytes<parent>(byteData);

            children b = a as children;

            Console.WriteLine(JsonConvert.SerializeObject(b));

        }

　　猜猜结果是什么？

　　很奇怪？是不是，我是先反序列化成的父对象：parent对象，parent对象里没有属性b，但是我将父对象AS成子对象时，子对象children的属性b中居然有值，是不是很神奇！！！

　　同样的情况，我们使用JsonConvert的序列化和反序列化做一遍，结果如下：

var cc = new children { a = "1", b = "2" };

            var ccStr = JsonConvert.SerializeObject(cc);

            parent p = JsonConvert.DeserializeObject<parent>(ccStr);
            Console.WriteLine(JsonConvert.SerializeObject(p));
            children c = p as children;
            Console.WriteLine(JsonConvert.SerializeObject(c));

            Console.Read();