源文件就是我们编写Java代码的文件。文件扩展名为.java

    字节码文件是源文件编译后的文件。字节码文件是二进制文件，需要通过特定的工具才能查看。里面存放了源文件编译后的字节码指令。

    Java 程序运行时会由类加载器负责把.class的字节码文件装在到内存中，供虚拟机执行。
       加载 Loading
    1. 启动类加载器 BootStrap Class Loader   :  负责从启动类中加载类。具有最高执行优先级。即：rt.jar等。
    
    2. 扩展类加载器 Extension Class Loader  :  负责加载扩展相关类。即：jre/lib/ext 目录
    
    3. 应用程序加载器 Application Class Loader  :  加载应用程序类路径(classpath)中相关类。
    4. 链接 Linking
    5. 校验 Verify  ： 校验器会校验字节码文件是否正确。
    6. 准备 Prepare  ： 所有静态变量初始化并赋予默认值
    7. 解析 Resolve  ：符号引用被换成直接引用。
    8. 初始化 Initialization  :  所有静态变量赋予初值，静态代码块执行。

 解释器 Interpreter   ： 解释器负责解释字节码文件。每次方法调用都会被重新解释。
    2. JIT编译器  : JIT 即时编译器。对于多次被使用的方法会放入到本地内存中，下次就可以直接调用了。
    3. 探测器  ; 负责探测多次被调用的代码。
    4. 垃圾回收器 GC  ： 负责回收不在被使用的对象。GC是JVM中非常重要的一块，在后面我们会单独讲解一下GC。

    	在Java代码中使用native修饰的方法表示方法具体实现使用其他编程语言实现的。例如：C语言。通过本地库接口为Java程序提供调用其他语言的实现方案。

    	所有的本地方法，通过本地库接口调用。

    程序计数器简称：PC Register
    程序计数器是一块较小的内存空间。记录了当前线程执行到的字节码行号。每个线程都有自己的程序计数器，相互不影响。如果是native方法，计数器为空。

    虚拟机栈跟随线程创建而创建，所以每个线程都有一个虚拟机栈。
    虚拟机栈中存储的是栈帧（frames），每个栈帧对应一个方法，每个栈帧都有自己的局部变量表、操作数栈、动态链接和返回地址等。当前正在执行的方法称为当前方法，当前方法所在的帧称为当前帧。方法执行时帧就是一个入栈操作，方法执行完成之后栈帧就是一个出站操作。

    局部变量表存储的8大基本数据类型和返回值以及方法参数及对象的引用。	其中long和double占用2倍长度。
    局部变量表就是一个数组，数组的长度在编译器确定。通过从0开始的索引调用局部变量表的内容。
    对于类方法，从索引0开始连续N个作为方法传递。对于实例方法索引0存储的都是实例化方法的实例对象的引用。

    操作数栈存在于栈帧中，其大小在编译期确定。
    操作数栈中存储了class文件中虚拟机指令以及准备要传递的参数和接收对方的返回结果。
    运行时常量池中数据以及局部变量表中得值都可以由操作数栈进行获取。

    方法·把符号转换为直接引用分为两种情况。在JVM加载或第一次使用转换时称为静态链接或静态解析。而在运行期间把符号转换为直接引用时就称为动态链接。

 正常结束执行。例如碰见return关键字。调用程序计数器的值后当前栈帧直接出栈就可以了。
    2. 异常结束。可能需要恢复上层方法的局部变量表和操作数栈，然后把返回值压如到栈帧的操作数栈中，之后调用程序计数器的值后获取到下条指令。

    堆是所有线程共享的，存储类的实例和数组。
    堆是在虚拟机启动时创建的，由GC负责回收。
    堆可以是一块不连续的内存空间。
    在Java 8 中，String是存在于堆中的。

    在Java 7时分为：新生代（Young Generation）、老年代（Old Generation）。在HotSpot中使用永久代来实现方法区的规范。且新生代、老年代和永久代是连续的。
    新生代又被分为Eden区、From Survivor区、To Survivor区。官方说明默认分配比例为8：1：1。但是使用jmap工具进行测试时发现比例为6：1：1。

    在Java 8时把永久代替换为元空间（MetaSpace），也就是说在Java8中使用元空间来实现方法区。且在Java8中把元空间移植到本地内存上（Native Memory），其实在Java 7 时，部分数据已经移植到本地内存上了。例如：符号引用(Symbols)

 方法区是线程共享的。
    2. 在虚拟机启动时自动创建方法区，方法区可以是一块不连续的内存空间。
    3. 方法区可以理解为编译代码存储区。在方法区中存储每个类的结构、运行时常量池、字段、方法、构造方法。
    4. 在JVM规范上方法区是一个独立的区域，但是在Java SE7 的HotSpot 上方法区使用永久代作为实现，永久代和堆是一块连续空间。在Java SE8的JVM规范实现上，HotSpot使用元空间实现方法区。

    运行时常量池存在于方法区。存储每个类或每个接口从编译时已知的数字文字到必须在运行时解析的方法和字段引用。

    java [options] classname [args]
    
    java [options] -jar filename [args]
    
    javaw [options] classname [args]
    
    javaw [options] -jar filename [args]

 **options**：选项。工支持6种选项。
    3**. classname**:类名
    4. **-jar** 参数
    5. **filename** 文件名称
    6. **args** 传递给主方法的参数。用空格分隔。

 Standard Options 标准选项。
    2. Non-Standard Options 非标准选项
    3. Advanced Runtime Options 高级运行时选项。控制Java HotSpot VM运行时行为。
    4. Advanced JIT Compiler Options 高级JIT（即时编译器）编译器选项。使用JIT时优化参数，属于HotSpot专有选项，非JVM通用选项。
    5. Advanced Serviceability Options 高级可维护性选项。提供了收集系统信息和执行大量调试的能力。
    6. Advanced Garbage Collection Options 高级垃圾收集选项。控制HotSpot执行GC的方式。
    其中3、4、5、6的参数都是以-XX：开头的

    	标准选项是所有JVM实现都支持的选项。

    	启用帮助，显示所有支持的选项。
    	也可以写成：java -?

    	打印版本号。

    	启用断言。默认情况下断言是不启用的。
    	assert expression;如果表达式为真继续运行，如果表达式为假报异常。

    	assert expression1:expression2;如果expression1为真继续运行。如果表达式为假expression2作为异常信息。

    	加载指定的jar包。

    	设置系统属性值。在项目部署或Spring Boot项目中会使用到。

    	运行指定的jar文件。

    	-verbose:gc 打印GC信息。用于诊断GC时使用。
    	-verbose:class 打印载入类的相关信息。可用于诊断找不到类或类冲突时使用。
    	-verbose:jni 输出native方法调用情况。可用于诊断native调用相关问题。
    	Non-Standard Options（非标准选项）
    	非标准选项是HotSpot专有选项。所有内容都是以-X开头（必须是大写）。

    显示所有选项。

    -Xms<size> 设置初始化Java堆大小
    
    -Xmx<size> 设置最大堆大小。
    
    -Xss<size>  设置Java线程堆栈大小。等效于-
    XX:ThreadStackSize
    
    -Xmn<size> 年轻代初始化和最大大小。建议年轻代占用整个堆的1/2~1/4之间。年轻代太小GC频率太高，年轻代太大会触发Full GC。也可以使用还可以使用-XX:NewSize设置初始大小和-XX:MaxNewSize最大大小
    
    -Xloggc:filename 设置将gc信息写入到某个日志文件中。

    控制Java HotSpot VM运行时行为。所有的参数都是-XX: 开头。注意大小写。
    
    -XX:+PrintCommandLineFlags
    打印命令行JVM参数。默认不开启不打印。通过此内容可以查看默认配置，例如当前锁使用的虚拟机类型。等效于jinfo -flags pid
    
    -XX:ThreadStackSize
    设置线程堆栈大小。等效于-Xss
    
    -XX:+TraceClassLoading
    启用类加载跟踪。默认不开启打印。
    
    -XX:+TraceClassLoadingPreorder
    按照引用顺序跟踪所有加载的类。默认禁用
    
    -XX:-UseBiasedLocking
    禁用偏向锁。设置后对于一些大量无竞争的同步操作会明显提升性能。但对于某些具有锁的应用性能会降低。

    -XX:+AggressiveOpts
    允许积极的使用性能优化功能。预计在后续版本设置为默认开启。目前是默认关闭的。
    
    -XX:+BackgroundCompilation
    启用后台编译，默认开启。如想取消使用-XX:-
    BackgroundCompilation(等效于-Xbatch).
    
    -XX:CICompilerCount=threads
    设置用于编译的编译器线程数。默认情况下，服务器 JVM 的线程数设置为 2，客户端 JVM 的线程数设置为 1
    
    -XX:CodeCacheMinimumFreeSpace=size
    设置编译器最小空间。默认500KB。当剩余空间少于最小空间时，编译器停止工作。
    
    -XX:InitialCodeCacheSize=size
    设置初始代码缓存大小
    
    -XX:+OptimizeStringConcat
    启动String连接操作优化。默认启用。可使用-XX:-OptimizeStringConcat禁用

    -XX:+HeapDumpOnOutOfMemoryError
    当出现java.lang.OutOfMemoryError把堆中内容转存到当前目录文件中。默认禁止的。
    
    -XX:HeapDumpPath=path
    当设置了-XX:+HeapDumpOnOutOfMemoryError以后，转存文件路径。例如：-XX:HeapDumpPath=C:/log/java/java_heapdump.log
    
    -XX:LogFile=path
    设置写入日志数据的路径和文件名，例如-XX:LogFile=C:/log/java/hotspot.log
    
    -XX:+PrintClassHistogram
    默认禁止。当按Ctrl+Break时打印类的直方图。等效于：jmap -histo pid 命令
    
    -XX:+PrintConcurrentLocks
    默认禁止。打印Concurrent相关的锁。等效于：jstack -l
    
    -XX:+UnlockDiagnosticVMOptions
    默认禁止。解锁诊断VM选项内容。因为在JVM中某些参数必须诊断后才能赋值。

    -XX:ActiveProcessorCount= x
    设置VM操作各种线程池（例如：ForkJoinPool）的CPU数量
    
    -XX:+AggressiveHeap
    默认禁止。启用堆优化。设置后将会根据计算机配置（RAM和CPU）将各种参数设置为最合适长时间运行的值。
    -XX:+CMSClassUnloadingEnabled
    默认开启。在使用标记清除垃圾收集齐（CMS）时开启类卸载。可使用减号禁用。
    
    -XX:CMSInitiatingOccupancyFraction=num
    设置老年代占用比例。取值（0-100），如果为负数，表示-XX:CMSTriggerRatio进行定义比例。
    
    -XX:ConcGCThreads=threads
    设置并发GC时可用线程数。默认情况下该值取决于JVM可用的CPU数量。
    
    -XX:+DisableExplicitGC
    默认禁用的。开启后将不会处理System.gc();但JVM仍会在必要时候进行GC。
    
    -XX:+ExplicitGCInvokesConcurrent
    默认禁用。通过System.gc()启用并发GC。必须与-XX:+UseConcMarkSweepGC一起启用。
    
    -XX:G1HeapRegionSize=size
    设置使用垃圾优先 (G1，garbage-first ) 收集器时 Java 堆细分到区域大小。
    
    -XX:+G1PrintHeapRegions
    默认禁止。打印哪些堆区域进行了回收，以及G1的使用情况。
    
    -XX:InitialHeapSize=size
    初始化堆大小。必须是0或1024的倍数且大于1MB。默认是根据系统配置自动选择。
    
    -XX:InitialSurvivorRatio=ratio
    初始化Suvivor区域的比例。
    
    -XX:InitiatingHeapOccupancyPercent=percent
    初始化堆所占空间触发GC的比例。默认45%。设置0表示不间断回收
    
    -XX:MaxGCPauseMillis=time
    单位毫秒。设置堆最大暂停时间。JVM有可能无法满足这个要求。默认没有设置。
    
    -XX:MaxHeapSize=size
    堆最大大小。等效于-Xmx
    
    -XX:MaxHeapFreeRatio=percent
    设置GC后最大堆空闲比例。如果超过这个比例将会缩小。默认值75%
    
    -XX:MaxMetaspaceSize=大小
    最大元空间大小。默认是根据系统所剩内容自动判断。
    
    -XX:MaxNewSize=size
    新生代最大大小
    
    -XX:MaxTenuringThreshold=threshold
    设置GC最大大小，即GC进行回收时年龄的大小。处于Survivor区域的对象每次GC后年龄都会增加1。最大值15.parallel collection默认值15.CMS默认值6.
    
    -XX:MetaspaceSize=size
    元空间大小。超过后进行GC。默认需要看系统可以内存大小。
    
    -XX:NewRatio=ratio
    年轻代和老年代比例。默认值为2.
    
    -XX:NewSize=size
    新生代大小。等效于-Xmn
    
    -XX:ParallelGCThreads=threads
    并行GC线程数。默认值取决于CPU。
    
    -XX:+PrintGC
    打印GC消息。默认禁用。
    
    -XX:+PrintGCApplicationStoppedTime
    打印GC时应用暂停时间
    
    -XX:+PrintGCDetails
    打印GC详情。默认禁用。
    
    -XX:+PrintGCTimeStamps
    打印GC时间戳
    
    -XX:+ScavengeBeforeFullGC
    在每次FullGC之前先对年轻代进行GC。默认开启的。且Oracle不建议禁用。
    
    -XX:SurvivorRatio=ratio
    设置年轻代中Eden区和Survivor区的比例。默认值是8.但是经过测试发现是打印的是8，实际比例为6.
    
    -XX:TargetSurvivorRatio=percent
    设置年轻代GC后Survivor区域的比例。
    
    -XX:+UseAdaptiveSizePolicy
    默认启用。使用自适应大小策略。如果想关闭，可以使用减号。关闭后必须显示设置 -XX:SurvivorRatio
    
    -XX:+UseG1GC
    默认禁用，根据计算机配置和JVM类型自动选择。配置后表示启动G1垃圾收集器。适用于服务端的垃圾收集器。主要是针对内存比较大的情况。G1可以尽可能的满足GC暂停时间要求，同时保证良好的吞吐量。在使用G1收集器的时候建议堆大小至少6GB以上。
    
    -XX:+UseGCOverheadLimit
    默认启用的。JVM限制在抛出OutofMemoryError之前GC所花费的比例。如果GC花费时间超过98%，而堆恢复低于2%则抛出OutOfMemoryError
    
    -XX:+UseParallelGC
    默认禁用。配置表示启用并行GC。如果开启会自动-XX:+UseParallelOldGC。除非显示禁用了。对于64位平台，默认GC类型。
    
    -XX:+UseParallelOldGC
    默认禁用。配置表示启用并行老年代GC。如果开启会自动启用-XX:+UseParallelGC
    
    -XX:+UseParNewGC
    默认禁止。启动年轻代并行GC。在JDK8 中如果希望启用年轻代GC时推荐使用这个选项，而不是XX:+UseConcMarkSweepGC
    
    -XX:+UseConcMarkSweepGC
    默认禁止，JVM根据计算机配置自动选择合适的GC。在老年代启用CMS垃圾回收器Oracle建议在吞吐量（-XX:+UseParallelGC）垃圾收集器无法满足应用程序延迟要求时使用CMS垃圾收集器。当开启此选项后自动开启-XX:+UseParNewGC。并且在JDK8中不允许-XX:+UseConcMarkSweepGC和-XX:-UseParallelGC组合
    
    -XX:+UseSerialGC
    启用串行GC。默认禁止。但是对于小型简单应用，这种GC是较佳选择。客户端默认GC类型。
    
    -XX:+UseStringDeduplication
    G1回收器专有选项。默认禁止。配置后表示启用字符串重复删除。也就是说允许多个字符串对象指向同一个堆中字符串对象。

    引用计数（已淘汰）
    引用计数算法就是看对象是否被引用。如果引用则对象计数器加一。如果释放引用计数器减一。但是引用计数算法最大的问题就是循环引用问题。当出现循环引用时对象计数器至少为1.这时候对象可能已经是垃圾了，但是无法被回收。

    	起源于JDK 1.3，单线程执行，每次回收必须STW。
    	应用场景：虚拟机在client模式下默认的GC。
    	优点：简单高效。

    	老年代收集器。标记整理算法。单线程。主要应用在client模式下老年代收集。在JDK1.5之前可以与Parallel Scavenge配合使用。可作为CMS的备选。

    	Serial 收集器多线程版本，用于收集新生代。可与CMS配合使用。
    	ParNew可以并行执行，主要为了减少STW的时间，加快程序响应，给用户提供良好的体验。

    	新生代收集器。采用复制算法。可以并行执行。
    	优点：
    	具备自适应调节能力。-XX:+UseAdaptiveSizePolicy
    	主要解决吞吐量问题。也被称为“吞吐量优先”收集器。即吞吐量 = 运行用户代码时间 /（运行用户代码时间 + 垃圾收集时间），虚拟机总共运行了100分钟，其中垃圾收集花掉1分钟，那吞吐量就是99%。高吞吐量可以高效的利用CPU时间，尽快完成运算任务。

    	老年代收集器。标记整理算法。多线程。JDK 1.6中出现。

    		主要为了减少STW时间。

    	采用标记清除算法：
    	初始标记：初始标记只是标记下GC Root能够关联的对象。速度很快。需要STW
    	并发标记：进行GC Roots Tracing的过程
    	重新标记：修正并发标记期间因用户程序继续运作而导致标记产生变动的那一部分对象的标记记录
    	并发清除：并发的清除对象。

    	并发收集。低停顿。

    	对CPU非常敏感，对于CPU大于4个时要求并发收集时使用的线程数不等于1/4。但随着CPU增加而下降。
    可能产生浮动垃圾。因为CMS清理阶段程序还在运行，所以就可能产生新的垃圾，这部分垃圾只能等到下次才能被清理。所以称为浮动垃圾。
    可能产生大量空间碎片。

    JDK8中主推的收集器。属于CMS的替代品。
    G1收集器时堆中的年轻代和老年代只是逻辑上的概念，实际上把堆（一块连续内存）分为很多Region（分区）每个分区里面又被分为多个卡片（Card）。所以里面可能有很多年轻代和老年代。G1收集器里面多了一个新的概念：humongous（巨型对象）。当对象达到或超过Region一半时称为巨型对象。举行对象独占一个或多个连续的Region。

 初始标记：初始标记阶段仅仅只是标记一下GC Roots能直接关联到的对象，并且修改TAMS（Next Top at Mark Start）的值。此过程需要STW，但是耗时很短。
    	2. 并发标记：并发标记阶段是从GC Root开始对堆中对象进行可达性分析，找出存活的对象。此过程耗时可能较长于用户操作并发执行，不需要STW。
    	3. 最终标记。标记因为并发标记时用户执行产生的垃圾。需要STW（也可以并行）
    	4. 筛选回收。对各个Region收回价值和时间进行计算，筛选出符合用户设定的预期回收时间。

 G1是用在新生代和老年代同时使用。CMS是老年代收集器。
    
    	2. G1是Java8主推的收集器。CMS是java5出现的收集器。
    	
    	3. G1的STW时间可由用户设定，在筛选回收过程“可预测”的想办法满足设定要求。CMS是尽可能的减少STW时间
    	
    	4. G1使用的是标记整理算法，CMS使用的是标记清除算法（所以可能有内存碎片）。
    
    	5. G1回收的流程是初始标记、并发标记、最终标记、筛选回收。CMS的流程是：初始标记、并发标记、重新标记、并发清除。

 服务器硬件配置能高则高。
    	
    	2. GC类型要选择好合适的类型。
    	
    	3. 减少GC频率和Full GC的次数。实现较高的吞吐量或较低延迟。

    GC的类型选择也是很重要的事情。
    
    单核或客户端模式选择serial+serial Old 组合即可。
    
    多核64位系统选择Parallel Scavenge+Parallel Old 模式。吞吐量表现非常优秀。
    
    如果对于较低延迟较高的应用可选择G1回收器。

    新生代的大小（-Xmn或-XX:NewSize+-XX:MaxNewSize）直接影响GC频率。GC频率太高会导致JVM性能下降。
    
    但是要注意：在堆大小固定的情况下，新生代大小越大，老年代大小越小。

    当老年代满了以后会进行Full GC，所以增加老年代大小可以减少Full GC 的次数。
    
    但是要注意：在堆大小固定的情况下，老年代越大，新生代越小。
    
    所以默认情况下新生代和老年代的比例1：2（-XX:NewRatio=）是Java官方通过不断尝试，不断测试出来的最优比例，在没有特殊要求的情况下可以使用这个比例。

    		可以借助各种技术或工具进行观察。

    可以通过 -XX:+PrintGCDetails 和 -Xloggc:/data/jvm/gc.log 把GC日志打印出来。

    当发生OutOfMemoryError后可以使用-XX:+HeapDumpOnOutOfMemoryError和-XX:HeapDumpPath=path把堆信息转存下来。

    	jstack pid 打印某个时间点的线程快照。

    		jconsole 可视化控制台工具，查看内存等。
    		
    		jmap 堆内存查看工具。
    		
    		jstat 虚拟机状态查看。
    		
    		jvisualvm 和jconsole类似，功能稍微强大一点。

 尝试修改新生代，老年代，元空间大小。及新生代中Eden和survivor的比例。但是最好不能全动，需要一点一点增加或减少根据配置后的效果再次修改。
    		个人建议：JVM默认配置都官方经过多少次尝试给出的方案，能不动就不动。
    
    2. 检查代码。很多时候是因为代码问题导致JVM性能下降。
    		(1)	避免创建大对象或大数组。因为大对象和大数组可能直接进入到老年代。增加Full GC 的次数。
    		(2)	避免一次做大量数据操作。可以考虑分页或分批完成。

    JVM 并不是我们写的，我们只是使用它。
    
    HotSpot之所以能够调优也是因为它给我们提供了一系列参数选项和工具，只要我们能够清楚JVM内存结构图、GC类型、GC算法、JVM参数就可以根据自己应用实际情况进行尝试调优。
    JVM调优是无法给出固定答案的，因为一点点小变化可能导致调优方案不一样。所以只要具备调优的思想就可以应付所有的情况了。
    
    另外优秀的代码也是调优的有段。好的代码可以大大减少调优的成本。

    这是类加载的一种机制。即：当一个ClassLoader加载一个类时，除非明确指定，否则这个类所依赖和引用的类也由这个ClassLoader进行加载。

    双亲委派机制在代码中体现可以通过java.lang.ClassLoader中的loadClass()方法进行查看。

 委派的过程就是一层一层向上找的过程。只要当前加载器加载过，就不会重新加载。如果没有加载过，会向上寻找是否加载过。
    2. 当加载到Bootstrap ClassLoader后会一层一层的向下判断是否可以进行加载，如果能加载则加载。如果不能加载向下一层寻找下个加载器是否能加载。如果到最后一层都无法加载则报ClassNotFoundException
    .

 加载：加载.class文件到内存。包含自定义类的字节码文件和依赖及引用的字节码文件。
    		
 链接：包含校验文件、静态变量申请内存赋初值、符号引用变成直接引用。
    		
 初始化：执行静态代码块和静态变量赋值。
    		
 运行。
    		
 卸载。

    create table student(
    	id int(11) primary key auto_increment,
    	name varchar(20),
    	subject varchar(20),
    	score double
    );
    
    insert into student values(1,'张三','语文',20);
    insert into student values(2,'张三','数学',30);
    insert into student values(3,'张三','英语',40);
    insert into student values(4,'李四','语文',50);
    insert into student values(5,'李四','数学',60);
    insert into student values(6,'李四','英语',70);

    select 
    	max(if(subject='语文',score,0)) 语文,
    	max(if(subject='数学',score,0)) 数学,
    	max(if(subject='英语',score,0)) 英语,
    	name 
    from student group by name;

    select 
    	max(case subject when '语文' then score else 0 end) 语文,
    	max(case subject when '数学' then score else 0 end)  数学,
    	max(case subject when '英语' then score else 0 end)  英语,
    	name 
    from student group by name;

 客户端向服务器端发送SQL命令和连接参数
    
    2. 服务器端连接模块连接并验证
    
    3. 缓存模块解析SQL为Hash并与缓存中Hash表对应。如果有结果直接返回结果，如果没有对应继续向下执行。如果是MySQL 8 是没有查询缓存的。
    
    4. 解析器解析SQL为解析树，检查关键字相关问题，如果出现错误，报SQL解析错误。如果正确，继续执行
    
    5. 预处理器对解析树继续处理检查表、列别名等，处理成功后生成新的解析树。
    
    6. 优化器根据开销自动选择最优执行计划，生成执行计划
    
    7. 执行器执行执行计划，访问存储引擎接口
    
    8. 存储引擎访问物理文件并返回结果
    
    9. 如果开启查询缓存，缓存管理器把结果放入到查询缓存中。
    
    10. 返回结果给客户端

    system > const > eq_ref > ref > fulltext > ref_or_null > index_merge > unique_subquery > index_subquery > range > index > ALL

    create table teacher(
    	tid int(11) primary key auto_increment,
    	tname varchar(20)
    );
    insert into teacher values(1,'老师1');
    insert into teacher values(2,'老师2');
    
    create table student(
    	sid int(11) primary key auto_increment,
    	sname varchar(20),
    	stid int(11),
    	constraint  fk_t_s foreign key (stid) references teacher(tid)
    );
    
    insert into student values(1,'学生1',1);

    explain select * from (select * from student  limit 0,1) t;

    explain select * from student s,teacher t where s.stid=t.tid;

    explain select * from student where stid=1;
    explain select * from student where stid=1 and sname='学生1';

    explain select * from student where stid=3 or  stid is null;

    alter table student add column (age int(11));
    create unique index bbb on student(age);
    insert into student values (2,'学生2',2,12);
    insert into student values (3,'学生3',2,13);
    explain select * from student where stid=1 or age=1;

    explain select t.tid in (select s.sid from student s) from teacher t

    explain select t.tid in (select s.stid from student s) from teacher t

    explain select * from student where sid between 1 and 5

    explain select count(*) from student;

    explain select * from student where sname='学生';

    索引和数据都是存储在.idb文件（InnoDB引擎），默认MySQL使用B+Tree（InnoDB引擎）结构进行存储索引数据，也可以修改为Hash索引。
    B+Tree就是基于B-Tree而来的，主要是非叶子节点只存储键的信息；数据都记录在叶子节点上；所有叶子节点都有都有一个链式指针。

    第一、通过创建唯一性索引，可以保证数据库表中每一行数据的唯一性。 
    
    第二、可以大大加快数据的检索速度，这也是创建索引的最主要的原因。 
    
    第三、可以加速表和表之间的连接，特别是在实现数据的完整性方面特别有意义。 
    
    第四、在使用分组和排序子句进行数据检索时，同样可以显著减少查询中分组和排序的时间。 
    
    第五、通过使用索引，可以在查询的过程中，使用查询优化器，提高系统的性能。

    第一、创建索引和维护索引要耗费时间，这种时间随着数据量的增加而增加。 
    
    第二、索引需要占物理空间，除了数据表占数据空间之外，每一个索引还要占一定的物理空间。如果要建立聚簇索引，那么需要的空间就会更大。 
    
    第三、当对表中的数据进行增加、删除和修改的时候，索引也要动态的维护，这样就降低了数据的维护速度。

    第一、在经常需要搜索的列上，可以加快搜索的速度； 
    
    第二、在作为主键的列上，强制该列的唯一性和组织表中数据的排列结构； 
    
    第三、在经常用在连接的列上，这些列主要是一些外键，可以加快连接的速度； 
    
    第四、在经常需要根据范围进行搜索的列上创建索引，因为索引已经排序，其指定的范围是连续的； 
    
    第五、在经常需要排序的列上创建索引，因为索引已经排序，这样查询可以利用索引的排序，加快排序查询时间； 
    
    第六、在经常使用在WHERE子句中的列上面创建索引，加快条件的判断速度。

    第一，对于那些在查询中很少使用或者参考的列不应该创建索引。这是因为，既然这些列很少使用到，因此有索引或者无索引，并不能提高查询速度。相反，由于增加了索引，反而降低了系统的维护速度和增大了空间需求。 
    
    第二，对于那些只有很少数据值的列也不应该增加索引。这是因为，由于这些列的取值很少，例如人事表的性别列，在查询的结果中，结果集的数据行占了表中数据行的很大比例，即需要在表中搜索的数据行的比例很大。增加索引，并不能明显加快检索速度。 
    
    第三，对于那些定义为text, image和bit数据类型的列不应该增加索引。这是因为，这些列的数据量要么相当大，要么取值很少。 
    
    第四，当修改性能远远大于检索性能时，不应该创建索引。这是因为，修改性能和检索性能是互相矛盾的。当增加索引时，会提高检索性能，但是会降低修改性能。当减少索引时，会提高修改性能，降低检索性能。因此，当修改性能远远大于检索性能时，不应该创建索引。

    create table demo(
    	id int(11) primary key,
    	col1 int,
    	col2 int,
    	col3 varchar(20)
    );

