对于Django框架的会话框架的深入研究——在大型项目中使用会话技术【Django】
会话框架会话是Django（以及大多数互联网）用来跟踪站点和特定浏览器之间的“状态”的机制。会话允许您为每个浏览器存储任意数据，并在浏览器连接时将该数据提供给站点。然后，通过用于存储和检索数据的“键”引用与会话关联的每个数据项。INSTALLED_APPS = [
...
'django.contrib.sessions',
....
MIDDLEWARE = [
...
'django.contrib.sessions.middleware.SessionMiddleware',
....Django使用包含特殊会话ID的cookie来识别每个浏览器及其与站点的关联会话。默认情况下，实际会话数据存储在站点数据库中（这比将数据存储在cookie中更安全，因为它们更容易受到恶意用户的攻击）。您可以将Django配置为将会话数据存储在其他位置（缓存、文件、“安全”cookie），但默认位置是一个不错且相对安全的选项。使用会话技术可以从请求请求参数（HttpRequest作为视图的第一个参数传入）访问视图中的会话会话属性。此会话属性表示与当前用户的特定连接（或更具体地说，与当前浏览器的连接，由站点的浏览器cookie中的会话ID标识）。# Get a session value by its key (e.g. 'my_car'), raising a KeyError if the key is not present
my_car = request.session['my_car']
# Get a session value, setting a default if it is not present ('mini')
my_car = request.session.get('my_car', 'mini')
# Set a session value
request.session['my_car'] = 'mini'
# Delete a session value
del request.session['my_car']会话会话属性是一个类似于字典的对象。您可以多次读取和写入视图，并根据需要对其进行修改。您可以执行所有常规字典操作，包括清除所有数据、测试是否有密钥、循环数据等。在大多数情况下，您只需要使用标准字典API来获取和设置值。下面的代码片段显示了如何使用与当前会话（浏览器）关联的键“my_car”来获取、设置和删除一些数据。# This is detected as an update to the session, so session data is saved.
request.session['my_car'] = 'mini'
# Session object not directly modified, only data within the session. Session changes not saved!
request.session['my_car']['wheels'] = 'alloy'
# Set session as modified to force data updates/cookie to be saved.
request.session.modified = True
作为一个简单的现实世界示例，我们将更新我们的库，以告诉当前用户他们访问LocalLibrary主页的次数。打开/locallibrary/cacatalog/views。py并在下面以粗体显示更改。def index(request):
...
num_authors=Author.objects.count() # The 'all()' is implied by default.
# Number of visits to this view, as counted in the session variable.
num_visits=request.session.get('num_visits', 0)
request.session['num_visits'] = num_visits+1
# Render the HTML template index.html with the data in the context variable.
return render(
request,
'index.html',
context={'num_books':num_books,'num_instances':num_instances,'num_instances_available':num_instances_available,'num_authors':num_authors,
'num_visits':num_visits}, # num_visits appended
)
在这里，我们首先获得“num_访问的值”会话密钥。如果之前未设置，请将值设置为0。每次收到请求时，我们都会增加值并将其保存回会话（用户下次访问页面时）。然后添加num_访问变量被传递到上下文变量中的模板。<h2>Dynamic content</h2>
<p>The library has the following record counts:</p>
<ul>
<li><strong>Books:</strong> {{ num_books }}</li>
<li><strong>Copies:</strong> {{ num_instances }}</li>
<li><strong>Copies available:</strong> {{ num_instances_available }}</li>
<li><strong>Authors:</strong> {{ num_authors }}</li>
</ul>
<p>You have visited this page {{ num_visits }}{% if num_visits == 1 %} time{% else %} times{% endif %}.</p>
认证系统非常灵活。您可以根据需要从头开始构建URL、表单、视图和模板。您可以通过调用提供的API来登录用户。然而，在本文中，我们将在登录和注销页面上使用Django的“库存”身份验证视图和表单。我们仍然需要创建一些模板，但这很简单。from django.contrib.auth.models import User
# Create user and save to the database
user = User.objects.create_user('myusername', '
[email protected]', 'mypassword')
# Update fields and then save again
user.first_name = 'John'
user.last_name = 'Citizen'
user.save()
当我们查看Django管理站点时，您已经创建了第一个用户（这是一个超级用户，使用命令python manage.py createsuperuser创建）。我们的超级用户已通过身份验证并拥有所有权限，因此我们需要创建一个测试用户来代表普通网站用户。我们将使用管理站点创建本地库组和网站登录，因为这是最快的方法之一。
Linux——gdb|准备工作查看代码|r命令|断点相关命令|逐语句|逐过程|调用堆栈|冯诺依曼结构
准备工作注意makefile要加-g选项我们写一段代码，并且使用makefile?输入gdb 可执行程序：进入调试模式?输入quit退出gdb模式查看代码??l 0：从第0行开始显示代码若想继续显示后面的代码，我们不断按回车即可，因为gdb具有记忆功能，当未输入指令时，按回车它会执行最近一次的指令 r命令r：开始调试，如果没有设置断点，就直接运行结束此时未设置断点，直接出结果了，相当于vs下按F?5断点相关命令b 行号：可以打断点?查看断点 info b注意第一列num，删断点时要用到?d num：去断点?有断点之后输入r，就可以跑到断点处逐语句|逐过程|调用堆栈 n:逐过程（等同于vsF10）p 变量名：打印变量内容s：逐语句bt：查看当前调用堆栈finish：将当前函数跑完，就停下来display 变量名：长显示变量undisplay ：取消长显示until：跳转到指定行，对一个函数局部跳转c或continue：运行至下一个断点处停下来disa 序号：关闭断点enable：打开断点断点在第22行，输入n没有进入函数，直接来到下一条语句，第23行语句是回车?当我们想查看函数里，result值是多少时，输入p result，可直接查看再次按r会重新调试输入s会进入函数里面 输入bt可查看调用堆栈当进入函数后又想退出，输入finish即可，之后我们发现函数已经跑完了，我们可以看到结果4950，此时我们输入bt，发现已经没有刚才函数的栈帧了 进入循环 如果想查看当前i时多少，输入display i 如果想查看当前地址输入p &i,p是打印只显示一次 如果想取消长显示，输入undisplay i是不能取消的 我们在设置常显示值之后，前面是有编号的，undisplay 编号 取消常显示 此时就看不到i了 若想跳出循环，这里直接想跳到15行 until 15，此时结果已经出来.如果想由一个断点直接跳到下一个断点修改一下程序，便于观察 输入c直接跳转 这行是显示断电的打开与关闭状态 disa 序号：可关闭该序号断点 输入disa关闭所有断点 enable可打开断点 也可加序号冯诺依曼结构 ?cpu读取数据（数据+代码），都是要从内存中读取，站在数据的角度骂我们人为cpu不和外设直接交互cpu要处理数据，需要先将外设中的数据，加载到内存，站在数据的角度，外设之和内存打交道程序要运行，必须先被加载到内存中，因为体系结构的特点决定 管理：先描述，在组织操作系统要给用户提供一个稳定，安全，简单的执行环境习题 1冯诺依曼体系结构中数据输入设备的有？A DA.键盘B.显示器C.内存D.磁盘注意：内存不是输入设备习题2 不属于冯诺依曼体系结构必要组成部分是：BA.CPUB.CacheC.RAMD.ROM CPU ? 运算器与控制器，Cache 缓存（一种技术）， RAM 内存（存储器），ROM 磁盘（输入输出设备） 冯·诺依曼 提出了计算机制造的三个基本原则，即采用二进制逻辑、程序存储执行以及计算机由五个部分组成（ 运算器 、 控制器 、 存储器 、 输入设备 、 输出设备 ）习题3 冯诺依曼体系结构计算机的基本原理是?A.信息存储B.存储智能C.数字控制D.存储程序和程序控制D计算机就是为了完成指定的数据处理，而通过指令按指定流程完成指定功能，指令的合集就是一段程序。说白了计算机就是按照指定的指令执行流程完成对指定数据的处理习题4 操作系统的主要功能有（A）A.控制和管理计算机系统软硬件资源B.对汇编语言，高级语言和甚高级语言程序进行翻译C.管理用各种语言编写的源程序D.管理数据库文件操作系统的定位就是控制和管理计算机上软硬件资源让计算机更加好用，因此A选项是 正确的对汇编语言，高级语言和甚高级语言程序进行翻译，这个功能是编译器的功能，将高级语言解释为机器指令能够被机器识别执行。因此B选项不正确，这不是操作系统的主要功能，而是一个外部应用的主要功能源程序以及数据库文件都是存储在磁盘上的，这是操作系统中，文件系统管理部分的主要功能，因此C和D选项不正确。习题5 下面关于系统调用的描述中,错误的是(B)A.系统调用把应用程序的请求传输给系统内核执行B.系统调用函数的执行过程应该是在用户态C.利用系统调用能够得到操作系统提供的多种服务D.是操作系统提供给编程人员的接口E.系统调用给用户屏蔽了设备访问的细节F.系统调用保护了一些只能在内核模式执行的操作指令系统调用是操作系统向上层提供的用于访问内核特定功能的接口。A正确，应用程序通过系统调用将自己需要完成的功能传递给内核，进行执行完成B错误，系统调用的运行过程是在内核态完成的，操作系统并不允许用户直接访问内核，也就是说用户运行态并不满足访问内核的权限。C正确，因为系统调用就是想上层提供用于完成特定内核服务或功能的。D正确，E正确，用户只需要将自己的请求以及数据通过系统调用接口传递给内核，内核中完成对应的设备访问过程，最终返回结果正确F正确，系统向上层提供系统调用接口用于访问内核服务或功能的很大原因也是因为这样可以最大限度的保护内核的稳定运行。习题6 下面的函数哪个是系统调用而不是库函数()？A.printfB.scanfC.fgetcD.readE.print_sF.scan_s库函数是用户对系统调用接口的进一步封装接口printf函数是glibc中封装的用于实现格式化输出的接口scanf函数是glibc中封装的用于实现格式化输入的接口fgetc函数是glibc中封装的用于实现从输入流中获取字符的接口read是系统提供的用于从输入设备获取数据的接口print_s以及scan_s这两个函数不存在，至少在C语言的常见典型的跨平台移植代码库中不存在
带你六分钟了解CleanMyMac X详细功能讲解
电脑明明有100G，但是只剩下几个G，明明已经清理了很多，但是还是没有释放出内存，怎么办？可以试试CleanMyMac X，怎么使用呢？来看看吧！CleanMyMac X是一款颇受欢迎的专业清理软件，拥有十多项强大的功能，可以进行系统清理、清空废纸篓、清除大旧型文件、程序卸载、除恶意软件、系统维护等等，并且这款清理软件操作简易，非常好上手，特别适用于那些刚入手苹果系统的宝宝们。 虽然说mac平时不需要大量维护进行清理但是有一些临时文件、软件残留、系统缓存、下载安装包还是会日积月累降低mac的速度，还占有大量的储存空间下面其他文件，有时候占用了十几合计，甚至上百G的空间。而且还删不了他。这里面往往是一些无用的临时文件和应用缓存。我们可以借助第三方清理工具来清理这些垃圾文件—cleanmymac x2023!转载于:https://blog.csdn.net/CaiHuaZeiPoJie/article/details/128258522下面，小编就带大家简单认识一下如何利用CleanMyMac X这款软件进行系统清理。打开已经安装好的软件后，会显示以下窗口。在左侧工具栏中，我们不难发现有许多功能，共分成了五项主题，分别是“清理”、“保护”、“速度”、“应用程序”以及“文件”。在每个对应的主题下，我们能完成相关的操作。顾名思义，在“清理”字样的下方，我们能够利用CleanMyMac X完成基础的系统清理工作。这款清理软件采用的是一键智能清理，操作起来特别方便，我们只需要点击界面下方的“扫描”，就可以了解到需要清理的内容。我们可以轻轻点击界面上的“查看详情”来查看需要移除的垃圾内容。点击了“查看详情”之后，我们会看到系统垃圾的文件类型以及大小，这时候我们可以根据自我需求勾选需要被清理的内容。勾选完毕之后，我们可以通过点击“返回摘要”返回到之前的扫描界面上，并点击下方的“运行”进行最后的清理工作。最终我们能看到清理后的结果，例如清理了多大的垃圾，以及可以点击界面下方的“查看日志”。在清理日志中，我们可以清楚地看到具体哪些内容被清理了，并且有对应的大小，非常方便大家查看是否有遗忘想要清理的内容。这样简单的系统清理工作就大功告成啦，不知道你有没有看会呢？打开CleanMyMac X软件主界面，点击左侧的“空间透镜”菜单，在界面右侧就会显示空间透镜的主要功能：它能够对Mac内部空间进行全面扫描，对文件夹和文件进行视觉大小比较，方便用户快速决策清理，同时保证了用户个人的隐私安全，如果需要扫描全部磁盘空间的话，还需要获得用户的授权访问，具体如下图。点击黄色的“授权访问”按钮，会打开如下提示界面，提示用户需要授权CleanMyMac访问全部磁盘的权限。打开Mac的设置界面，然后点击“安全性与隐私”选项，进入“隐私”选项，然后在左侧的选项中，拉到最下方，选择“完全磁盘访问权限”，然后再点击下方的“点按锁按钮以进行更改”，操作步骤如下图箭头，最后输入Mac电脑用户名和密码，解锁权限修改功能。解锁以后，点击右侧加号按钮，添加“CleanMyMac”应用程序，即表示授予CleanMyMac软件全盘访问的权限，然后再点击下方“点按锁按钮以防止再次更改”按钮，锁住权限修改功能即可。此时回到CleanMyMac软件中，会发现提示界面变成了下图所示界面，表示权限修改成功。开始使用1.点击“扫描”按钮，开始全盘文件和文件夹扫描，扫描过程如下图，耐心等待扫描完成即可。扫描完成后，结果如下图，可以看到，每个文件夹所占用的内存空间大小都可以直接显示出来，在左侧中是以列表的直观形式进行展现，在右侧是以球形的形式进行展现。点开左侧的列表项可以展开具体的详细内容，比如点击左侧第一项的应用程序，将展示出Mac系统上各个应用程序以及其相对应的占用空间，如下图，非常的直观。勾选上需要清除的文件或文件夹，然后点击“移除”，可以对所选的文件进行清理删除。CleanMyMac X全新绿色版下载如下:https://wm.makeding.com/iclk/?zoneid=49983?Mac清理软件CleanMyMac X的出现成功的吸引了Mac用户的注意，CleanMyMac X是2018年发布的，深受许多Mac用户的青睐。
hibernate的一级缓存
hibernate的一级缓存就是指Session缓存（1）hibernate的一级缓存默认打开的（2）hibernate的一级缓存使用范围，是session范围，从session创建到session关闭范围（3）hibernate的一级缓存中，存储数据必须 持久态数据验证一级缓存的存在第一步执行get方法之后，发送sql语句查询数据库第二个执行get方法之后，没有发送sql语句，是直接从一级缓存里面查找内容，这样就省了很多时间。Hibernate一级缓存执行过程：Hibernate一级缓存特性：?持久态自动更新数据库不需要用session的update方法就可以对数据库进行更新了。持久态自动更新的过程：在创建session的时候会出现一个一级缓存，同时也会产生一个快照区（副本），执行session.get方法时先在一级缓存区找有没有这个数据如果没有就去数据库查询，然后把持久态对象放到一级缓存和快照区，然后通过set*来修改持久态的值和一级缓存中的内容，但是不会修改快照区的内容，提交事物时进行比较，比较一级缓存区的内容和快照区的内容是否相同，不相同就把一级缓存中的内容更新到数据库，相同就不进行操作。
【面试】一篇文章帮你彻底清楚"java"必考面试题
数据库三范式是什么?? 第一范式（1NF）：字段具有原子性,不可再分。所有关系型数据库系统都满足第一范式） 数据库表中的字段都是单一属性的，不可再分。例如，姓名字段，其中的姓和名必须作为一 个整体，无法区分哪部分是姓，哪部分是名，如果要区分出姓和名，必须设计成两个独立的 字段。 第二范式（2NF）：第二范式（2NF）是在第一范式（1NF）的基础上建立起来的，即满足 第二范式（2NF）必须先满足第一范式（1NF）。要求数据库表中的每个实例或行必须可以 被惟一地区分。通常需要为表加上一个列，以存储各个实例的惟一标识。这个惟一属性列被 称为主关键字或主键。第二范式（2NF）要求实体的属性完全依赖于主关键字。所谓完全依 赖是指不能存在仅依赖主关键字一部分的属性，如果存在，那么这个属性和主关键字的这一 部分应该分离出来形成一个新的实体，新实体与原实体之间是一对多的关系。为实现区分通 常需要为表加上一个列，以存储各个实例的惟一标识。简而言之，第二范式就是非主属性非 部分依赖于主关键字。 第三范式的要求如下：满足第三范式（3NF）必须先满足第二范式（2NF）。简而言之，第三范式（3NF）要求一个数据库表中不包含已在其它表中已包含的非主关键字信息。所以 第三范式具有如下特征： 1，每一列只有一个值 。 2，每一行都能区分。 3，每一个表都不包含其他表已经包含 的非主关键字信息。例如，帖子表中只能出现发帖人的 id，而不能出现发帖人的 id，还同时出现发帖人姓名， 否则，只要出现同一发帖人 id 的所有记录，它们中的姓名部分都必须严格保持一致，这就 是数据冗余。???说出一些数据库优化方面的经验?? 用 PreparedStatement 一般来说比 Statement 性能高：一个 sql 发给服务器执行，步骤：语法 检查、语义分析， 编译，缓存 “inertintouservalues(1,1,1)”->二进制? “inertintouservalues(2,2,2)”->二进制? “inertintouservalues(?,?,?)”->二进制 有外键约束会影响插入和删除性能，如果程序能够保证数据的完整性，那在设计数据库时就 去掉外键。（比喻：就好比免检产品，就是为了提高效率，充分相信产品的制造商）?（对于 hibernate 来说，就应该有一个变化：empleyee->Deptment 对象，现在设计时就成了 employee_>deptid）union 和 unionall 有什么不同?? UNION 在进行表链接后会筛选掉重复的记录，所以在表链接后会对所产生的结果集进 行排序运算，删除重复的记录再返回结果。实际大部分应用中是不会产生重复的记录，最常 见的是过程表与历史表 UNION。而 UNIONALL 只是简单的将两个结果合并后就返回。这样，如果返回的两个结果集中有 重复的数据，那么返回的结果集就会包含重复的数据了。从效率上说，UNIONALL 要比 UNION 快很多，所以，如果可以确认合并的两个结果集 中不包含重复的数据的话，那么就使用 UNIONALL。分页语句?取出 sql 表中第 31 到 40 的记录（以自动增长 ID 为主键）??sql server 方案 1：
select top 10 * from t where id not in(select top 30 id from t order by id)ordeby id
sql server 方案 2：
select top 10 * from t where id in(select top 40 id fromt order by id) order by id desc
mysql 方案：select * from t order by id limit 30,10
oracle 方案：select * from(select rownum r,*from t where r<=40)where r >30?所有部门之间的比赛组合? 一个叫 department 的表，里面只有一个字段 name,一共有 4 条纪录，分别是 a,b,c,d,对应四个 球对，现在四个球对进行比赛，用一条 sql 语句显示所有可能的比赛组合.select a.name,b.name from team a,team b wherea.name< b.nameClass.forName 的作用?为什么要用? 按参数中指定的字符串形式的类名去搜索并加载相应的类，如果该类字节码已经被加载 过，则返回代表该字节码的 Class 实例对象，否则，按类加载器的委托机制去搜索和加载该类，如果所有的类加载器都无法加载到该类，则抛出 ClassNotFoundException。加载完这个 Class 字节码后，接着就可以使用 Class 字节码的 newInstance 方法去创建该类的实例对象了。有时候，我们程序中所有使用的具体类名在设计时（即开发时）无法确定，只有程序运行时 才能确定，这时候就需要使用 Class.forName 去动态加载该类，这个类名通常是在配置文件 中配置的，例如，spring 的 ioc 中每次依赖注入的具体类就是这样配置的，jdbc 的驱动类名 通常也是通过配置文件来配置的，以便在产品交付使用后不用修改源程序就可以更换驱动类 名。?大数据量下的分页解决方法。? 最好的办法是利用 sql 语句进行分页，这样每次查询出的结果集中就只包含某页的数据 内容。在?sql 语句无法实现分页的情况下，可以考虑对大的结果集通过游标定位方式来获取 某页的数据。说出数据连接池的工作机制是什么?? J2EE 服务器启动时会建立一定数量的池连接，并一 直维持不少于此数目的池连接。客户端 程序需要连接时，池驱动程序会返回一个未使用的池连接并将其表记为忙。如果当前没有空 闲连接，池驱动程序就新建一定数量的连接，新建连接的数量有配置参数决定。当使用的池 连接调用完成后，池驱动程序将此连接表记为空闲，其他调用就可以使用这个连接。实现方式，返回的 Connection 是原始 Connection 的代理，代理 Connection 的 close 方法不是 真正关连接，而是把它代理的 Connection 对象还回到连接池中。??为什么要用 ORM? 和 JDBC 有何不一样? ?orm 是一种思想，就是把 object 转变成数据库中的记录，或者把数据库中的记录转变成 object，我们可以用 jdbc 来实现这种思想，其实，如果我们的项目是严格按照 oop 方式编 写的话，我们的 jdbc 程序不管是有意还是无意，就已经在实现 orm 的工作了。现在有许多 orm 工具，它们底层调用 jdbc 来实现了 orm 工作，我们直接使用这些工具，就 省去了直接使用 jdbc 的繁琐细节，提高了开发效率，现在用的较多的 orm 工具是 hibernate。也听说一些其他 orm 工具，如 toplink,ojb 等。XML 部分xml 有哪些解析技术?区别是什么?? 有 DOM,SAX,STAX 等 DOM:处理大型文件时其性能下降的非常厉害。这个问题是由 DOM 的树结构所造成的，这种结构占用的内存较多，而且 DOM 必须在解析文件之前把整个文档装入内存,适合对 XML 的随机访问 SAX:不现于 DOM,SAX 是事件驱动型的 XML 解析方式。它顺序读取 XML 文 件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结 束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理 XML 文件，适合 对 XML 的顺序访问 STAX:StreamingAPI forXML(StAX)?你在项目中用到了 xml 技术的哪些方面?如何实现的? 用到了数据存贮，信息配置两方面。在做数据交换平台时，将不能数据源的数据组装成 XML 文件，然后将 XML 文件压缩打包加密后通过网络传送给接收者，接收解密与解压缩 后再同 XML 文件中还原相关信息进行处理。在做软件配置时，利用 XML 可以很方便的进 行，软件的各种配置参数都存贮在 XML 文件中。?XML 文档定义有几种形式？它们之间有何本质区别？解析 XML 文档有哪几种方式？ a: 两种形式 dtd schema，b: 本质区别:schema 本身是 xml 的，可以被 XML 解析器解析(这 也是从 DTD 上发展 schema 的根本目的)，c:有 DOM,SAX,STAX 等 DOM:处理大型文件时其性能下降的非常厉害。这个问题是由 DOM 的树结构所造成的，这 种结构占用的内存较多，而且 DOM 必须在解析文件之前把整个文档装入内存,适合对 XML 的随机访问。?? SAX:不现于 DOM,SAX 是事件驱动型的 XML 解析方式。它顺序读取 XML 文件，不需要一 次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触 发一个事件，用户通过在其回调事件中写入处理代码来处理 XML 文件，适合对 XML 的顺 序访问。?流行的框架与新技术谈谈你对 SSH 的理解 ?典型的 JavaEE 三层结构，分为表现层、中间层（业务逻辑层）和数据服务层。三层体系将 业务规则、数据访问及合法性校验等工作放在中间层处理。客户端不直接与数据库交互，而 是通过组件与中间层建立连接，再由中间层与数据库交互。? 表现层是传统的 JSP 技术，自 1999 年问世以来，经过多年的发展，其广泛的应用和稳定的 表现，为其作为表现层技术打下了坚实的基础。 ?中间层采用的是流行的 Spring+Hibernate，为了将控制层与业务逻辑层分离，又细分为以下 几种。 ?Web 层，就是 MVC 模式里面的“C”（controller），负责控制业务逻辑层与表现层的交互， 调用业务逻辑层，并将业务数据返回给表现层作组织表现，该系统的 MVC 框架采用 Struts。 ?Service 层（就是业务逻辑层），负责实现业务逻辑。业务逻辑层以 DAO 层为基础，通过对 DAO 组件的正面模式包装，完成系统所要求的业务逻辑。? DAO 层，负责与持久化对象交互。该层封装了数据的增、删、查、改的操作。PO，持久化对象。通过实体关系映射工具将关系型数据库的数据映射成对象，很方便地实 现以面向对象方式操作数据库，该系统采用 Hibernate 作为 ORM 框架。? Spring 的作用贯穿了整个中间层，将 Web 层、Service 层、DAO 层及 PO 无缝整合，其数据 服务层用来存放数据。??谈谈你对 Hibernate 的理解。? 1. 面向对象设计的软件内部运行过程可以理解成就是在不断创建各种新对象、建立对象之 间的关系，调用对象的方法来改变各个对象的状态和对象消亡的过程，不管程序运行的过程和操作怎么样，本质上都是要得到一个结果，程序上一个时刻和下一个时刻的运行结果的差 异就表现在内存中的对象状态发生了变化。? 2.为了在关机和内存空间不够的状况下，保持程序的运行状态，需要将内存中的对象状态保 存到持久化设备和从持久化设备中恢复出对象的状态，通常都是保存到关系数据库来保存大 量对象信息。从 Java 程序的运行功能上来讲，保存对象状态的功能相比系统运行的其他功 能来说，应该是一个很不起眼的附属功能，java 采用 jdbc 来实现这个功能，这个不起眼的 功能却要编写大量的代码，而做的事情仅仅是保存对象和恢复对象，并且那些大量的 jdbc 代码并没有什么技术含量，基本上是采用一套例行公事的标准代码模板来编写，是一种苦活 和重复性的工作。 3.通过数据库保存 java 程序运行时产生的对象和恢复对象，其实就是实现了 java 对象与关 系数据库记录的映射关系，称为 ORM（即 Object Relation Mapping），人们可以通过封装 JDBC 代码来实现了这种功能，封装出来的产品称之为 ORM 框架，Hibernate 就是其中的一 种流行 ORM 框架。使用 Hibernate 框架，不用写 JDBC 代码，仅仅是调用一个 save 方法， 就可以将对象保存到关系数据库中，仅仅是调用一个 get 方法，就可以从数据库中加载出一 个对象。? 4.使用 Hibernate 的基本流程是：配置 Configuration 对象、产生 SessionFactory、创建 session 对象，启动事务，完成 CRUD 操作，提交事务，关闭 session。 5.使用 Hibernate 时，先要配置 hibernate.cfg.xml 文件，其中配置数据库连接信息和方言等， 还要为每个实体配置相应的 hbm.xml 文件，hibernate.cfg.xml 文件中需要登记每个 hbm.xml 文件。 ?6.在应用 Hibernate 时，重点要了解 Session 的缓存原理，级联，延迟加载和 hql 查询。AOP 的作用。??面向切面编程（AOP）提供另外一种角度来思考程序结构，通过这种方式弥补了面向对象编 程（OOP）的不足 。除了类（classes）以外，AOP 提供了切面。切面对关注点进行模块化，例如横切多个类型和 对象的事务管理 。Spring的一个关键的组件就是AOP框架，可以自由选择是否使用AOP提供声明式企业服务， 特别是为了替代 EJB 声明式服务。最重要的服务是声明性事务管理，这个服务建立在 Spring 的抽象事物管理之上?。允许用户实现自定义切面，用 AOP 来完善 OOP 的使用.可以把 SpringAOP 看作是对 Spring 的一种增强 。你对 Spring 的理解。?1.Spring 实现了工厂模式的工厂类（在这里有必要解释清楚什么是工厂模式），这个类名为 BeanFactory（实际上是一个接口），在程序中通常 BeanFactory 的子类 ApplicationContext。?Spring 相当于一个大的工厂类，在其配置文件中通过元素配置用于创建实例对象的类 名和实例对象的属性。?2.Spring 提供了对 IOC 良好支持，IOC 是一种编程思想，是一种架构艺术，利用这种思想 可以很好地实现模块之间的解耦。IOC 也称为 DI（DepencyInjection），什么叫依赖注入呢？?3.Spring 提供了对 AOP 技术的良好封装， AOP 称为面向切面编程，就是系统中有很多各 不相干的类的方法，在这些众多方法中要加入某种系统功能的代码，例如，加入日志，加入 权限判断，加入异常处理，这种应用称为 AOP。实现 AOP 功能采用的是代理技术，客户端 程序不再调用目标，而调用代理类，代理类与目标类对外具有相同的方法声明，有两种方式 可以实现相同的方法声明，一是实现相同的接口，二是作为目标的子类在， JDK 中采用 Proxy 类产生动态代理的方式为某个接口生成实现类，如果要为某个类生成子类，则可以用 CGLI B。在生成的代理类的方法中加入系统功能和调用目标类的相应方法，系统功能的代理以 Advice 对象进行提供，显然要创建出代理对象，至少需要目标类和 Advice 类。spring 提供 了这种支持，只需要在 spring 配置文件中配置这两个元素即可实现代理和 aop 功能。hibernate 中的 update()和 saveOrUpdate()的区别，session 的 load()和 get()的区别。?简述 Hibernate 和 JDBC 的优缺点? 如何书写一个 one tomany 配置文件.Hibernate 的应用（Hibernate 的结构）？? //首先获得 SessionFactory 的对象
SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
//然后获得 session 的对象
Session session = sessionFactory.openSession();
//其次获得 Transaction 的对象
Transaction tx = session.beginTransaction();
//执行相关的数据库操作:增,删,改,查 session.save(user);
//增加,user 是 User 类的对象 session.delete(user);
//删除 session.update(user);
//更新 Queryquery=session.createQuery(“fromUser”);
//查询 List list =query.list();
//提交事务 tx.commit();
//如果有异常,我们还要作事务的回滚,恢复到操作之前
tx.rollback();
//最后还要关闭 session,释放资源
session.close()Hibernate 有哪 5 个核心接口？?? Configuration 接口：配置 Hibernate，根据其启动 hibernate，创建 SessionFactory 对象；? SessionFactory 接口：初始化 Hibernate，充当数据存储源的代理，创建 session 对象， sessionFactory 是线程安全的，意味着它的同一个实例可以被应用的多个线程共享，是重量 级、二级缓存；? Session 接口：负责保存、更新、删除、加载和查询对象，是线程不安全的，避免多个 线程共享同一个 session，是轻量级、一级缓存； Transaction 接口：管理事务；? Query 和 Criteria 接口：执行数据库的查询。iBatis 与 Hibernate 有什么不同? 相同点：屏蔽 jdbcapi 的底层访问细节，使用我们不用与 jdbcapi 打交道，就可以访问数据。jdbcapi 编程流程固定，还将 sql 语句与 java 代码混杂在了一起，经常需要拼凑 sql 语句，细 节很繁琐。? ibatis 的好处：屏蔽 jdbc api 的底层访问细节；将 sql 语句与 java 代码进行分离;提供了将结果集自动封装称为实体对象和对象的集合的功能，queryForList 返回对象集合，用 queryForObject 返回单个对象；提供了自动将实体对象的属性传递给 sql 语句的参数。 ?Hibernate是一个全自动的orm映射工具，它可以自动生成sql语句,ibatis需要我们自己在xml 配置文件中写 sql 语句，hibernate 要比 ibatis 功能负责和强大很多。因为 hibernate 自动生成 sql 语句，我们无法控制该语句，我们就无法去写特定的高效率的 sql。对于一些不太复杂的 sql 查询，hibernate 可以很好帮我们完成，但是，对于特别复杂的查询，hibernate 就很难适 应了，这时候用 ibatis 就是不错的选择，因为 ibatis 还是由我们自己写 sql 语句。?写 Hibernate 的一对多和多对一双向关联的 orm 配置??什么是 ORM？? 对象关系映射（Object—Relational Mapping，简称 ORM）是一种为了解决面向对象与 面向关系数据库存在的互不匹配的现象的技术；简单的说，ORM 是通过使用描述对象和数 据库之间映射的元数据，将 java 程序中的对象自动持久化到关系数据库中；本质上就是将 数据从一种形式转换到另外一种形式。?hibernate 的 inverse 属性的作用? 解决方案一，按照 Object[]数据取出数据，然后自己组 bean? 解决方案二，对每个表的 bean 写构造函数，比如表一要查出 field1,field2 两个字段，那么有 一个构造函数就是 Bean(type1filed1,type2 field2) ，然后在 hql 里面就可以直接生成这个 bean 了。?在 DAO 中如何体现 DAO 设计模式?? 解决方案一，按照 Object[]数据取出数据，然后自己组 bean? 解决方案二，对每个表的 bean 写构造函数，比如表一要查出 field1,field2 两个字段，那么有 一个构造函数就是 Bean(type1filed1,type2 field2) ，然后在 hql 里面就可以直接生成这个 bean 了。?spring+Hibernate 中委托方案怎么配置? 解决方案一，按照 Object[]数据取出数据，然后自己组 bean? 解决方案二，对每个表的 bean 写构造函数，比如表一要查出 field1,field2 两个字段，那么有 一个构造函数就是 Bean(type1filed1,type2 field2) ，然后在 hql 里面就可以直接生成这个 bean 了。?hibernate 进行多表查询每表中各取几个字段，就是说查询出的结果集没有一个实体 类与之对应如何解决 ？解决方案一，按照 Object[]数据取出数据，然后自己组 bean?解决方案二，对每个表的 bean 写构造函数，比如表一要查出 field1,field2 两个字段，那么有 一个构造函数就是 Bean(type1filed1,type2 field2) ，然后在 hql 里面就可以直接生成这个 bean 了。介绍一下 Hibernate 的二级缓存? 按照以下思路来回答：（1）首先说清楚什么是缓存，（2）再说有了 hibernate 的 Session 就 是一级缓存，即有了一级缓存，为什么还要有二级缓存，（3）最后再说如何配置 Hibernate 的二级缓存。? （1）缓存就是把以前从数据库中查询出来和使用过的对象保存在内存中（一个数据结构中）， 这个数据结构通常是类似于 Hashmap，当以后要使用某个对象时，先查询缓存中是否有这个 对象，如果有则使用缓存中的对象，如果没有则去查询数据库，并将查询出来的对象保存在 缓存中，以便下次使用。 （2）Hibernate 的 Session 就是一种缓存，我们通常将之称为 Hibernate 的一级缓存，当想使 用session从数据库中查询出一个对象时， Session也是先从自己内部查看是否存在这个对象， 存在则直接返回，不存在才去访问数据库，并将查询的结果保存在自己内部。由于 Session 代表一次会话过程，一个 Session 与一个数据库连接相关连，所以 Session 最好不要长时间 保持打开，通常仅用于一个事务当中，在事务结束时就应关闭。并且 Session 是线程不安全的，被多个线程共享时容易出现问题。通常只有那种全局意义上的缓存才是真正的缓存应用， 才有较大的缓存价值，因此，Hibernate 的 Session 这一级缓存的缓存作用并不明显，应用价 值不大。Hibernate 的二级缓存就是要为 Hibernate 配置一种全局缓存，让多个线程和多个事 务都可以共享这个缓存。我们希望的是一个人使用过，其他人也可以使用，session 没有这 种效果。 （3）二级缓存是独立于 Hibernate 的软件部件，属于第三方的产品，多个厂商和组织都提供 有缓存产品，例如，EHCache 和 OSCache 等等。在 Hibernate 中使用二级缓存，首先就要在 hibernate.cfg.xml 配置文件中配置使用哪个厂家的缓存产品，接着需要配置该缓存产品自己 的配置文件，最后要配置 Hibernate 中的哪些实体对象要纳入到二级缓存的管理中。明白了 二级缓存原理和有了这个思路后，很容易配置起 Hibernate 的二级缓存。扩展知识：一个 SessionFactory 可以关联一个二级缓存，也即一个二级缓存只能负责缓存一个数据库中的数 据，当使用 Hibernate 的二级缓存后，注意不要有其他的应用或 SessionFactory 来更改当前 数据库中的数据，这样缓存的数据就会与数据库中的实际数据不一致。?解释 Spring 的依赖注入? 给一个 Bean 的 message 属性, 字符串类型, 注入值为 "Hello"的 XML 配置文件该怎么写??Jdo 是什么?? JDO 是 Java 对象持久化的新的规范，为 java dataobject 的简称,也是一个用于存取某种数据 仓库中的对象的标准化 API。JDO 提供了透明的对象存储，因此对开发人员来说，存储数据 对象完全不需要额外的代码（如 JDBCAPI 的使用）。这些繁琐的例行工作已经转移到 JDO 产品提供商身上，使开发人员解脱出来，从而集中时间和精力在业务逻辑上。另外，JDO 很灵活，因为它可以在任何数据底层上运行。JDBC 只是面向关系数据库（RDBMS）JDO 更通用，提供到任何数据底层的存储功能，比如关系数据库、文件、XML 以及对象数据库 （ODBMS）等等，使得应用可移植性更强。?spring 与 EJB 的区别！
TensorFlow2.0（10）：加载自定义图片数据集到Dataset
前面的推文中我们说过，在加载数据和预处理数据时使用tf.data.Dataset对象将极大将我们从建模前的数据清理工作中释放出来，那么，怎么将自定义的数据集加载为DataSet对象呢？这对很多新手来说都是一个难题，因为绝大多数案例教学都是以mnist数据集作为例子讲述如何将数据加载到Dataset中，而英文资料对这方面的介绍隐藏得有点深。本文就来捋一捋如何加载自定义的图片数据集实现图片分类，后续将继续介绍?如何加载自定义的text、mongodb等数据。加载自定义图片数据集如果你已有数据集，那么，请将所有数据存放在同一目录下，然后将不同类别的图片分门别类地存放在不同的子目录下,目录树如下所示：$ tree flower_photos -L 1
flower_photos
├── daisy
├── dandelion
├── LICENSE.txt
├── roses
├── sunflowers
└── tulips所有的数据都存放在flower_photos目录下，每一个子目录（daisy、dandelion等等）存放的都是一个类别的图片。如果你已有自己的数据集，那就按上面的结构来存放，如果没有，想操作学习一下，你可以通过下面代码下载上述图片数据集：
import tensorflow as tf
import pathlib
data_root_orig = tf.keras.utils.get_file(origin='https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz',
fname='flower_photos', untar=True)
data_root = pathlib.Path(data_root_orig)
print(data_root) # 打印出数据集所在目录下载好后，建议将整个flower_photos目录移动到项目根目录下。
import tensorflow as tf
import random
import pathlib
data_path = pathlib.Path('./data/flower_photos')
all_image_paths = list(data_path.glob('*/*'))
all_image_paths = [str(path) for path in all_image_paths] # 所有图片路径的列表
random.shuffle(all_image_paths) # 打散
image_count = len(all_image_paths)
image_count3670查看一下前5张：all_image_paths[:5]['data/flower_photos/sunflowers/9448615838_04078d09bf_n.jpg',
'data/flower_photos/roses/15222804561_0fde5eb4ae_n.jpg',
'data/flower_photos/daisy/18622672908_eab6dc9140_n.jpg',
'data/flower_photos/roses/459042023_6273adc312_n.jpg',
'data/flower_photos/roses/16149016979_23ef42b642_m.jpg']读取图片的同时，我们也不能忘记图片与标签的对应，要创建一个对应的列表来存放图片标签，不过，这里所说的标签不是daisy、dandelion这些具体分类名，而是整型的索引，毕竟在建模的时候y值一般都是整型数据，所以要创建一个字典来建立分类名与标签的对应关系：label_names = sorted(item.name for item in data_path.glob('*/') if item.is_dir())label_names['daisy', 'dandelion', 'roses', 'sunflowers', 'tulips']label_to_index = dict((name, index) for index, name in enumerate(label_names))label_to_index{'daisy': 0, 'dandelion': 1, 'roses': 2, 'sunflowers': 3, 'tulips': 4}all_image_labels = [label_to_index[pathlib.Path(path).parent.name] for path in all_image_paths]for image, label in zip(all_image_paths[:5], all_image_labels[:5]): print(image, ' ---> ', label)data/flower_photos/sunflowers/9448615838_04078d09bf_n.jpg ---> 3
data/flower_photos/roses/15222804561_0fde5eb4ae_n.jpg ---> 2
data/flower_photos/daisy/18622672908_eab6dc9140_n.jpg ---> 0
data/flower_photos/roses/459042023_6273adc312_n.jpg ---> 2
data/flower_photos/roses/16149016979_23ef42b642_m.jpg ---> 2好了，现在我们可以创建一个Dataset了：ds = tf.data.Dataset.from_tensor_slices((all_image_paths, all_image_labels))不过，这个ds可不是我们想要的，毕竟，里面的元素只是图片路径，所以我们要进一步处理。这个处理包含读取图片、重新设置图片大小、归一化、转换类型等操作，我们将这些操作统统定义到一个方法里：
def load_and_preprocess_from_path_label(path, label):
image = tf.io.read_file(path) # 读取图片
image = tf.image.decode_jpeg(image, channels=3)
image = tf.image.resize(image, [192, 192]) # 原始图片大小为(266, 320, 3)，重设为(192, 192)
image /= 255.0 # 归一化到[0,1]范围
return image, labelimage_label_ds = ds.map(load_and_preprocess_from_path_label)image_label_ds<MapDataset shapes: ((192, 192, 3), ()), types: (tf.float32, tf.int32)>这时候，其实就已经将自定义的图片数据集加载到了Dataset对象中，不过，我们还能秀，可以继续shuffle随机打散、分割成batch、数据repeat操作。这些操作有几点需要注意：（1）先shuffle、repeat、batch三种操作顺序有讲究：在repeat之后shuffle，会在epoch之间数据随机（当有些数据出现两次的时候，其他数据还没有出现过）在batch之后shuffle，会打乱batch的顺序，但是不会在batch之间打乱数据。（2）shuffle操作时，buffer_size越大，打乱效果越好，但消耗内存越大，可能造成延迟。推荐通过使用 tf.data.Dataset.apply 方法和融合过的 tf.data.experimental.shuffle_and_repeat 函数来执行这些操作:
ds = image_label_ds.apply(tf.data.experimental.shuffle_and_repeat(buffer_size=image_count))
BATCH_SIZE = 32
ds = ds.batch(BATCH_SIZE)好了，至此，本文内容其实就结束了，因为已经将自定义的图片数据集加载到了Dataset中。下面的内容作为扩展阅读。扩展上面的方法是简单的在每次epoch迭代中单独读取每个文件，在本地使用 CPU 训练时这个方法是可行的，但是可能不足以进行GPU训练并且完全不适合任何形式的分布式训练。可以使用tf.data.Dataset.cache在epoch迭代过程间缓存计算结果。这能极大提升程序效率，特别是当内存能容纳全部数据时。在被预处理之后（解码和调整大小），图片就被缓存了：
ds = image_label_ds.cache() # 缓存
ds = ds.apply(tf.data.experimental.shuffle_and_repeat(buffer_size=image_count))使用内存缓存的一个缺点是必须在每次运行时重建缓存，这使得每次启动数据集时有相同的启动延迟。如果内存不够容纳数据，使用一个缓存文件：
ds = image_label_ds.cache(filename='./cache.tf-data')
ds = ds.apply(tf.data.experimental.shuffle_and_repeat(buffer_size=image_count))
浅谈Volley请求
浅谈Volley请求Queue = Volley.newRequestQueue(context)深入理解RequestQueue request先简单介绍一下Volley的诞生背景 Volley诞生于 2013年 Google I/O大会上 是Google开发工程师写的一个网络请求框架 特点是进行数据量不大,但通讯频繁的网络操作,内部还封装了图片加载的控件 NetworkImageView 用于直接在网络上面加载图片 本文只是对??RequestQueue requestQueue = Volley.newRequestQueue(context);这一行代码的深入理解 别小看这一行代码 这一行代码信息量很大的 废话不多说 我们就直接来阅读源码吧(Read The Fucking Source Code)当我们用Volley执行网络请求时 首先就会写这一行代码RequestQueue queue = Volley.newRequestQueue(context);点进去之后 代码如下(class volley)//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package com.android.volley.toolbox;
import android.content.Context;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager.NameNotFoundException;
import android.net.http.AndroidHttpClient;
import android.os.Build.VERSION;
import com.android.volley.Network;
import com.android.volley.RequestQueue;
import java.io.File;
public class Volley {
private static final String DEFAULT_CACHE_DIR = "volley";
public Volley() {
}
public static RequestQueue newRequestQueue(Context context, HttpStack stack) {
File cacheDir = new File(context.getCacheDir(), "volley");
String userAgent = "volley/0";
try {
String packageName = context.getPackageName();
PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);
userAgent = packageName + "/" + info.versionCode;
} catch (NameNotFoundException var6) {
}
if (stack == null) {
if (VERSION.SDK_INT >= 9) {
stack = new HurlStack();
} else {
stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
}
}
Network network = new BasicNetwork((HttpStack)stack);
RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
queue.start();
return queue;
}
public static RequestQueue newRequestQueue(Context context) {
return newRequestQueue(context, (HttpStack)null);
}
}这个类里面主要是看几行代码我们调用的是一个参数的构造方法? 但是他还是会去掉两个参数的构造方法 两个参数的构造方法 看下面这一行代码RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);这里new了一个RequestQueue 的对象这一行代码第一个参数告诉我们的信息是1.new DiskBasedCache(cacheDir) 字面的意思是基于磁盘的缓存 里面的参数我们可以在volley类里看到 如下:private static final String DEFAULT_CACHE_DIR = "volley";
File cacheDir = new File(context.getCacheDir(), DEFAULT_CACHE_DIR);这两行代码的意思是在项目data/data包下创建一个volley的文件夹然后再看一下DiskBasedCache类的实现的一些细节 点开之后我们发现DiskBasedCache类里面的代码行数五百多行 我们还是挑重点看public DiskBasedCache(File rootDirectory, int maxCacheSizeInBytes) {
this.mEntries = new LinkedHashMap(16, 0.75F, true);
this.mTotalSize = 0L;
this.mRootDirectory = rootDirectory;
this.mMaxCacheSizeInBytes = maxCacheSizeInBytes;
}
private static final int DEFAULT_DISK_USAGE_BYTES = 5242880;
public DiskBasedCache(File rootDirectory) {
this(rootDirectory, 5242880);
}点开他的构造方法可以看到是给成员变量赋值 我们重点看参数二? 参数二我们可以明显看到了一个数 那就是规定默认磁盘缓存的大小时5M所以我们在创建一个请求队列时 第一个参数得到的结论是?1.volley文件夹是在这里创建的,2. 磁盘缓存的大小时5M,看到这里我们大致了解了一些基本信息我们接着往下看 创建请求队列时的第二个参数是什么意思 :network? 点进去之后public interface Network {
NetworkResponse performRequest(Request<?> var1) throws VolleyError;
}这就是一个接口 通过注释了解到 主要是由他来执行网络请求的? 那么他是怎样执行网络请求的呢 我们接着往下看点到BasicNetwork类里面看到 (由于源码比较多 我们就看这一行代码)httpResponse = this.mHttpStack.performRequest(request, headers);是通过这一行来执行网络请求的回过头来 我们再来看volley类代码Network network = new BasicNetwork(stack);这一行代码参数的好像在哪里见过 没错就是默认给我们传过来的值就是null 这行代码的上面 有一个判断if (stack == null) {
if (VERSION.SDK_INT >= 9) {
stack = new HurlStack();
} else {
stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
}
}这里给stack赋值了 如果版本大于9 的话? stack = new HurlStack();点到HurlStack类里面看到 protected HttpURLConnection createConnection(URL url) throws IOException {
return (HttpURLConnection)url.openConnection();
}这个方法我们可以看到底层是通过HttpURLConnecttion来完成网络请求的如果版本小于9 的话用的是HttpClient来执行网络请求的总结:从创建一个请求队列我们可以看到以下几点:1.volley文件夹是在这里创建的,2. 磁盘缓存的大小时5M,3.底层执行网络请求所用的框架 说了半天现在也是在说RequestQueue后面的两个参数的意思? 我们接着往下看RequestQuene的源码RequestQuene 类里面也就三百多行代码 这里我们就看跳过来的代码private static final int DEFAULT_NETWORK_THREAD_POOL_SIZE = 4;
public RequestQueue(Cache cache, Network network) {
this(cache, network, 4);
}
public RequestQueue(Cache cache, Network network, int threadPoolSize, ResponseDelivery delivery) {
this.mSequenceGenerator = new AtomicInteger();
this.mWaitingRequests = new HashMap();
this.mCurrentRequests = new HashSet();
this.mCacheQueue = new PriorityBlockingQueue();
this.mNetworkQueue = new PriorityBlockingQueue();
this.mCache = cache;
this.mNetwork = network;
this.mDispatchers = new NetworkDispatcher[threadPoolSize];
this.mDelivery = delivery;
}
public RequestQueue(Cache cache, Network network, int threadPoolSize) {
this(cache, network, threadPoolSize, new ExecutorDelivery(new Handler(Looper.getMainLooper())));
}进去之后看到了一个常量?DEFAULT_NETWORK_THREAD_POOL_SIZE这里我们可以看到 默认的网络线程池的大小为四这里的线程池可以优化 这里可以看到volley里的线程池是由数组组成 并且默认的线程数为四个还可以看到第四个参数new ExecutorDelivery(new Handler(Looper.getMainLooper())))这里使用hander绑定一个主线程的looper 来完成线程的之间的切换的总结:RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);我们写的这一行代码 volley帮我们做了mCache = cache;//磁盘缓存
mNectwork = network;//网络请求的处理
mDispatchers = new NetworkDispatcher[threadPoolSize]; //线程池
mDelivery = delivery;//初始化分发器 做网络结果和错误的回溯
我们接着往下看 看volley源码知道 现在该启动这个队列了queue.start(); 这一行代码又做了什么呢public void start() {
this.stop();
this.mCacheDispatcher = new CacheDispatcher(this.mCacheQueue, this.mNetworkQueue, this.mCache, this.mDelivery);
this.mCacheDispatcher.start();
for(int i = 0; i < this.mDispatchers.length; ++i) {
NetworkDispatcher networkDispatcher = new NetworkDispatcher(this.mNetworkQueue, this.mNetwork, this.mCache, this.mDelivery);
this.mDispatchers[i] = networkDispatcher;
networkDispatcher.start();
}
}这里是先开启了一个缓存的分发器??mCacheQueue, mNetworkQueue, mCache, mDelivery有四个参数 第三个和第四个参数是在创建队列的时候调用第一和第二个参数是在RequestQueue类里面已经初始化好了? 这两个队列的意思是首先看缓存队列里面有没有请求 有的话就直接用 没有的话 就放在网络队列里点到CacheDispatcher里面可以看到这是一个线程 他的run方法是一个死循环再来看start方法 里面有一个for循环? mDispatchers.length的值 我们已经知道是四了 意思是创建四个网络分发器所以我们start方法里一次性启动了五条线程以上这些内容就是我们在创建一个请求队列时volley帮我们做的所有事情 也就是开篇讲的mRequestQueue?=?Volley.newRequestQueue(context);做的事情
web验证码的生成以及验证
应用场景：在登录的网页常常要用到验证码，能有效的防止恶意的登陆注册，暴力的提交数据。验证码是一张图片，java有专门绘制图的类Graphics。验证码小demo下载地址：http://download.csdn.net/download/bushqiang/10260194例子演示：1.jsp页面用一个img标签来放验证码<img src="verifyCodeImage" id="verifyCodeImage" οnclick="javascript:myRefersh();">2.script提交换图请求，要导入jquery<script>
$(function() {
myRefersh();
});
function myRefersh() {
var date = new Date(); // 创建一个 Date 对象的 一个 实例
var time = date.getTime(); // 从 新创建的 Date 对象的实例中获得该时间对应毫秒值
$('#verifyCodeImage').attr('src', 'verifyCodeImage?time=' + time);
}
</script>verifyCodeImage的请求后面加上时间戳time是因为换验证码是局部的刷新，浏览器有记忆功能，会自己缓存已经请求过的页面，为了表示不同于之前的验证码，所以用时间来区别。3.后台处理接收到请求后就画一个验证码，再传给前台。 //生成验证码
@RequestMapping("/verifyCodeImage")
public ModelAndView regist(HttpServletRequest request,HttpServletResponse response) throws Exception{
// 获得 当前请求 对应的 会话对象
HttpSession session = request.getSession();
final int width = 120; // 图片宽度
final int height = 40; // 图片高度
final String imgType = "jpeg"; // 指定图片格式 (不是指MIME类型)
final OutputStream output = response.getOutputStream(); // 获得可以向客户端返回图片的输出流
// 创建验证码图片并返回图片上的字符串
String codeimage = GraphicHelper.create(width, height, imgType, output);
//存放验证码
session.setAttribute("codeimage", codeimage);
output.flush();
output.close();
return null;
}4.画验证码的类public final class GraphicHelper {
/**
* 以字符串形式返回生成的验证码，同时输出一个图片
*
* @param width
* 图片的宽度
* @param height
* 图片的高度
* @param imgType
* 图片的类型
* @param output
* 图片的输出流(图片将输出到这个流中)
* @return 返回所生成的验证码(字符串)
*/
public static String create(final int width, final int height,
final String imgType, OutputStream output) {
StringBuffer sb = new StringBuffer();
Random random = new Random();
BufferedImage image = new BufferedImage(width, height,
BufferedImage.TYPE_INT_RGB);
Graphics graphic = image.getGraphics();
graphic.setColor(Color.getColor("F8F8F8"));
graphic.fillRect(0, 0, width, height);
Color[] colors = new Color[] { Color.BLUE, Color.GRAY, Color.GREEN,
Color.RED, Color.BLACK, Color.ORANGE, Color.magenta,Color.darkGray,Color.pink };
// 在 "画板"上生成干扰线条 ( 40 是线条个数)
for (int i = 0; i < 40; i++) {
graphic.setColor(colors[random.nextInt(colors.length)]);
final int x = random.nextInt(width);
final int y = random.nextInt(height);
final int w = random.nextInt(20);
final int h = random.nextInt(20);
final int signA = random.nextBoolean() ? 1 : -1;
final int signB = random.nextBoolean() ? 1 : -1;
graphic.drawLine(x, y, x + w * signA, y + h * signB);
}
// 在 "画板"上绘制字母
graphic.setFont(new Font("Comic Sans MS", Font.BOLD, 30));
for (int i = 0; i < 4; i++) {
final int temp = random.nextInt(26) + 97;
String s = String.valueOf((char) temp);
sb.append(s);
graphic.setColor(colors[random.nextInt(colors.length)]);
graphic.drawString(s, i * (width / 4), height - (height / 3));
}
graphic.dispose();
try {
ImageIO.write(image, imgType, output);
} catch (IOException e) {
e.printStackTrace();
}
return sb.toString();
}
}5.校验验证码是否正确// 用户登录处理
@RequestMapping("/userlogin")
public ModelAndView checklogin(HttpSession session,
HttpServletRequest request) throws Exception {
ModelAndView modelAndView = new ModelAndView();
//获取验证码
String verifyCode = request.getParameter("verifyCode");
String code = (String) session.getAttribute("codeimage");
//验证码错误
if(!code.equals(verifyCode.toLowerCase())){
modelAndView.addObject("message", str + "验证码错误！");
modelAndView.addObject("user", user);
// 返回首页，并且提示错误
modelAndView.setViewName("index");
return modelAndView;
}else{
//登陆成功就清除验证码的session
session.removeAttribute("codeimage");//防止用户重复提交表单
}
}6.验证码效果图，上面的小demo是项目的一部分和下面的效果图有一点小差距，按照我上面代码修改就可以了
Eureka应用
Eureka[ju?ri?k?]简介Eureka是Netflix服务发现的服务端与客户端，Eureka提供服务注册以及服务发现的能力，当是Eureka Server时(注册中心)，所有的客户端会向其注册，当是Eureka Client时，可以从注册中心获取对应的服务信息，或者是向Eureka Server将自己作为实例注册进去，每个Eureka不仅仅是一个服务端同时还是一个客户端。注册中心当Eureka想要成为注册中心时，必须将注册中心的服务地址指向自己，同时禁用服务检索的功能。Eureka是一个高可用的组件，它没有后端缓存，每一个实例注册之后需要向注册中心发送心跳来检测服务的可用性，注册中心不处理请求的转发，只是记录每个实例注册进来的信息。mark项目搭建导入依赖编写配置文件开启这个功能 @EnableXXXXXX配置类Eureka服务pom<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>springcloud</artifactId>
<groupId>cn.com.codingce</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>springcloud-eureka-7001</artifactId>
<dependencies>
<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka-server -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-eureka-server</artifactId>
<version>1.4.6.RELEASE</version>
</dependency>
<!--热部署工具-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
</dependency>
</dependencies>
</project>EurekaServerpackage cn.com.codingce;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
@SpringBootApplication
@EnableEurekaServer //EnableEurekaServer 服务端启动类
public class EurekaServer {
public static void main(String[] args) {
SpringApplication.run(EurekaServer.class, args);
}
}application.ymlserver:
port: 7001
# Eureka配置
eureka:
instance:
hostname: localhost #Eureka服务端实例的名字
client:
register-with-eureka: false # 表示是否向eureka注册中心注册自己
fetch-registry: false # 表示如果 false 则表示自己为注册中心
service-url:
defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/Eureka 的自我保护模式详解访问Eureka主页时，如果看到这样一段大红色的句子：EMERGENCY! EUREKA MAY BE INCORRECTLY CLAIMING INSTANCES ARE UP WHEN THEY’RE NOT. RENEWALS ARE LESSER THAN THRESHOLD AND HENCE THE INSTANCES ARE NOT BEING EXPIRED JUST TO BE SAFE.（那么就表明着Eureka的 自我保护模式(self-preservation mode) 被启动了，当 Eureka Server 节点在短时间内丢失了过多实例的连接时（比如网络故障或频繁的启动关闭客户端），那么这个节点就会进入自我保护模式，一旦进入到该模式，Eureka server 就会保护服务注册表中的信息，不再删除服务注册表中的数据（即不会注销任何微服务），当网络故障恢复后，该 Ereaka Server 节点就会自动退出自我保护模式）在自我保护模式中, EurekaServe 会保护注册表中的信息, 不再注销任何服务实例. 当他重新收到心跳数重新恢复到阈值以上时, 该EurekaServe节点就会自动推出自我保护模式. 它的哲学就是宁可保存错误的服务注册信息, 也不盲目注销任何可能健康的实例, 一句话：好死不如赖活着综上, 自我保护模式中, 自我保护模式是一种应对网络异常安全保护措施, 它的架构哲学是宁可同时保留所有微服务(健康的服务和不健康的服务都会保留), 也不盲目注销任何健康的服务. 使用自我保护模式, 可以让Eureka集群更加健壮和稳定.在SpringCloud中, 可以使用eureka.serve.enable-self-preservation = false 禁用自我保护模式 [不推荐关闭自我保护机制]默认情况下，如果 Ereaka Server 在一段时间内没有接受到某个微服务示例的心跳，便会注销该实例（默认90秒），而一旦进入自我保护模式，那么即使你关闭了指定实例，仍然会发现该 Ereaka Server 的注册实例中会存在被关闭的实例信息，如果你对该实例做了负载均衡，那么仅关闭了其中一个实例，则通过网关调用接口api时很可能会发生如下异常：{
"timestamp": 1507707671780,
"status": 500,
"error": "Internal Server Error",
"exception": "com.netflix.zuul.exception.ZuulException",
"message": "GENERAL"
}解决这种情况的方法主要有几种方式：等待 Eureka Server 自动恢复 正常的情况下，等待网络恢复（或者没有频繁的启动与关闭实例）后，等待一段时间 Eureka Server 会自动关闭自我保护模式，但是如果它迟迟没有关闭该模式，那么便可以尝试手动关闭，如下。重启 Eureka Server 通常而言，PRD 环境建议对 Eureka Server 做负载均衡，这样在依次关闭并开启 Eureka Server 后，无效的实例会被清除，并且不会对正常的使用照成影响。关闭 Eureka 的自我保护模式 在yml配置文件中新增如下配置：eureka:
server:
enable-self-preservation: false
eviction-interval-timer-in-ms: 4000 # This is not required对比Zookeeper回顾CAP原则 RDBMS(Mysql、Oracle、sqlServer) ==>ACID NoSQL(redis、 mongdb)==>CAPACID是什么A(Atomicity)原子性：事务里面的所有操作，要么全部做完，要么都不做，只要有一个失败，整个事务都失败，需要回滚C(Consistency)一致性：以转账案例为例，假设有五个账户，每个账户余额是100元，那么五个账户总额是500元，如果在这个5个账户之间同时发生多个转账，无论并发多少个，比如在A与B账户之间转账5元，在C与D账户之间转账10元，在B与E之间转账15元，五个账户总额也应该还是500元，这就是保护性和不变性I(Isolation)隔离性：并发的事务之间互不影响D(Durability)持久性：事务一旦提交，数据将永久保存在数据库上CAP是什么C(Consistency)强一致性A(Availability)可用性P(Partition tolerance) 分区容错性CAP的三进二 CA AP CPCAP理论核心一个分布式系统不可能同时很好的满足一致性、可用性和分区容错性三个要求根据CAP原理, 将NOSQL数据库分成了满足CA原则， 满足CP原则满足AP原则三大类CA：单点集群, 满足一致性, 可用性的系统, 通常可扩展性差CP: 满足一致性, 分区容错性的系统, 通常性能不是特别高AP：满足可用性，分区容错性的系统，通常可能对一致性要求低一点作为服务注册中心, Eureka比Zookeeper好在哪里 著名的CAP理论指出, 一个分布式系统不可能同时满足C(一致性)A(可用性)P(容错性) 由于分区容错性P在分布式系统中是必须要保证的, 因此我们只能在A和C之前进行权衡Zookeeper保证的是CPEureka保证的是APZookeeper保证的是CP当向注册中心查询服务列表时，我们可以容忍注册中心返回的是几分钟以前的信息，但不能就收服务直接 down 掉不可用。也就是说服务注册的可用性要高于一致性 当时 zk 会出现这么一个情况，当 mastr 节点因网络故障和其他节点失去联系时，剩余节点会重新进行选举。问题在于，选举时间比较长，30s~120s，且选举期间，整个 zk 是不可用的。这就导致了在选举期间，注册服务的瘫痪。在云部署的环境下，因网络问题使 zk 集群时区 master 节点是交大概率会发生的事情，虽然服务能够最终恢复，但是漫长的选举时间导致的注册服务长期不可用是不能容忍的。Eureka保证的是APEureka 明白这一点，因此在设计时，就优先保证可用性. Eureka 各个节点是平等的 ，几个节点挂掉不会影响正常工作，只要有一台 Eureka 存在，就可以保证注册服务可用（保证可用性），只不过查到的信息可能不是最新的（不保证强一致性）。除此之外，Eureka 还有一种自我保护机制，如果在 15 分钟内超过 85% 的节点没有正常的心跳，那么 Eureka 就会认为客户端与注册中心出现了故障，此时会出现以下几种情况：Eureka 不再从注册列表中移出因长时间没收到心跳而应该过期的服务Eureka 仍然能够接受新服务的注册和查询要求，但是不会被同步到其他节点上（即保证当前节点依然可用）当网络稳定时，当前实例新的注册信息会被同步到其他节点中结论 Eureka 可以很好的应对因网络故障导致部分节点失去联系的情况，而不会像 zookeeper 那样使整个注册服务瘫痪服务注册集群搭建springcloud-eureka-7002pom<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>springcloud</artifactId>
<groupId>cn.com.codingce</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>springcloud-eureka-7002</artifactId>
<dependencies>
<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka-server -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-eureka-server</artifactId>
<version>1.4.6.RELEASE</version>
</dependency>
<!--热部署工具-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
</dependency>
</dependencies>
</project>application.ymlserver:
port: 7002
# Eureka配置
eureka:
instance:
hostname: eureka7002.com #Eureka服务端实例的名字
client:
register-with-eureka: false # 表示是否向eureka注册中心注册自己
fetch-registry: false # 表示如果 false 则表示自己为注册中心
service-url:
defaultZone: http://eureka7001.com:7001/eureka/, http://eureka7003.com:7003/eureka/启动类package cn.com.codingce;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
@SpringBootApplication
@EnableEurekaServer //EnableEurekaServer 服务端启动类
public class EurekaServer_7003 {
public static void main(String[] args) {
SpringApplication.run(EurekaServer_7003.class, args);
}
}springcloud-eureka-7003pom<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>springcloud</artifactId>
<groupId>cn.com.codingce</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>springcloud-eureka-7003</artifactId>
<dependencies>
<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka-server -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-eureka-server</artifactId>
<version>1.4.6.RELEASE</version>
</dependency>
<!--热部署工具-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
</dependency>
</dependencies>
</project>application.ymlserver:
port: 7003
# Eureka配置
server:
port: 7003
# Eureka配置
eureka:
instance:
hostname: eureka7003.com #Eureka服务端实例的名字
client:
register-with-eureka: false # 表示是否向eureka注册中心注册自己
fetch-registry: false # 表示如果 false 则表示自己为注册中心
service-url:
defaultZone: http://eureka7001.com:7001/eureka/, http://eureka7002.com:7002/eureka/启动类package cn.com.codingce;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
@SpringBootApplication
@EnableEurekaServer //EnableEurekaServer 服务端启动类
public class EurekaServer_7003 {
public static void main(String[] args) {
SpringApplication.run(EurekaServer_7003.class, args);
}
}
NoSQL概述
NoSQL概述我们现在处理什么年代 ? ?2020年 ?大数据时代? 适者生存 学习才是在这个社会生存的唯一法则。1.单机MySQL的年代90年代, 一个基本网站访问量一般不会太大, 单个数据库完全足够！那个时候更多的使用静态网页 HTML 服务器根本没有压力 思考下：整个网站的瓶颈是什么？数据量太大, 一个机器放不下数据索引 （300万条数据就一定建立索引! B+树), 一个机器内存也放不下访问量(读写混合), 一台服务器承受不了只要你开始出现以上三种情况之一， 那么就必须晋级！2.Memcached（缓存） + MySQL + 垂直拆分网站80%的情况都是在读数据, 每次都要查询数据就很麻烦， 所以说我们希望减轻数据压力, 我们可以使用缓存来保证效率!发展过程：优化数据结构-->文件缓存(IO)-->Memcached（缓存 当时最热门的技术！）3.分库分表+水平拆分+MySQL集群技术和业务发展的同时, 对人的要求也越来越高 本质:数据库(读 写)早些年MyISAM:表锁, 十分影响效率!高并发下就会出现严重的问题, 转到Innodb：行锁慢慢的就开始使用分库分表来解决写的压力! MySQL在那个年代推出了表分区 这个并没有多少公司使用 MySQL集群4.如今年代技术爆炸 2010-2020 ? 十年之间, 世界发生翻天覆地的变化MySQl关系型数据库就不够用了, 数量巨多, 变化很快MySQL有的使用它来存储一些比较大的文件, 博客 图片 ? ?数据库表很大, 效率就低了！如果有一种数据库专门来处理这种数据 MySQL的压力就会十分小(研究如何处理这些问题) 大数据IO压力下, 表几乎没办法更大！5.目前一个基本互联网项目！6.为什么要用NoSQL用户的个人信息, 社交网络, 地理位置. 用户自己产生的数据, 用户日志等等爆发式的增长 这时候我们就应该使用NoSQL数据库, NoSQL可以很好的处理以上的情况.什么是NoSQLNoSQL = Not Only SQL(不仅仅是SQL)泛指非关系型数据库，随着 Web2.0 互联网的诞生， 传统关系型数据库很难对付web2.0时代！尤其是超大规模的高并发的社区 暴露出很多难以克服的问题, NoSQL在当今大数据环境下发展的十分迅速，Redis是发展最快的，而且当下必须掌握一个技术很多数据类型用户的个人信息，社交网络，地理位置。这些数据类型的存储要有一个固定的格式！不需要多余的格式就可以横向扩展的！Map 使用键值对NoSQL特点解耦方便拓展(数据之间没有关系, 很好扩展)大数据量 高性能(Redis一秒些8万次 ?读取11万 ? ?NoSQL的缓存记录， 是一种细粒度的缓存, 性能会比较高)数据类型是多样的!(不需要事先设计数据库! ? 随取随用 ? ?如果是十分大的表, 很多人就无法设计了)传统的RDBMS和NoSQL传统的RDBMS：结构化组织、SQL、数据和关系都存在单独的表中row col、操作数据、数据定义语言、严格的一致性、基础事务......NoSQL: 不仅仅是数据、没有固定的查询语言、键值对存储、列存储、文档存储（社交关系）、最终一致性、CAP原理 和 BASE （异地多活）、高性能、高可用、高可扩、......了解3V + 3高大数据时代的3V：主要描述问题海量Volume多样Variety实时Velocity大数据时代的3高：主要是对程序的要求高并发高可扩（随时水平拆分，机器不够用了，可以扩展机器）高性能（保证我们的用户体验）真正在公司中的实践：NoSQL + RDBMS 一起使用才是最强大的, 阿里巴巴的架构引进.阿里巴巴演进分析思考问题 这么多的数据难道都是在一个数据库中的么?敏捷开发、极限编程开源才是技术的王道任何一家互联网公司，都不可能简简单单让用户能用就好了 大量公司做的都是相同的业务;(竞品协议)如果未来相当一个架构师：没有什么是加一层解决不了的！商品的基本信息名称 价格 商家信息 关系型数据库就能就解决 MySQL/oracle (淘宝早就去IOE了 ? ?王坚：推荐文章 ：阿里云的这群疯子) 淘宝内部的MySQL 不是大家用的MySQL商品描述 评论（文字比较多）文档型数据库中 ?MongDB图片分布式文件存储系统 FastDFS淘宝自己的 ? ?TFSGoogle ? ? ? GFSHadoop ? ? ? HDFS阿里云的 ? ? ?oss商品关键字（搜索）搜索引擎：solr ? elasticsearchISerach：多隆（多关注技术大佬）商品热门的波段信息内存数据库‘Reids Tair ?Memache商品的交易 ? 外部的支付接口第三方应用要知道， 一个简单的网页背后的技术一定不是大家所想象的那么简单大型互联网应用问题数据类型太多了数据源多， 经常重构（敏捷开发）！数据要改造, 大面积改造解决问题：NoSQL的四大分类KV键值对新浪：Redis美团：Redis + Tair阿里、百度：Redis + memecache文档型数据库(bson格式 ? 和json一样)MongoDB(一般必须要掌握)MongoDB是一个基于分布式文件存储的数据库, C++编写, 主要用来处理大量的文档MongoDB是一个介于关系型数据库和非关系型数据库中中间产品 ? MongoDB是非关系型数据库中功能最丰富, 最像关系型数据库.ConthDB列存储HBase分布式文件系统图关他不是存储图形, 放的是关系, 比如：朋友圈社交网络 ? 广告推荐Neo4j InfoGridWeb1.0：以静态、单向阅读为主，网站内信息可以直接和其他网站信息进行交互，能通过第三方信息平台同时对多家网站信息进行整合使用。Web2.0：以分享为特征的实时网络，用户在互联网上拥有自己的数据，并能在不同的网站上使用。Web3.0：将以网络化和个性化为特征，提供更多人工智能服务，完全基于Web，用浏览器即可实现复杂的系统程序才具有的功能。Web3.0的特征分析：1、微内容(Widget)的自由整合与有效聚合 2、适合多种终端平台，实现信息服务的普适性 3、良好的人性化用户体验，以及基础性的个性化配置 4、有效和有序的数字新技术