1 普通索引：不考虑过多情况，主要是为了让查询更快一些。
    	语法：create index 索引名 on 表名(列)
    		例如：create index index1 on demo(col1);
    
    1.2 唯一索引：列中值不可以重复，可以是null
    	语法：create unique index 索引名 on 表名(列)
    		例如：create unique index index2 on demo(col2);
    
    1.3 主键索引：列中值不可以重复，又不可以为null。简单点理解不允许为null的列添加上唯一索引就是主键索引。

    		语法：create index 索引名 on 表名(列1，列2...)
    
    	例如：create index index3 on demo(col1,col2,col3)

    	语法：create fulltext index 索引名 on 表名(列)

    create table tb_fulltext(
    	id int(11) primary key auto_increment,
    	name varchar(100),
    address varchar(200)
    );

    CREATE FULLTEXT INDEX index_name ON table_name(column(length))
    
    TABLE table_name ADD FULLTEXT index_name( column)
    
    CREATE TABLE table_name (id int not null auto_increment,title varchar(30) ,PRIMARY KEY(id) ,  FULLTEXT  index_name (title))

    insert into tb_fulltext values(1,'tony','beijing yizhuang');
    
    insert into tb_fulltext values(2,'kevin','beijing yizhuang jingkaiqu');
    
    insert into tb_fulltext values(3,'jordan','beijing daxing');
    
    explain select * from tb_fulltext where match(name,address) against('yizhuang');
    
    select * from tb_fulltext where match(name) against('yizhuang');// 执行报错

    	自然语言模式：IN NATURAL LANGUAGE MODE
    	布尔模式：IN BOOLEAN MODE
    	查询扩展模式：WITH QUERY EXPANSION

    drop index ft on tb_fulltext;
    create fulltext index ft on tb_fulltext(address);
    select * from tb_fulltext where match(address) against('daxing');

     	+   一定要有(不含有该关键词的数据条均被忽略)。 
    	
    	-   不可以有(排除指定关键词，含有该关键词的均被忽略)。 
    	
    	>   提高该条匹配数据的权重值。 
    	
    	<   降低该条匹配数据的权重值。
    	
    	~   将其相关性由正转负，表示拥有该字会降低相关性(但不像 - 将之排除)，只是排在较后面权重值降低。 
    	
    	*   万用字，不像其他语法放在前面，这个要接在字符串后面。 因为搜索时只能满足最左前缀搜索like ‘内容%’，不能实现类似like ‘%内容%’这种。
    	
    	" " 用双引号将一段句子包起来表示要完全相符，不可拆字。

    # daxin* 可以搜索到内容。 daxin 不能搜索到内容
    
    explain select * from tb_fulltext where match(address) against('daxin*' in boolean mode);

    insert into tb_fulltext values(4,'kelvin','hebei baoding');
    
    # 结果查询到三行，id为4的没有被查询出来。因为daxing相关的词条有beijing、所有包含beijing的都被查询出来了。
    
    explain select * from tb_fulltext where match(address) against('daxing' with query expansion);

    	ngram_token_size=2

    create fulltext index index3 on ft(address)  with parser ngram;

    磁盘需要一段时间才能找到一段数据。对于现代磁盘来说，这种平均时间通常低于10ms，因此理论每秒100次寻找。这一次用新的磁盘缓慢地改进，并且对于单个表是很难优化的。优化查找时间的方法是将数据分发到一个以上的磁盘上。

    当磁盘处于正确位置时，我们需要读取或写入数据。使用现代磁盘，一个磁盘可以提供至少10到20Mb/s的吞吐量。这比磁盘寻找更容易优化，因为您可以从多个磁盘并行读取。

    当数据在主存储器中时，我们必须处理它以得到结果。与内存量相比，具有大数据库量的表是最常见的限制因素。但是对于小表来说，速度通常不是问题。

    当CPU需要比CPU缓存中更多的数据时，主存储器带宽成为瓶颈。对于大多数系统来说，这是一个不常见的瓶颈，但也是一个需要注意的点

    1 表结构是否正确（Are the tables structured properly?）：
    	特别的是列是否具有正确的类型，和表中列的个数是否正确。
    	例如：对于执行频繁更新的应用通常设计更多表，每个表的列并不多。而对于需要进行大量分析的应用通常设计更少的表，而每个表的列更多一些。
    
    2 正确的设置索引达到查询高效（Are the right indexes in place to make queries efficient?）：
    	需要考虑的是什么SQL会导致索引无效，什么情况会让查询效率更高
    
    3 对于不同情况选择不同的存储引擎（Are you using the appropriate storage engine for each table, and taking advantage of the strengths and features of each storage engine you use? ）
    	选择不同的存储引擎对性能和可伸缩性具有较大的影响
    
    4 每张表是否具有适当的行格式（Does each table use an appropriate row format?）：
    	主要取决于适当的存储引擎。压缩表可以占用更低的磁盘空间和更少的I/O操作。压缩表适用于InnoDB和MyISM存储引擎。
    
    5 应用程序是否使用适当的锁策略（Does the application use an appropriate locking strategy? ）：
    	在具有高并发、分布式应用程序中，选择适当的锁策略以保证数据的共享性和特定的情况下独占数据。
    	InnoDB存储引擎在不需要我们参与下能处理大部分锁问题，允许数据库实现更好的并发性，减少代码调优量。
    
    6 所有缓存区域使用的大小是否都正确（Are all memory areas used for caching sized correctly?）：
    	配置的原则是缓存区域大到足以容纳所有频繁访问的数据，但又不能太大，否则导致过量占用物理内存而导致分页。
    	一般情况下需要配置InnoDB的缓冲池、MyISAM密钥缓存和MySQL的查询缓存

    	注意：优化有风险，涉足需谨慎！

    	1 优化不总是对一个单纯的环境进行，还很可能是一个复杂的已投产的系统。
    	
    	2 优化手段本来就有很大的风险，只不过你没能力意识到和预见到！
    	
    	3 任何的技术可以解决一个问题，但必然存在带来一个问题的风险！
    	
    	4 对于优化来说解决问题而带来的问题,控制在可接受的范围内才是有成果

    	1 稳定性和业务可持续性,通常比性能更重要！
    	
    	2 优化不可避免涉及到变更，变更就有风险！
    	
    	3 优化使性能变好，维持和变差是等概率事件！
    	
    	4 切记优化,应该是各部门协同，共同参与的工作，任何单一部门都不能对数据库进行优化！

    	优化成本:硬件>系统配置>数据库表结构>SQL及索引
    	
    	优化效果:硬件<系统配置<数据库表结构<SQL及索引

    !=、<>、not in、not exists、not like 等
    explain select * from teacher where address !='aa';

1.	避免使用or逻辑
    应尽量避免在 where 子句中使用 or 来连接条件，否则将导致引擎放弃使用索引而进行全表扫描，如：
    select id from t where num=10 or num=20
    
    可以这样查询：
    	select id from t where num=10
    	union all	
    	select id from t where num=20	
    在MySQL5.7 开始or已经可以触发索引了，老版本不可以。
    
    1.2.	慎用in和not in逻辑
    	in可以代替union all操作，虽然对CPU性能稍微增加一些，但是也可以忽略不计了。
    	
    	in 和 not in 也要慎用，否则会导致全表扫描，如：
    	select id from t1 where num in(select id from t2 where id > 10)
    	
    	此时外层查询会全表扫描，不使用索引。可以修改为：
    	
    	select id from t1,(select id from t1 where id > 10)t2 where t1.id = t2.id
    	
    	此时索引被使用，可以明显提升查询效率。

    			select id from t where num/2=100

    		select id from t where num=100*2

    select id from t where substring(name,1,3)='abc'--name以abc开头的id

    select id from t where name like 'abc%'

    不要在 where 子句中的“=”左边进行函数、算术运算或其他表达式运算，否则系统将可能无法正确使用索引。

    select id from t where name like '%abc%'

    模糊查询如果是必要条件时，可以使用select id from t where name like 'abc%'来实现模糊查询，此时索引将被使用。
    如果头匹配是必要逻辑，建议使用全文搜索引擎（Elastic search、Lucene、Solr等）。

    select num from a where num in(select num from b)

    select num from a where exists(select 1 from b where num=a.num)

    并不是所有索引对查询都有效，SQL是根据表中数据来进行查询优化的，当索引列有大量数据重复时，SQL查询可能不会去利用索引，如一表中有字段sex，male、female几乎各一半，那么即使在sex上建了索引也对查询效率起不了作用。

    不使用*、尽量不使用union，union all等关键字、尽量不使用or关键字、尽量使用等值判断。

    对串列进行索引，如果可能应该指定一个前缀长度。例如，如果有一个CHAR(255)的列，如果在前10个或20个字符内，多数值是惟一的，那么就不要对整个列进行索引。短索引不仅可以提高查询速度而且可以节省磁盘空间和I/O操作。
    CREATE  INDEX  index_name  ON  table_name (column(length))

    MySQL查询只使用一个索引，因此如果where子句中已经使用了索引的话，那么order by中的列是不会使用索引的。因此数据库默认排序可以符合要求的情况下不要使用排序操作；尽量不要包含多个列的排序，如果需要最好给这些列创建复合索引。

    一般情况下不鼓励使用like操作，如果非使用不可，如何使用也是一个问题。like “%aaa%” 不会使用索引，而like “aaa%”（非前导模糊查询）可以使用索引。
    使用后，优化到range级别
    explain select * from teacher where address like '%oracle%';

    alter table teacher add column (age int(3));
    alter table teacher add column (weight int(3));
    select * from teacher;
    update teacher set age=10,weight=90 where id = 1;
    update teacher set age=20,weight=100 where id = 2;
    update teacher set age=30,weight=110 where id = 3;
    
    create index age_index on teacher(age);
    create index weight_index on teacher(weight);
    
    explain select * from teacher where age between 10 and 20 and weight between 90 and 100;

    当列是文本类型时，把数值类型当作列的条件会弃用索引
    explain select * from teacher where name = 20;

    **MySQL中锁按照不同分类标准有多种分类。**

    		SQL语句：
    				select .... lock in share mode;

    		SQL：
    			select .... for update;

    create table teacher(
    	tid int(11) primary key,
    	tname varchar(20)
    );
    
    insert into teacher values(1,'老师1');
    insert into teacher values(2,'老师2');
    insert into teacher values(3,'老师3');
    
    create table student(
    	sid int(11) primary key,
    	sname varchar(20),
    	stid int(11)
    );
    
    insert into student values(1,'学生1',1);
    insert into student values(2,'学生2',1);
    insert into student values(3,'学生3',2);
    insert into student values(4,'学生4',null);

    		select * from student s,teacher t;

    select * from student s inner join teacher t on s.stid=t.tid;
    
    select * from student s,teacher t where s.stid=t.tid;

    select * from student s left outer join teacher t on s.stid=t.tid;
    
    select * from teacher t left outer join student s on s.stid=t.tid;

    select * from student s right outer join teacher t on s.stid=t.tid;
    
    select * from teacher t right outer join student s on s.stid=t.tid;

    在InnoDB引擎中count(*)和count(1)性能没有什么差别
    count(列)需要看列和count(*)优化后的列情况，如果count(列)使用了非索引列，而表中包含索引列则count(*)更快。
    如果count（列）和count(*)优化后的是同一个列则性能没有什么差别。如果表中没有索引则count（列）和count(*)性能也没有什么差别。

 客户端发起URL请求
    
    2. 判断URL是否是登录URL，如果不是登录URL执行十一个Filter内置Filter功能实现。所有Filter都是通过FilterChainProxy进行协调。最终跳转到登录页面。
    
    3. 如果是登录URL，依然执行内置Filter链，其中UsernamePasswordAuthenticationFilter负责获取到请求中的用户名和密码，并把用户名和密码封装到UsernamePasswordAuthenticationToken中。
    
    4. 通过AuthenticationManager调用自定义登录逻辑UserDetailsService
    
    5. 把返回结果UserDetails交给AuthenticationProvider进行处理
    
    
    6. 根据处理结果调用成功处理器或失败处理器显示最终结果。

    如果同一个目录下，有application.yml也有application.properties，默认先读取application.properties。
    
    如果同一个配置属性，在多个配置文件都配置了，默认使用第1个读取到的，后面读取的不覆盖前面读取到的。

    		config/application.properties
    		
    		config/application.yml
    		
    		application.properties
    		
    		application.yml
    		
    		resources/config/application.properties
    		
    		resources/config/application.yml
    		
    		resources/application.properties
    		
    		resources/application.yml

    	@SpringBootApplication 启动器注解。
    	
    	@SpringBootTest 测试类注解。

    		@EnableAutoConfiguration 启动自动化配置
    		
    		@ConditionalOnBean 容器中存在指定Bean时才会去创建Bean
    		
    		@ConditionalOnClass 当前项目如果能找到指定类时才会创建这个类的Bean
    		
    		@ConditionalOnSingleCandidate 当容器中存在一个时或者虽然有多个但是指定首选Bean
    		
    		@EnableConfigurationProperties 启动配置属性类
    		
    		@AutoConfigureAfter 在加载配置类后在加载当前类
    		
    		@ConfigurationProperties 定义属性前缀
    		
    		@ConditionalOnMissingBean 只有当容器中不存在指定Bean时才会去实例化。

    	SpringBoot项目通过SpringApplication.run()作为启动入口
    		
 进入SpringApplication构造方法，从META-INF/spring.factories中读取初始化和监听器，并记录主类。
    		
 创建计时器StopWatch
    		
 声明上下文对象ConfigurableApplicationContext
    		
 启动Headless服务器，设置系统属性
    		
 创建并启动运行时监听器
    		
 准备环境Environment并打印Banner
    		
 上下文环境准备及刷新，此时Tomcat被启动。
    		
 停止计时器，并打印启动时间。
    		
 运行时监听器启动。
    		
 返回上下文对象。

    以mybatis-spring-boot-starter举例，分析得出重要角色：
    
    mybatis-spring-boot-autoconfigure项目包含：
    	MyBatisAutoConfiguration自动化配置类
    	MyBatisProperties 支持的配置属性

    在@SpringBootAutoConfiguration注解中包含了
    @EnableAutoConfiguration注解。在SpringBoot项目启动时会自动加载META-INF/spring.factories中EnableAutoConfiguration内容

启动类中@SpringBootApplication中包含@EnableAutoConfiguration
    
    2.加载项目依赖的META-INF/spring.factories中EnableAutoConfiguration对应类，进行实例化。
    
    3. 实例化自动化配置类时会同时加载属性类，从配置文件中读取。
    
    4. 生效自动化配置，把对应的Bean放入到Spring容器中。

    xxx-spring-boot-autoconfigure:里面编写自动化配置相关内容。
    xxx-spring-boot-starter：只是一个依赖，依赖xxx-spring-boot-autoconfigure

    <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.5.5</version>
    </parent>
    <dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-autoconfigure</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <optional>true</optional>
    </dependency>
    </dependencies>

    @ConfigurationProperties(prefix = "bjsxt")
    public class BjsxtProperties {
    private String name;
    private int age;
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    }

    org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.bjsxt.starter.BjsxtAutoConfiguration

    <dependencies>
    <dependency>
        <groupId>com.bjsxt</groupId>
        <artifactId>bjsxt-spring-boot-autoconfigure</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
    </dependencies>

    @SpringBootTest
    class DemoApplicationTests {
      @Autowired
      private BjsxtProperties bjsxtProperties;
      @Test
      void contextLoads() {
    System.out.println(bjsxtProperties.getName());
    System.out.println(bjsxtProperties.getAge());
      }
    }

 创建自动化配置项目 xxx-spring-boot-autoconfigure
    		
 在项目中提供自定义属性类，添加自定义属性。在类上添加@ConfigurationProperties
    		
 再创建一个自动化配置类。添加@Configuration、@EnableConfigrationProperties
    		
 在类路径下添加META-INF/spring.factories设置自动化配置类的全限定路径。
    		
 打包项目后新建xxx-spring-boot-starter,并且在启动器项目中添加上自动化配置项目的依赖。

    	.properties 格式为key=value形式
    	
    	.yml 格式为key: value 采用树状结构
    	
    	 yaml 格式和yml 格式相同。

    POM(Project Object Model)即项目对象模型，在Maven中使用pom.xml进行体现，声明式配置。
    可以在pom.xml中可以配置项目与项目的关系，插件等信息。
    POM模型中认为每个项目都是一个对象，项目和项目之间可以存在关系：依赖、继承、聚合。
    通过坐标引用其他项目的jar。如果引用时本地仓库不存在，会从中央仓库中下载到本地仓库。

    依赖：当一个项目需要使用另一个项目的类时可以设置为依赖关系。由于Maven具有依赖传递性，有时也通过依赖替代继承来获取到另一个项目的pom.xml（Spring Cloud）。
    继承：当一个项目需要继承另一个项目的pom.xml时，可以设置为继承关系。Maven中只支持单继承。
    聚合：聚合是在一个窗口中通过一个父项目管理整个项目的pom.xml，方便进行版本管理、依赖管理等。

    继承关系是指子项目可以继承父项目的pom.xml中配置。
    子项目中需要通过<parent>配置父项目的坐标，子项目的groupid和version都可以和父项目的不同。父项目中没有任何子项目的信息。
    
    聚合项目时父项目类型为pom类型，父项目和子项目都存在一个窗口中，可认为是一个项目，但是每个子项目又可以独立运行。
    在聚合项目中子项目需要通过<parent>配置父项目的坐标，子项目和父项目的groupid和version都和父项目的相同。父项目通过<modules>配置聚合的子项目。

    Maven项目中项目类型是在pom.xml中通过<packaging>进行配置的。可取值：
    jar:默认值，表示打包为jar类型项目。
    war：web项目。当需要打包为servlet容器支持时，需要配置此类型。
    pom：逻辑父项目。聚合项目中父项目的类型。当设置为pom时Maven只解析pom.xml，不会编译src中内容。在idea中创建聚合项目时，自动会把父项目设置为pom类型。

    mvn help:system 打印系统属性和环境变量。
    mvn clean 清理target目录。
    
    mvn validate 验证项目是否可用。
    mvn compile 编译项目，生成target目录。
    mvn test 执行测试。
    
    执行测试时会自动运行src/test/java 目录下所有
    **/*Test.java、**/Test*.java、**/*TestCase.java 文件，采用约定方式执行。
    
    mvn package 打包项目。
    mvn deploy 发布项目。
    mvn verify 校验包是否正确。
    mvn install 安装到本地仓库。
    mvn install -DskipTests 跳过测试
    mvn site 生成站点。但是需要添加插件才能使用。

    <build>
    <plugins>
        <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-project-info-reports-plugin</artifactId>
                <version>2.7</version>
        </plugin>
    </plugins>
    </build>

    无论是IDEA还是Eclipse，默认的Java项目就是使用Ant进行项目管理的。
    在老Ant项目需要自己添加build文件，但是在目前的java项目中都不需要自己进行管理，
    都可以通过idea或eclipse帮助进行管理即可。

    MVC是一种软件开发模式，是目前Java项目使用的最多的一种软件开发模式。因为Sun公司推荐JavaEE开发使用MVC模式。针对于MVC，Sun公司也推出了JSP Model1和JSP Model2，我们现在使用的就是JSP Model 2。
    
    MVC适用于中大型项目，开发时由底层向上层开发，越底层复用性越高。
    
    MVC把项目由单一大文件拆分成多个部分。包含：
    
    	M(Model)即模型。包含数据模型和业务模型。数据模式就是项目中的实体类，实现了数据封装的重用性。业务模型就是项目中的Service，业务类。
    	
    	V（View）即视图。视图就是呈现给用户的具体内容，如数据表格显示，树状菜单。目前已经发展成了一个独立岗位，前后端分离开发时的前端工程师就负责的是V。
    	
    	C(Controller）即控制器。在以前的项目中控制器主要的作用是根据业务模型和数据模

    	MultipartResovler：多部分处理器。文件上传时需要使用。
    	
    	LocaleResolver：解决客户端的区域和时区问题。
    	
    	ThemeResolver：主题解析器。刻提供自定义布局。
    	
    	HandlerMapping: 映射处理器。主要负责处理URL，并找到对应的Handler
    	
    	HandlerAdapter：适配器。负责调用具体的Handler。
    		
    	HandlerExceptionResovler:异常处理器。异常处理，根据不同异常返回视图。
    	
    	RequestToViewNameTranslator：从请求中获取到视图名称。
    	
    	ViewResovler:视图解析器，负责解析字符串视图名和物理视图文件的。
    	
    	FlashMapManager：主要用于存储属性的，本质是一个Map。多用在重定向时。FlashMap在重定向之前存储，重定向之后删除。
    	
    	ModelAndView：模型和视图。Spring MVC中提供的模型和视图接口。
    	
    	HandlerInterceptor：拦截器。拦截控制器资源的。

 客户端向服务端发起请求，当URL匹配后执行DispatcherServlet
    	
    	2. DispatcherServlet根据URL类型调用HandlerMapping
    	
    	3. HandlerMapping查找Handler后产生HandlerExecutionChain
    	
    	4. HandlerExecutionChain中包含Handler和Interceptor返回给DispatcherServlet
    	
    	5. DispatcherServlet根据Handler类型调用HandlerAdapter
    	
    	6. HandlerAdapter调用Handler进行执行。
    	
    	7. Handler执行完成后返回ModelAndView
    	
    	8. ModelAndView返回给DispatcherServlet
    	
    	9. DispatcherServlet调用ViewResovler处理视图
    	
    	10. DispatcherServlet响应结果给客户端

    		@Controller 定义控制器
    		
    		@RestController 等效 @Controller+@ResponseBody
    		
    		@ControllerAdvice 基于Spring框架的异常通知实现。
    		
    		@RequestMapping 定义映射路径
    		
    		@PutMapping 接收put请求，整体更新
    		
    		@PatchMapping 属于对Put的补充，局部更新
    		
    		@DeleteMapping 接收delete请求
    		
    		@PostMapping 接收post请求
    		
    		@GetMapping 接收get请求
    		
    		@ResponseBody 把返回值转换为json并设置到响应体中
    		
    		@CrossOrigin 允许跨域，在响应头添加Access-Control-Allow-Origin属性
    		
    		@ExceptionHandler 异常处理
    		
    		@RequestParam 处理请求参数
    		
    		@RequestHeader 接收请求头
    		
    		@RequestBody 把请求体数据转换为对象
    		
    		@SessionAttribute 获取Session作用域的值
    		
    		@PathVariable 获取restful请求参数

 IoC和DI是一件事。IoC又称DI，DI又称IoC。它是一个过程
    
    2. bean的创建和管理都是由容器完成，这个过程就是对象控制权的反转，也就是IoC
    
    3. 容器创建对象的过程难免需要给对象中属性进行赋值，尤其是属性是类类型，需要使用容器中另一个Bean，
    	就需要从容器中获取另一个Bean注入到当前Bean。这个过程就是DI这个过程也是IoC。
    
    4. 给对象属性设置值有二种方式：构造方法、set方法。
    对应的代码：

    <bean id="teacher" class="com.bjsxt.pojo.Teacher"></bean>
    <bean id="student" class="com.bjsxt.pojo.Student">
    <property name="teacher" ref="teacher"></property>
    </bean>

    FileSystemResource fsr = new FileSystemResource("D:\ ideaws\ spring1\ src\ applicationContext.xml");
    
    XmlBeanFactory xmlBeanFactory = new XmlBeanFactory(fsr);
    
    Object teacher = xmlBeanFactory.getBean("teacher");
    
    System.out.println(teacher);

    但是从Spring 3.1 版本开始，使用

    DefaultListableBeanFactory和XMLBeanDefinitionReader替代了。
    
    DefaultListableBeanFactory defaultListableBeanFactory = new DefaultListableBeanFactory();
    
    XmlBeanDefinitionReader xmlBeanDefinitionReader = new XmlBeanDefinitionReader(defaultListableBeanFactory);
    
    xmlBeanDefinitionReader.loadBeanDefinitions(new FileSystemResource("D:\ ideaws\ spring1\ src\ applicationContext.xml"));
    
    Object teacher = defaultListableBeanFactory.getBean("teacher");

 AOP 功能
    2. 国际化（MessageSource）
    3. 访问资源，如URL和文件（ResourceLoader）
    4. 消息发送机制（ApplicationEventPublisher）
    5. Spring集成Web时的WebApplicationContext

    ClassPathXmlApplicationContext
    ClassPathXmlApplicationContext applicationContext =
        new ClassPathXmlApplicationContext("applicationContext.xml");
    Object teacher = applicationContext.getBean("teacher");

    <bean id="teacher" class="com.bjsxt.pojo.Teacher" lazy-init="true"></bean>

    no：不自动注入。
    
    default：默认值。根据default-autowire=”"配置进行自动注入。如果autowire和default-autowire都没有配置时等效于no。
    
    byName：通过名称自动注入。要求必须存在自定
    
    byType：通过类型进行注入。如果存在多个相同类型的Bean，会报NoUniqueBeanDefinitionException
    
    constructor：通过构造方法进行注入。默认按照构造方法参数byName进行注入，如果没有找到与参数同名的bean，会按照byType进行注入。如果Spring容器中存在多个相同类型的bean时，也不会报错，但是不会注入。

    面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。
    			
    AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，
    
    是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，
    
    从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

    	日志记录，性能统计，安全控制，事务处理，异常处理等等。

    将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，
    
    通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，
    
    进而改变这些行为的时候不影响业务逻辑的代码。

     ①    BeforeAdvice

     ②	AfterReturningAdvice
     ③	MethodInterceptor
     ④	ThrowAdvice

    <bean id="myBefore" class="com.bjsxt.aop.MyBefore"></bean>
    <bean id="myafter" class="com.bjsxt.aop.MyAfter"></bean>
    <bean id="myarround" class="com.bjsxt.aop.MyArround"></bean>
    <bean id="mythrow" class="com.bjsxt.aop.MyThrow"></bean>
    <aop:config proxy-target-class="false">
    <aop:pointcut id="mingcheng" expression="execution(* com.bjsxt.aop.Demo.*(..))"/>
    <aop:advisor advice-ref="myarround" pointcut-ref="mingcheng"></aop:advisor>
    <aop:advisor advice-ref="myBefore" pointcut-ref="mingcheng"></aop:advisor>
    <aop:advisor advice-ref="myafter" pointcut-ref="mingcheng"></aop:advisor>
    <aop:advisor advice-ref="mythrow" pointcut-ref="mingcheng" ></aop:advisor>
    </aop:config>

    前置通知、后置通知、环绕通知、异常通知。
    可以使用AOP中的Schema-based或AspectJ方式实现。
    其中AspectJ中后置通知又分为：after和after-returning,after无论切点是否出现异常都执行的后置通知，after-returning只有在切点正常执行完成，才会触发的通知。

    <tx:advice id="txAdvice" transaction-manager="txManager">
    <tx:attributes>
        <tx:method name="insert*" isolation="SERIALIZABLE"/>
        <tx:method name="delete*" propagation="MANDATORY"/>
        <tx:method name="update*" rollback-for="java.lang.Exception" no-rollback-for="java.lang.Exception" />
        <tx:method name="select*" read-only="true"/>
    </tx:attributes>
    </tx:advice>
    
    <aop:config>
    <aop:pointcut id="mypoint" expression="execution(* com.bjsxt.service.impl.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="mypoint"></aop:advisor>
    </aop:config>

    默认值。如果当前有事务则加入到事务中。如果当前没有事务则新增事务。

    必须在非事务状态下执行,如果当前没有事务,正常执行,如果当前有事务,报错.

    必须在事务状态下执行.如果没有事务,新建事务,如果当前有事务,创建一个嵌套事务.

    必须在事务中执行,如果当前没有事务,新建事务,如果当前有事务,把当前事务挂起. 在重新建个事务。

    如果当前有事务就在事务中执行,如果当前没有事务,就在非事务状态下执行.

    必须在非事务下执行,如果当前没有事务,正常执行,如果当前有事务,把当前事务挂起.

    必须在事务内部执行,如果当前有事务,就在事务中执行,如果没有事务,报错.

    事务A没有提交事务，事务B读取到事务A未提交的数据，这个过程称为脏读。读取到的数据叫做脏数据。

    当事务A读取到表中一行数据时，同时另一个事务修改这行数据，事务A读取到的数据和表中真实数据不一致。

    事务A对表做查询全部操作，事务B向表中新增一条数据。事务A查询出来的数据和表中数据不一致，称为幻读。

    	服务提供者（Application Service）不可用。如：硬件故障、程序BUG、缓存击穿、并发请求量过大等。
    	
    	重试加大流量。如：用户重试、代码重试逻辑等。
    	
    	服务调用者（Application Client）不可用。如：同步请求阻塞造成的资源耗尽等。

    ```java
    <dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
    </dependency>

    降级
    
    降级是指，当请求超时、资源不足等情况发生时进行服务降级处理，不调用真实服务逻辑，而是使用快速失败（fallback）方式直接返回一个托底数据，保证服务链条的完整，避免服务雪崩。
    解决服务雪崩效应，都是避免application client请求application service时，出现服务调用错误或网络问题。处理手法都是在application client中实现。我们需要在application client相关工程中导入hystrix依赖信息。并在对应的启动类上增加新的注解@EnableCircuitBreaker，这个注解是用于开启hystrix熔断器的，简言之，就是让代码中的hystrix相关注解生效。
    
    ```java
    17	新建ApplicationServiceDemo
    18	配置pom.xml
    <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.5.RELEASE</version>
    </parent>
    <dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Hoxton.SR3</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
    </dependencyManagement>
    <dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    </dependencies>
    19	新建配置文件
    新建application.yml
    spring:
      application:
    name: application-service-demo
    eureka:
      client:
    service-url:
      defaultZone: http://eurekaserver1:8761/eureka/
    20	新建控制器
    新建com.bjsxt.controller.DemoController
    @Controller
    public class DemoController {
    @RequestMapping("/demo")
    @ResponseBody
    public String demo(){
        return "demo-service";
    }
    }
    21	新建启动类
    新建com.bjsxt.DemoApplication
    @SpringBootApplication
    public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class,args);
    }
    }
    
    22	新建DemoFallback
    新建项目DemoFallback作为Application Client
    23	编写pom.xml
    <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.5.RELEASE</version>
    </parent>
    <dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Hoxton.SR3</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
    </dependencyManagement>
    <dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
    </dependency>
    </dependencies>
    24	新建配置文件
    新建application.yml
    注意不要端口号冲突
    spring:
      application:
    name: fallback-demo
    eureka:
      client:
    service-url:
      defaultZone: http://eurekaserver1:8761/eureka/
    
    
    server:
      port: 8081
    
    25	新建配置类
    新建com.bjsxt.config.RibbonConfig
    此处使用@LoadBalancer方式快捷配置负载均衡。
    @Configuration
    public class RibbonConfig {
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
    }
    26	新建service及实现类
    新建com.bjsxt.service.DemoService及实现类。
    实现类中@HystrixCommand的fallbackMethod配置的就是降级方法。
    myFallback方法：
    参数：和test的参数是相同的。
    返回值：和test中调用的application-service-demo/demo控制器方法返回值相同
    public interface DemoService {
    String test();
    }
    @Service
    public class DemoServiceImpl implements DemoService {
    @Autowired
    private RestTemplate restTemplate;
    @HystrixCommand(fallbackMethod = "myFallback")
    @Override
    public String test() {
        String result = restTemplate.postForObject("http://application-service-demo/demo", null, String.class);
        System.out.println(result);
        return result;
    }
    
    public String myFallback(){
        return "托底数据";
    }
    }
    
    27	新建控制器
    新建com.bjsxt.controller.FallbackController
    @Controller
    public class FallbackController {
    
    @Autowired
    private DemoService demoService;
    
    @RequestMapping("/demo")
    @ResponseBody
    public String demo(){
        return demoService.test();
    }
    }
    28	新建启动类
    @SpringBootApplication
    @EnableCircuitBreaker
    public class ApplicationClientApplication {
    
    public static void main(String[] args) {
        SpringApplication.run(ApplicationclientdemoApplication.class, args);
    }
    }
    29	访问
    在浏览器输入http://localhost:8081/demo
     
    30	测试降级
    停止ApplicationServiceDemo项目。再次访问

    @RequestMapping("/service")
    public String demo(String name){
    return "姓名："+name;
    }

    @RequestMapping("/service2")
    public List<String> demo2(@RequestBody List<String> names){
    System.out.println("接收到的内容："+names);
    List<String> list = new ArrayList<>();
    for (String name : names){
        list.add("姓名："+name);
    }
    return list;
    }

    Future<String> client(String name);
    @Override
    @HystrixCollapser(batchMethod = "myBatchMethod",scope = com.netflix.hystrix.HystrixCollapser.Scope.GLOBAL
    ,collapserProperties = {@HystrixProperty(name="timerDelayInMilliseconds",value="10"),@HystrixProperty(name="maxRequestsInBatch",value = "200")})
    public Future<String> client(String name) {
    System.out.println("client方法，有请求合并时将不支持这个方法");
    String result = restTemplate.getForObject("http://APPLICATION-SERVICE/service?name={1}", String.class, name);
    return null;
    }
    
    @HystrixCommand
    public List<String> myBatchMethod(List<String> name){
    System.out.println("传递过去的参数："+name);
    List<String> list = restTemplate.postForObject("http://APPLICATION-SERVICE/service2", name, List.class);
    return list;
    }

    @RequestMapping("/client")
    public String client(){
    try {
        Future<String> f1 = clientService.client("张三");
        Future<String> f2 = clientService.client("李四");
        System.out.println("f1："+f1.get());
        System.out.println("f2："+f2.get());
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }
    return "ok";
    }
    @RequestMapping("/client")
    public String client(){
    try {
        Future<String> f1 = clientService.client("张三");
        Future<String> f2 = clientService.client("李四");
        System.out.println("f1："+f1.get());
        System.out.println("f2："+f2.get());
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }
    return "ok";
    }

    @HystrixCommand(groupKey = "jqk",commandKey = "abc",threadPoolKey = "jqk",threadPoolProperties = {
        @HystrixProperty(name="coreSize",value="8"),
        @HystrixProperty(name="maxQueueSize",value="5"),
        @HystrixProperty(name="keepAliveTimeMinutes",value="2"),
        @HystrixProperty(name="queueSizeRejectionThreshold",value="5")
    })
    @Override
    public String thread() {
    System.out.println(Thread.currentThread().getName());
    return "thread1";
    }
    
    @Override
    public String thread2() {
    System.out.println(Thread.currentThread().getName());
    return "thread2";
    }

    @HystrixCommand(commandProperties = {
        @HystrixProperty(name=HystrixPropertiesManager.EXECUTION_ISOLATION_STRATEGY,value="SEMAPHORE"),
        @HystrixProperty(name=HystrixPropertiesManager.EXECUTION_ISOLATION_SEMAPHORE_MAX_CONCURRENT_REQUESTS,value="10")
    },fallbackMethod = "jqk")
    @Override
    public String semaphore() {
    System.out.println("执行了，访问service");
    return "结果";
    }

    	没有线程切换，性能好。

    所有请求处理共用一个线程池。所有接口相互影响更大。容易因为一个接口问题，导致其他接口同时出错。

    spring:
      application:
    name: hystrix-provider
    server:
      port: 8082
    eureka:
      client:
    service-url:
      defaultZone: http://eurekaserver1:8761/eureka/,http://eurekaserver2:8761/eureka/
    
    
    feign:
      hystrix:
    enabled: true

    <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.5.RELEASE</version>
    </parent>
    <dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Hoxton.SR3</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
    </dependencyManagement>
    <dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>
    </dependencies>

    @FeignClient(name = "eureka-application-provider", fallback = HystricService.HystrixServiceFallback.class)
    public interface HystricService {
    @PostMapping("/show1")
    Map<String, Object> show(@RequestParam String content);
    
    @Component
    class HystrixServiceFallback implements HystricService {
        @Override
        public Map<String, Object> show(String content) {
            System.out.println("执行方法，出现服务降级，返回托底数据");
            Map<String, Object> map = new HashMap<>();
            map.put("a", "因为Provider连接不上了，返回托底数据");
            return map;
        }
    }
    }

    @SpringBootApplication
    @EnableDiscoveryClient
    @EnableFeignClients
    public class HystrixApplication {
    public static void main(String[] args) {
        SpringApplication.run(HystrixApplication.class,args);
    }
    }

    hystrix: # hystrix 容灾配置
      command: # hystrix 命令配置，就是具体的容灾方案
    default: # 默认环境，相当于全局范围，后续的配置，参考HystrixPropertiesManager中的常量配置
      circuitBreaker: # 熔断配置， 常用。 其他配置不常用。
        enabled: true
        requestVolumeThreshold: 2
        sleepWindowInMilliseconds: 2000
        errorThresholdPercentage: 50

    当程序运行后会出现异常，异常信息如下

    Caused by: java.lang.IllegalArgumentException: Mapped Statements collection already contains value for com.bjsxt.mapper.StudentMapper.selectAll. please check com/bjsxt/mapper/StudentMapper.xml and com/bjsxt/mapper/StudentMapper.xml
    	at org.apache.ibatis.session.Configuration$StrictMap.put(Configuration.java:1014)
    	at org.apache.ibatis.session.Configuration$StrictMap.put(Configuration.java:970)
    	at org.apache.ibatis.session.Configuration.addMappedStatement(Configuration.java:768)
    	at org.apache.ibatis.builder.MapperBuilderAssistant.addMappedStatement(MapperBuilderAssistant.java:297)
    	at org.apache.ibatis.builder.xml.XMLStatementBuilder.parseStatementNode(XMLStatementBuilder.java:113)
    	at org.apache.ibatis.builder.xml.XMLMapperBuilder.buildStatementFromContext(XMLMapperBuilder.java:138)
    	at org.apache.ibatis.builder.xml.XMLMapperBuilder.buildStatementFromContext(XMLMapperBuilder.java:131)
    	at org.apache.ibatis.builder.xml.XMLMapperBuilder.configurationElement(XMLMapperBuilder.java:121)
    	... 13 more

    protected ReflectorFactory reflectorFactory = new DefaultReflectorFactory();

    <settings>
    <setting name="lazyLoadingEnabled" value="true"/>
    <setting name="aggressiveLazyLoading" value="false"/>
    </settings>

    <plugins>
    <plugin interceptor="com.bjsxt.plugin.PagePlugin"></plugin>
    </plugins>

    动态SQL本质就是SQL语句的拼接。根据不同条件产生不同的SQL语句。
    
    在MyBatis中动态SQL标签包含
    <if>、<choose>..<when>..<otherwise>、<trim>、<where>、<set>、<foreach>、<bind>七组标签。

    	A、HTML
       
    B、注释[java注释   HTML注释   JSP注释]
    
    C、Java代码 [小脚本  声明式  表达式]

    A、小脚本中定义java代码最后都会放到service方法中  声明定义代码最后都在方法外
    
     B、小脚本中定义所有变量都是局部变量 声明中定义变量是成员变量
     
     C、小脚本中不可以定义方法  声明中可以定义方法
    
     D、小脚本中可以使用JSP内置对象  声明中不可以使用JSP内置对象

    		JSP注释更优越  JSP减少网络带宽

    	   例如:out /resuest/response

    		  request---->HttpServletRequest;
    		 
    		  response---->HttpServletResponse;
    		  
    		  page-------->JspPage;  涵盖就是页面配置信息
    		  
    		  pageContext->PageContext;
    		  
    		  session----->HttpSession;
    		 
    		  application->ServletContext;
    		  
    		  config------>ServletConfig;
    		 
    		  out--------->PrintWriter;
    		  
    		  exception :需要在page上指定isErrorPage="true"

    <html>
    <head>
    <base href="<%=request.getContextPath()+"/"%>"/>
    <title>Title</title>
    </head>
    <body>
    
    <%--优点：任何服务器中任何资源都可以访问   缺点:路径书写比较长 比较麻烦--%>
      
      <h3>绝对路径(协议+IP+端口+跳转地址)</h3>
    <a href="http://127.0.0.1:8080/web05_war_exploded/path1/add.jsp">同一个项目中同一个目录中文件add.jsp</a><br/>
    <a href="http://127.0.0.1:8080/web05_war_exploded/path1/subpath/sub.jsp">同一个项目中子级目录中文件subpath/sub.jsp</a><br/>
    <a href="http://127.0.0.1:8080/web05_war_exploded/path2/update.jsp">同一个项目中同级目录中文件path2/update.jsp</a><br/>
    <a href="http://127.0.0.1:8080/web05_war_exploded/index.jsp">同一个项目中父级目录中文件index.jsp</a><br/>
    <a href="http://127.0.0.1:8080/web05_war_exploded/abc/PathServlet">同一个项目中Servlet如何访问</a><br/>
    <a href="http://127.0.0.1:8080/web04_war_exploded/index.jsp">web04项目中index.jsp文件(同一个服务器)</a><br/>
    <a href="http://www.bjsxt.com">北京尚学堂官网如何访问(不同服务器)</a><br/>
    
    
    <%--优点:路径书写方式比较简单  缺点:只可以访问同一个服务器中项目--%>
    
      <h3>根路径(必须/开始 后面紧跟【项目上下文】 +访问地址)</h3>
    <a href="/web05_war_exploded/path1/add.jsp">同一个项目中同一个目录中文件add.jsp</a><br/>
    <a href="/web05_war_exploded/path1/subpath/sub.jsp">同一个项目中子级目录中文件subpath/sub.jsp</a><br/>
    <a href="/web05_war_exploded/path2/update.jsp">同一个项目中同级目录中文件path2/update.jsp</a><br/>
    <a href="/web05_war_exploded/index.jsp">同一个项目中父级目录中文件index.jsp</a><br/>
    <a href="/web05_war_exploded/abc/PathServlet">同一个项目中Servlet如何访问</a><br/>
    <a href="/web04_war_exploded/index.jsp">web04项目中index.jsp文件(同一个服务器)</a><br/>
    <%--<a href="http://www.bjsxt.com">北京尚学堂官网如何访问(不同服务器)</a><br/>--%>
    
    
    <%--优点:路径书写方式比较简单  缺点:只可以访问同一个服务器中项目  必须找相对关系 如果path的位置改变了 这个相对路径全部不对--%>
    
      <h3>相对路径A(直接写路径 在最前面不需要写/ 相对于本身  ./当前目录  ../返回上级)</h3>
    <a href="add.jsp">同一个项目中同一个目录中文件add.jsp</a><br/>
    <a href="subpath/sub.jsp">同一个项目中子级目录中文件subpath/sub.jsp</a><br/>
    <a href="../path2/update.jsp">同一个项目中同级目录中文件path2/update.jsp</a><br/>
    <a href="../index.jsp">同一个项目中父级目录中文件index.jsp</a><br/>
    <a href="../abc/PathServlet">同一个项目中Servlet如何访问</a><br/>
    <a href="../../web04_war_exploded/index.jsp">web04项目中index.jsp文件(同一个服务器)</a><br/>
    
    
    <%--优点:书写最简单，并且不需要找相对关系只要顺着上面base继续写即可   缺点:只可以访问当前项目中内容--%>
      
      <h3>相对路径B 相对于base</h3>
    <a href="path1/add.jsp">同一个项目中同一个目录中文件add.jsp</a><br/>
      
    <a href="path1/subpath/sub.jsp">同一个项目中子级目录中文件subpath/sub.jsp</a><br/>
    <a href="path2/update.jsp">同一个项目中同级目录中文件path2/update.jsp</a><br/>
    <a href="index.jsp">同一个项目中父级目录中文件index.jsp</a><br/>
    <a href="abc/PathServlet">同一个项目中Servlet如何访问</a><br/>
    <%--    <a href="/web04_war_exploded/index.jsp">web04项目中index.jsp文件(同一个服务器)</a><br/>--%>
    
    
    	</body>
    </html>

    		如果访问的都是当前项目文件: 推荐使用基于base的路径
    		
    		如果访问是同一个服务器中其他项目文件：推荐使用根路径
    		
    		如果访问是不同服务器中项目:必须使用绝对路径

    MySQL最强大的优势之一在于它是一个开放源代码的数据库管理系统。开源的特点是给予了用户根据自己需要修改DBMS的自由。MySQL采用了General Public License，这意味着授予用户阅读、修改和优化源代码的权利，这样即使是免费版的MySQL的功能也足够强大，这也是为什么MySQL越来越受欢迎的主要原因。

    MySQL可在不同的操作系统下运行，简单地说，MySQL可以支持Windows系统、UNIX系统、Linux系统等多种操作系统平台。这意味着在一个操作系统中实现的应用程序可很方便移植到其他操作系统下。

    MySQL的核心程序完全采用多线程编程，这些线程都是轻量级的进程，它在灵活地为用户提供服务的同时，又不会占用过多的系统资源。因此MySQL能够更快速、高效的处理数据。

    MySQL分为社区版和企业版，社区版是完全免费的，而企业版是收费的。即使在开发中需要用到一些付费的附加功能，价格相对于昂贵的Oracle、DB2等也是有很大优势的。其实免费的社区版也支持多种数据类型和正规的SQL查询语言，能够对数据进行各种查询、增加、删除、修改等操作，所以一般情况下社区版就可以满足开发需求了，而对数据库可靠性要求比较高的企业可以选择企业版。

    社区版与企业版主要的区别是： 
    		 社区版包含所有MySQL的最新功能，而企业版只包含稳定之后的功能。换句话说，社区版可以理解为是企业版的测试版。  
    		
    		MySQL官方的支持服务只是针对企业版，如果用户在使用社区版时出现了问题，MySQL官方是不负责任的。

    	抽象类：
 抽象方法，只有行为的概念，没有具体的行为实现。使用abstract关键字修饰，没有方法体。子类必须重写这些抽象方法。
 包含抽象方法的类，一定是抽象类。
 抽象类只能被继承，一个类只能继承一个抽象类。
    
    	接口：
 全部的方法都是抽象方法，属性都是常量
 不能实例化，可以定义变量。
 接口变量可以引用具体实现类的实例
 接口只能被实现，一个具体类实现接口，必须实现全部的抽象方法
    ·		5. 接口之间可以多实现
  一个具体类可以实现多个接口，实现多继承现象

    值传递 传的是值
    引用传递 传递的是地址
    		理论上说，java都是引用传递，对于基本数据类型，传递是值的副本，而不是值本身。
    		对于对象类型，传递是对象的引用，当在一个方法操作操作参数的时候，其实操作的是引用所指向的对象。

 数据储存位置  cookie在客户端浏览器  session 在服务器
    2. 安全方面 coolie相较session不安全 
    3. 数据大小 cookie保存的数据不能超4k 很多浏览器规定一个站点不能超20个对于session来说并没有上限，但出于对服务器端的性能考虑，session内不要存放过多的东西，并且设置session删除机制。
    4. 有效期不同开发可以通过设置cookie的属性，达到使cookie长期有效的效果。session依赖于名为JSESSIONID的cookie，而cookie JSESSIONID的过期时间默认为-1，只需关闭窗口该session就会失效，因而session不能达到长期有效的效果。
    5. 服务器压力不同cookie保管在客户端，不占用服务器资源。对于并发用户十分多的网站，cookie是很好的选择。 session是保管在服务器端的，每个用户都会产生一个session。假如并发访问的用户十分多，会产生十分多的session，耗费大量的内存。
    6.  跨域支持上不同cookie支持跨域名访问。session不支持跨域名访问

    ==：
    == 比较的是变量(栈)内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是指相同一个对象。比较的是真正意义上的指针操作。
    1、比较的是操作符两端的操作数是否是同一个对象。
    2、两边的操作数必须是同一类型的（可以是父子类之间）才能编译通过。
    3、比较的是地址，如果是具体的阿拉伯数字的比较，值相等则为true，如：
    int a=10 与 long b=-10L 与 double c=10.0都是相同的（为true），因为他们都指向地址为10的堆。
    
    equals：
    equals用来比较的是两个对象的内容是否相等，由于所有的类都是继承自java.lang.Object类的，所以适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object中的
    equals方法返回的却是==的判断。
    
    总结：
    所有比较是否相等时，都是用equals 并且在对常量相比较时，把常量写在前面，因为使用object的
    equals object可能为null 则空指针
    在阿里的代码规范中只使用equals ，阿里插件默认会识别，并可以快速修改，推荐安装阿里插件来排查老代码使用“==”，替换成equals

 jsp经编译后就变成了Servlet。
    2. jsp更擅长表现于页面显示,servlet更擅长于逻辑控制。 
    3. Servlet中没有内置对象，Jsp中的内置对象都是必须通过HttpServletResponse对象以及HttpServlet对象得到。
    4. 而Servlet则是个完整的Java类，这个类的Service方法用于生成对客户端的响应 
    5. Servlet的应用逻辑是在Java文件中，并且完全从表示层中的HTML里分离开来。 
    6. 而JSP的情况是Java和HTML可以组合成一个扩展名为.jsp的文件。 
    7. JSP侧重于视图，Servlet主要用于控制逻辑 
    8. Servlet更多的是类似于一个Controller，用来做控制。

    Jdk是工具包 包含了jre（运行环境）和jvm是虚拟机
    
    1. JDK：java development kit：java开发工具包，是开发人员所需要安装的环境
    2. JRE：java runtime environment：java运行环境，java程序运行所需要安装的环境

    * GET请求会被浏览器主动cache(缓存)，而POST不会，除非手动设置。
    	* GET请求只能进行url编码，而POST支持多种编码方式。* * GET请求参数会被完整保留在浏览器历史记录里，而POST中的参数不会被保留。
    	* GET请求在URL中传送的参数是有长度限制的，而POST则没有。对参数的数据类型GET只接受ASCII字符，从http协议的角度来说 get请求 和 post请求都没有限制, 这个长度限制是浏览器(各种浏览器) 和 服务器 提出来的	长度限制	http协议本身就是用来做数据通信用的(包含请求 & 响应)	不同的浏览器对长度的限制是不一样的:	IE浏览器对长度限制为 最大2KB	chrome浏览器对长度限制为 最大8kb 经过我们实测中文 1.81kb都报错  字符串1.81kb没问题,不报错	其他浏览器各自有各自的长度 需要的时候 去看一下就可以了 
    	* POST既可是字符也可是字节。
    	* GET相比POST来说不安全，因为参数直接暴露在URL上，所以不能用来传递敏感信息。

     1、StringBuffer与StringBuilder中的方法和功能完全是等价的。
     2、只是StringBuffer中的方法大都采用了 synchronized 关键字进行修饰，因此是线程安全的，而StringBuilder没有这个修饰，可以被认为是线程不安全的。  
     3、在单线程程序下，StringBuilder效率更快，因为它不需要加锁，不具备多线程安全而StringBuffer则每次都需要判断锁，效率相对更低

    String是只读字符串，它并不是基本数据类型，而是一个对象。从底层源码来看是一个fifinal类型的字符数组，所引用的字符串不能被改变，一经定义，无法再增删改。每次对String的操作都会生成新的
    String对象
    每次+操作 ： 隐式在堆上new了一个跟原字符串相同的StringBuilder对象，再调用append方法 拼接
    +后面的字符。
    
    StringBuffer与StringBuilder都继承了AbstractStringBulder类，而AbtractStringBuilder又实现了CharSequence接口，两个类都是用来进    行字符串操作的。
    在做字符串拼接修改删除替换时，效率比string更高。
    StringBuffer是线程安全的，Stringbuilder是非线程安全的。所以Stringbuilder比stringbuffer效率更高，StringBuffer的方法大多都加了
    synchronized关键字

 bean的生命周期 通过构造函数（不管是有参还是无参）来实例化bean
 为bean的属性设置值 和对其他的bean引用（调用set方法）
 在初始化之前执行的方法    postProcessBeforeInitialization 
 调用bean的初始化的方法（需要进行配置） xml文件中加上init -method 
 在初始化之后执行的方法    postProcessAfterInitialization 
 获取创建bean实例对象 
 执行销毁方法

    	NullPointerException：空指针异常.
    	SQLException：mysql语句异常
    	IndexOutOfBoundsException：下标超出

    ​				10

    	HashMap底层基于数组+链表+红黑树。HashMap存储的是键值对，
    	将每个键值对保存到Node对象中，然后再把Node对象存到Node数组中。

    从字面上看，重写就是 重新写一遍的意思。其实就是在子类中把父类本身有的方法重新写一遍。子类继承了父类原有的方法，
    但有时子类并不想原封不动的继承父类中的某个方法，所以在方法名，参数列表，返回类型(除过子类中方法的返回值是父类中方法
    返回值的子类时)都相同的情况下， 对方法体进行修改或重写，这就是重写。但要注意子类函数的访问修饰权限不能少于父类的。

    public class Father {
    
    public static void main(String[] args) {
    
    // TODO Auto-generated method stub
    
    Son s = new Son();
    
    s.sayHello();
    
    }
    
    public void sayHello() {
    
    System.out.println("Hello");
    	}
    }
    
    class Son extends Father{
    
    @Override
    
    public void sayHello() {
    
    // TODO Auto-generated method stub
    
    System.out.println("hello by ");
    
    	}
    
    }

    原因： 在某个范围内的整型数值的个数是有限的，而浮点数却不是。
    重写 总结：
    1.发生在父类与子类之间
    2.方法名，参数列表，返回类型（除过子类中方法的返回类型是父类中返回类型的子类）必须相同
    3.访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private)
    4.重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常

    在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同甚至是参数顺序不同） 则视为重载。同时，重载对返回类型没有要求，
    可以相同也可以不同，但不能通过返回类型是否相同来判断重载。

    public class Father {
    
    public static void main(String[] args) {
    
    // TODO Auto-generated method stub
    
    Father s = new Father();
    
    s.sayHello();
    
    s.sayHello("wintershii");
    
    }
    
    public void sayHello() {
    
    System.out.println("Hello");
    
    }
    
    public void sayHello(String name) {
    
    System.out.println("Hello" + " " + name);
    
    	}
    
    }

    重载总结：
    1.重载Overload是一个类中多态性的一种表现
    2.重载要求同名方法的参数列表不同(参数类型，参数个数甚至是参数顺序)
    3.重载的时候，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准

 针对第一个因素，JDK里面提供了很多atomic类, AtomicLong, AtomicBoolean等等，
    	这些类本身可以通过CAS来保证操作的原子性；Java也提供了锁机制，
    	锁内的代码块在同一时刻只能有一个线程执行，例如synchronized关键字。 
    
    2. 针对第二个因素，可用synchronized关键字加锁保证，
    	将操作共享数据的语句加入synchronized关键字，
       同一时刻只能有一个线程执行，直到完成。 也可用volatile关键字，可以保证修改共享数据后对其他线程可见。 
    
    3. 针对第三个因素可以使用Lock锁。Lock锁很灵活，但需要手动释放和开启。
    	 在并发量比较高的情况下，Lock锁优于synchronized关键字。

    扩容的时候 会以新的容量建一个原数组的拷贝 修改原数组 指向这个新数组 原数组被抛弃 
    会被cg回收当数组的大小大于初始容量的时候 （比如初始值为10 当添加第11个元素的时候 ）
    就会进行扩容 新容量为旧容量的1.5倍

    未提交读（Read Uncommitted）允许脏读 可能读到其他会话中未提交事务修改的数据不重复度（Read Committed）
    						   只能读取到已经提交的数据 
    						   
    可重复读(Repeated Read)在同一个事务内的查询都是事务开始时刻一致的，InnoDB默认级别。
    
    在SQL标准中，该隔离级别消除了不可重复读，但是还存在幻象读，但是innoDB解决了幻读串行读（(Repeated Read)）
    完全串行化的读 每次读都需要获得表级共享锁 读和写都会阻塞 默认 可重读读

    Char最大长度是255字符 varchar最大长度65535个字符Char是定长的 不足的地方用隐藏空格填充  
    
    varchar是不定长的Char会浪费空间 varchar不会浪费空间Char查找效率高 varchar查找效率低

    同步阻塞I/O模式，数据的读取写入必须阻塞在一个线程内等待其完成。这里假设		
    一个烧开水的场景，有一排水壶在烧开水，BIO的工作模式就是， 
    叫一个线程停留在一个水壶那，直到这个水壶烧开，才去处理下一个水壶。但是实际上线程在等待水壶烧开的时间段什么都没有做。

     同时支持阻塞与非阻塞模式，但这里我们以其同步非阻塞I/O模式来说明，
     那么什么叫做同步非阻塞？如果还拿烧开水来说，NIO的做法是叫一个线程不断的轮询每个水壶的状态，
     看看是否有水壶的状态发生了改变，从而进行下一步的操作。

     异步非阻塞I/O模型。异步非阻塞与同步非阻塞的区别在哪里？
     异步非阻塞无需一个线程去轮询所有IO操作的状态改变，在相应的状态改变后，系统会通知对应的线程来处理。
     对应到烧开水中就是，为每个水壶上面装了一个开关，水烧开之后，水壶会自动通知我水烧开了。

    Java 中的基本数据类型只有  8 个：
    
    		byte 、short、int、long、float、double、  char、boolean；
    		
    		除了基本类型（primitive type）， 剩下的都是引用类型（reference type），
    		Java 5 以后引入的枚举类型也算是一种比较特殊的引用类型。

    序列化是将对象状态转换为可保持或传输的格式的过程。说明白点就是你可以用对象输出流输出到文件.
    如果不序列化输出的话.很可能会乱!
    
     实现方式是实现java.io.Serializable接口.这个接口不需要实现任何具体方法.
     只要implements java.io.Serializable 就好了
     
    java中的序列化机制能够将一个实例对象（只序列化对象的属性值，而不会去序列化什么所谓的方法。）的状态信息写入到一个
    字节流中使其可以通过socket进行传输、或者持久化到存储数据库或文件系统中；然后在需要的时候通过字节流中的信息来
    重构一个相同的对象。
    
    一般而言，要使得一个类可以序列化，只需简单实现java.io.Serializable接口即可。

    主要有三点：
    			原子性：一个或者多个操作在CPU执行的过程中被中断
    			可见性：一个线程对共享变量的修改，另外一个线程不能立刻看到
    			有序性：程序执行的顺序没有按照代码的先后顺序执行

    Redis的键值可以使用物种数据类型：字符串，散列表，列表，集合，有序集合。本文详细介绍这五种数据类型的使用方法。
    本文命令介绍部分只是列举了基本的命令，至于具体的使用示例，可以参考Redis官方文档：Redis命令大全

    字符串是Redis中最基本的数据类型，它能够存储任何类型的字符串，包含二进制数据。可以用于存储邮箱，JSON化的对象，甚至是一张图片，
    一个字符串允许存储的最大容量为512MB。字符串是其他四种类型的基础，与其他几种类型的区别从本质上来说只是组织字符串的方式不同而已。

    1、SET赋值，用法：SET key value
    
    2、GET取值，用法：GET key
    
    3、INCR递增数字，仅仅对数字类型的键有用，相当于Java的i++运算，用法：INCR key
    
    4、INCRBY增加指定的数字，仅仅对数字类型的键有用，相当于Java的i+=3，用法：INCRBY key increment，意思是key自增increment，increment可以为负数，表示减少。
    
    5、DECR递减数字，仅仅对数字类型的键有用，相当于Java的i–，用法：DECR key
    
    6、DECRBY减少指定的数字，仅仅对数字类型的键有用，相当于Java的i-=3，用法：DECRBY key decrement，意思是key自减decrement，decrement可以为正数，表示增加。
    
    7、INCRBYFLOAT增加指定浮点数，仅仅对数字类型的键有用，用法：INCRBYFLOAT key increment
    
    8、APPEND向尾部追加值，相当于Java中的”hello”.append(“ world”)，用法：APPEND key value
    
    9、STRLEN获取字符串长度，用法：STRLEN key
    
    10、MSET同时设置多个key的值，用法：MSET key1 value1 [key2 value2 ...]
    
    11、MGET同时获取多个key的值，用法：MGET key1 [key2 ...]

    1、GETBIT获取一个键值的二进制位的指定位置的值(0/1)，用法：GETBIT key offset
    
    2、SETBIT设置一个键值的二进制位的指定位置的值(0/1)，用法：SETBIT key offset value
    
    3、BITCOUNT获取一个键值的一个范围内的二进制表示的1的个数，用法：BITCOUNT key [start end]
    
    4、BITOP该命令可以对多个字符串类型键进行位运算，并将结果存储到指定的键中，BITOP支持的运算包含：OR,AND,XOR,NOT，用法：BITOP OP desKey key1 key2
    
    5、BITPOS获取指定键的第一个位值为0或者1的位置，用法：BITPOS key 0/1 [start， end]

    散列类型相当于Java中的HashMap，他的值是一个字典，保存很多key，value对，每对key，value的值个键都是字符串类型，
    换句话说，散列类型不能嵌套其他数据类型。一个散列类型键最多可以包含2的32次方-1个字段。

    1、 HSET赋值，用法：HSET key field value
    
    2、 HMSET一次赋值多个字段，用法：HMSET key field1 value1 [field2 values]
    
    3、 HGET取值，用法：HSET key field
    
    4、 HMGET一次取多个字段的值，用法：HMSET key field1 [field2]
    
    5、 HGETALL一次取所有字段的值，用法：HGETALL key
    
    6、  HEXISTS判断字段是否存在，用法：HEXISTS key field
    
    7、 HSETNX当字段不存在时赋值，用法：HSETNX key field value
    
    8、 HINCRBY增加数字，仅对数字类型的值有用，用法：HINCRBY key field increment
    
    9、 HDEL删除字段，用法：HDEL key field
    
    10、 HKEYS获取所有字段名，用法：HKEYS key
    
    11、 HVALS获取所有字段值，用法：HVALS key
    
    12、 HLEN获取字段数量，用法：HLEN key

    列表类型(list)用于存储一个有序的字符串列表，常用的操作是向队列两端添加元素或者获得列表的某一片段。
    列表内部使用的是双向链表（double linked list）实现的，所以向列表两端添加元素的时间复杂度是O(1),
    获取越接近列表两端的元素的速度越快。但是缺点是使用列表通过索引访问元素的效率太低（需要从端点开始遍历元素）。
    所以列表的使用场景一般如：朋友圈新鲜事，只关心最新的一些内容。借助列表类型，Redis还可以作为消息队列使用。

    1、 LPUSH向列表左端添加元素，用法：LPUSH key value
    
    2、 RPUSH向列表右端添加元素，用法：RPUSH key value
    
    3、 LPOP从列表左端弹出元素，用法：LPOP key
    
    4、 RPOP从列表右端弹出元素，用法：RPOP key
    
    5、 LLEN获取列表中元素个数，用法：LLEN key
    
    6、 LRANGE获取列表中某一片段的元素，用法：LRANGE key start stop，index从0开始，-1表示最后一个元素
    
    7、 LREM删除列表中指定的值，用法：LREM key count value，删除列表中前count个值为value的元素，当count>0时从左边开始数，count<0时从右边开始数，count=0时会删除所有值为value的元素
    
    8、 LINDEX获取指定索引的元素值，用法：LINDEX key index
    
    9、 LSET设置指定索引的元素值，用法：LSET key index value
    
    10、 LTRIM只保留列表指定片段，用法：LTRIM key start stop，包含start和stop
    
    11、 LINSERT像列表中插入元素，用法：LINSERT key BEFORE|AFTER privot value，从左边开始寻找值为privot的第一个元素，然后根据第二个参数是BEFORE还是AFTER决定在该元素的前面还是后面插入value
    
    12、 RPOPLPUSH将元素从一个列表转义到另一个列表，用法：RPOPLPUSH source destination

    集合在概念在高中课本就学过，集合中每个元素都是不同的，集合中的元素个数最多为2的32次方-1个，集合中的元素师没有顺序的。

  SADD添加元素，用法：SADD key value1 [value2 value3 ...]
    
    2.  SREM删除元素，用法：SREM key value2 [value2 value3 ...]
    
    3.  SMEMBERS获得集合中所有元素，用法：SMEMBERS key
    
    4.  SISMEMBER判断元素是否在集合中，用法：SISMEMBER key value
    
    5.  SDIFF对集合做差集运算，用法：SDIFF key1 key2 [key3 ...]，先计算key1和key2的差集，然后再用结果与key3做差集
    
    6.  SINTER对集合做交集运算，用法：SINTER key1 key2 [key3 ...]
    
    7.  SUNION对集合做并集运算，用法：SUNION key1 key2 [key3 ...]
    
    8.  SCARD获得集合中元素的个数，用法：SCARD key
    
    9.  SDIFFSTORE对集合做差集并将结果存储，用法：SDIFFSTORE destination key1 key2 [key3 ...]
    
    10.  SINTERSTORE对集合做交集运算并将结果存储，用法：SINTERSTORE destination key1 key2 [key3 ...]
    
    11.  SUNIONSTORE对集合做并集运算并将结果存储，用法：SUNIONSTORE destination key1 key2 [key3 ...]
    
    12.  SRANDMEMBER随机获取集合中的元素，用法：SRANDMEMBER key [count]，当count>0时，会随机中集合中获取count个不重复的元素，当count<0时，随机中集合中获取|count|和可能重复的元素。
    
    13.  SPOP从集合中随机弹出一个元素，用法：SPOP key

    有序集合类型与集合类型的区别就是他是有序的。有序集合是在集合的基础上为每一个元素关联一个分数，
    这就让有序集合不仅支持插入，删除，判断元素是否存在等操作外，还支持获取分数最高/最低的前N个元素。
    有序集合中的每个元素是不同的，但是分数却可以相同。有序集合使用散列表和跳跃表实现，
    即使读取位于中间部分的数据也很快，时间复杂度为O(log(N))，有序集合比列表更费内存。

  ZADD添加元素，用法：ZADD key score1 value1 [score2 value2 score3 value3 ...]
    
    2.  ZSCORE获取元素的分数，用法：ZSCORE key value
    
    3.  ZRANGE获取排名在某个范围的元素，用法：ZRANGE key start stop [WITHSCORE]，按照元素从小到大的顺序排序，从0开始编号，包含start和stop对应的元素，WITHSCORE选项表示是否返回元素分数
    
    4.  ZREVRANGE获取排名在某个范围的元素，用法：ZREVRANGE key start stop [WITHSCORE]，和上一个命令用法一样，只是这个倒序排序的。
    
    5.  ZRANGEBYSCORE获取指定分数范围内的元素，用法：ZRANGEBYSCORE key min max，包含min和max，(min表示不包含min，(max表示不包含max，+inf表示无穷大
    
    6.  ZINCRBY增加某个元素的分数，用法：ZINCRBY key increment value
    
    7.  ZCARD获取集合中元素的个数，用法：ZCARD key
    
    8.  ZCOUNT获取指定分数范围内的元素个数，用法：ZCOUNT key min max，min和max的用法和5中的一样
    
    9.  ZREM删除一个或多个元素，用法：ZREM key value1 [value2 ...]
    
    10.  ZREMRANGEBYRANK按照排名范围删除元素，用法：ZREMRANGEBYRANK key start stop
    
     11.  ZREMRANGEBYSCORE按照分数范围删除元素，用法：ZREMRANGEBYSCORE key min max，min和max的用法和4中的一样
    
    12.  ZRANK获取正序排序的元素的排名，用法：ZRANK key value
    
    13.  ZREVRANK获取逆序排序的元素的排名，用法：ZREVRANK key value
    
    14.  ZINTERSTORE计算有序集合的交集并存储结果，用法：ZINTERSTORE destination numbers key1 key2 [key3 key4 ...] 
    		WEIGHTS weight1 weight2 [weight3 weight4 ...] AGGREGATE SUM | MIN | MAX，numbers表示参加运算的集合个数，
    		 weight表示权重，aggregate表示结果取值
    
    15.  ZUNIONSTORE计算有序几个的并集并存储结果，用法和14一样，不再赘述。

    数据先找cache，cache没有数据，找数据库，在将数据库查询结果保存在cache。先写DB，再删cache，在同步cache（解决写穿透）

    	反射是一种计算机处理方式。有程序可以访问、检测和修改它本身状态或行为的这种能力。
    	能提供封装程序集、类型的对象。（程序集包含模块，而模块包含类型，类型又包含成员。）
    优点:
    	1、反射提高了程序的灵活性和扩展性。
    	2、降低耦合性，提高自适应能力。
    	3、它允许程序创建和控制任何类的对象，无需提前硬编码目标类。
    缺点:
    	1、性能问题：使用反射基本上是一种解释操作，用于字段和方法接入时要远慢于直接代码。
    		因此反射机制主要应用在对灵活性和拓展性要求很高的系统框架上，普通程序不建议使用。
    	2、使用反射会模糊程序内部逻辑；程序员希望在源代码中看到程序的逻辑，反射却绕过了源代码的技术，
    		因而会带来维护的问题，反射代码比相应的直接代码更复杂。

    AOP、OOP在字面上虽然非常类似，但却是面向不同领域的两种设计思想。OOP（面向对象编程）针对业务处理过程的实体及其属性和行为进行抽象封装，
    以获得更加清晰高效的逻辑单元划分。
    
    而AOP则是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。
    这两种设计思想在目标上有着本质的差异。
    
    上面的陈述可能过于理论化，举个简单的例子，对于“雇员”这样一个业务实体进行封装，自然是OOP/OOD的任务，我们可以为其建立一个“Employee”类，
    并将“雇员”相关的属性和行为封装其中。而用AOP设计思想对“雇员”进行封装将无从谈起。
    
    同样，对于“权限检查”这一动作片断进行划分，则是AOP的目标领域。而通过OOD/OOP对一个动作进行封装，则有点不伦不类。
    
    换而言之，OOD/OOP面向名词领域，AOP面向动词领域。

    很多人在初次接触 AOP 的时候可能会说，AOP 能做到的，一个定义良好的 OOP 的接口也一样能够做到，我想这个观点是值得商榷的。
    AOP和定义良好的 OOP 的接口可以说都是用来解决并且实现需求中的横切问题的方法。但是对于 OOP 中的接口来说，它仍然需要我们在相应的模块中去调用
    该接口中相关的方法，这是 OOP 所无法避免的，并且一旦接口不得不进行修改的时候，所有事情会变得一团糟；AOP 则不会这样，
    你只需要修改相应的 Aspect，再重新编织（weave）即可。 当然，AOP 也绝对不会代替 OOP。
    核心的需求仍然会由 OOP 来加以实现，而 AOP 将会和 OOP 整合起来，以此之长，补彼之短。

    如果缓存中的数据在某个时刻批量过期，导致大部分用户的请求都会直接落在数据库上，这种现象就叫作缓存击穿。
    
    造成缓存击穿的主要原因就是：我们为缓存中的数据设置了过期时间。如果在某个时刻从数据库获取了大量的数据，并设置了相同的过期时间，
    这些缓存的数据就会在同一时刻失效，造成缓存击穿问题

    对于比较热点的数据，我们可以在缓存中设置这些数据永不过期；也可以在访问数据的时候，在缓存中更新这些数据的过期时间；
    如果是批量入库的缓存项，我们可以为这些缓存项分配比较合理的过期时间，避免同一时刻失效。
    
    还有一种解决方案就是：使用分布式锁，保证对于每个 Key 同时只有一个线程去查询后端的服务，某个线程在查询后端服务的同时，
    其他线程没有获得分布式锁的权限，需要进行等待。不过在高并发场景下，这种解决方案对于分布式锁的访问压力比较大。

    	缓存穿透是指用户查询数据，在数据库没有，自然在缓存中也不会有。这样就导致用户查询的时候，在缓存中找不到，每次都要去数据库再
    	查询一遍，然后返回空（相当于进行了两次无用的查询）。这样请求就绕过缓存直接查数据库，这也是经常提的缓存命中率问题。

    	最常见的则是采用布隆过滤器，将所有可能存在的数据哈希到一个足够大的bitmap中，一个一定不存在的数据会被这个bitmap拦截掉，从
    	而避免了对底层存储系统的查询压力。另外也有一个更为简单粗暴的方法，如果一个查询返回的数据为空（不管是数据不存在，还是系统故
    	障），我们仍然把这个空结果进行缓存，但它的过期时间会很短，最长不超过五分钟。通过这个直接设置的默认值存放到缓存，这样第二次
    	到缓冲中获取就有值了，而不会继续访问数据库，这种办法最简单粗暴。

    	由于原有缓存失效，新缓存未到期间(例如：我们设置缓存时采用了相同的过期时间，在同一时刻出现大面积的缓存过期)，
    	所有原本应该访问缓存的请求都去查询数据库了，而对数据库CPU和内存造成巨大压力，严重的会造成数据库宕机。
    	从而形成一系列连锁反应，造成整个系统崩溃。