不记文档，白忙一场
每日课程
1> java相关 -> 设计模式 23种名称+划分类型都过一遍，细节每日过5种 2>
0、java相关
0、基础知识大牛
1> 基础中基础（数篇）：https://blog.csdn.net/u014634338/article/details/81434327 2> ClassLoader不在面试准备之列，最好有时间写一个小Demo 3> java之注解源码（自定义注解）不在面试准备之列，最好有时间写一个小Demo
1、设计模式
详见"学习资料 -> 后端 -> java" 1> 学习地址一 地址：菜鸟教程 -> 工厂模式 网址：https://www.runoob.com/design-pattern/factory-pattern.html 2> 学习地址二 地址：优秀博客 网址：https://www.cnblogs.com/onetwo/p/9933417.html
2、java8的新特性
Lambda 表达式
格式： (params) -> expression (params) -> statement (params) -> { statements } ------------------------------------------------------------------------------------------- 场景： 将函数当成参数传递给某个方法 ------------------------------------------------------------------------------------------- 例子（匿名内部类）1： 1> 排序：new ArrayList<>().sort(Comparator<? super E> c) 2> 迭代：new ArrayList<>().forEach(n -> System.out.println(n)); 3> 排序：Collections.sort(List<T> list, Comparator<? super T> c) 4> 线程：new Thread( () -> System.out.println("In Java8") ).start(); ------------------------------------------------------------------------------------------- 例子（配合函数式接口Predicate）2： filter(List<String> names, Predicate<String> condition) if(condition.test(name)) 调用： filter(Arrays.asList("1","2"), (String str)->str.startsWith("J")); ------------------------------------------------------------------------------------------- 例子（更多）： https://www.cnblogs.com/coprince/p/8692972.html函数式接口（Lambda 表达式配合函数式接口，将函数当成参数传递给某个方法 ）
概述： 函数式接口，用Lambda表达式赋值，实现了将函数当成参数传递给某方法 ------------------------------------------------------------------------------------------- 例子： 1> Function<T,R> T 作为输入，返回的 R 作为输出 Function<String,String> function = (x) -> {return x "Function";}; System.out.println(function.apply("hello world")); // hello world Function 注：既有输入，也有输出，apply方法 2> Predicate<T> T 作为输入 ，返回 boolean 值的输出 Predicate<Integer> predicate = (x) ->{return x % 2 == 0 ;}; System.out.println(predicate.test(1)); // false 注：test方法 3> Consumer<T> T 作为输入 ，没有输出 Consumer<String> consumer = (x) -> {System.out.println(x);}; consumer.accept("hello world "); // hello world 注：消费者，只有输入，accept【接收】方法 4> Supplier<R> 没有输入 , R 作为输出 Supplier<String> supplier = () -> {return "Supplier";}; System.out.println(supplier.get()); 注：提供者，只有输出，get【提供的第几个】方法 注：你可以把其当成正常的接口使用，由用户使用 Lambda 传入《流》
1> 概述 1> 应用在Stream流上的操作，可以分成两种：Intermediate(中间操作)和Terminal(终止操作)。 2> 中间操作的返回结果都是Stream，故可以多个中间操作"叠加"； 3> 终止操作用于返回我们最终需要的数据，只能有一个终止操作 4> 使用流可以实现并行操作，不需要程序猿生成线程，只专心逻辑代码就好 2> 生成流的方法 1> List/Set（Collection接口的 ）：stream()或parallelStream()方法 2> Arrays：Arrays.stream(array, from, to) 3> 静态的Stream.of()、Stream.empty()方法 4> 静态的Stream.generate()方法生成无限流，接受一个不包含引元的函数 注：集合有1个，数组有1个，Stream静态方法有2个 3> 基础接口BaseStream包含如下方法： 1> boolean isParallel(); //判断是否是并行化流 2> S sequential(); //将流串行化 3> S parallel(); //将流并行化 4> S unordered(); //解除有序流的顺序限制，发挥并行处理的性能优势 4> 流的Intermediate方法(中间操作) 0> sorted(Comparator) 排序（将流元素按Comparator排序） 1> filter(Predicate) 过滤（将结果为false的元素过滤掉） 2> distinct() 去重 3> limit(n) 保留前n个元素 4> skip(n) 跳过前n个元素 5> map(fun) ===> 重要 注：转换元素的值，可以用方法引元或者lambda表达式（python也有此功能） 5> 流的Terminal方法(终止操作) max(Comparator) min(Comparator) count() findFirst() 返回第一个元素 findAny() 返回任意元素 anyMatch(Predicate) 任意元素匹配时返回true allMatch(Predicate) 所有元素匹配时返回true noneMatch(Predicate) 没有元素匹配时返回true reduce(fun) ===> 重要 注：reduce -> 从流中计算某个值，接受一个二元函数作为"累积器"，从前两个元素开始持续应用它，累积 器的中间结果作为第一个参数，流元素作为第二个参数（python也有此功能） 6> 基本类型流 vs 对象流 1> Stream、IntStream、LongStream、DoubleStream都是BaseStream的子接口 2> IntStream、LongStream、DoubleStream直接存储基本类型，可以避免自动装/拆箱，效率会更高一些 7> 更多： https://blog.csdn.net/sanri1993/article/details/101176712 https://www.cnblogs.com/coprince/p/8692972.html
3、深浅拷贝
相同点： 都是实现Cloneable接口，重写clone方法 1> 浅拷贝 只拷贝目标对象，目标对象中如果还有引用，则原来对象和拷贝生成对象都指向一个内存。 2> 深拷贝 目标对象和目标对象中引用都进行拷贝。 注：深拷贝实现 1、两个类都实现了cloneable接口，重写clone方法时，super.clone()返回对象，点内部引用再点 clone()方法，将内部引用也拷贝。 2、还有一种没有试验的方法，实现Serializable接口（这个接口的作用是实现序列化） 注：https://blog.csdn.net/riemann_/article/details/87217229
4、集合
HashMap - 源码
1> 底层数据结构 1> jdk1.7采用数组+链表 2> jdk1.8采用数组+链表+红黑树 2> 为什么要加链表（和红黑树），而不是直接用数组存储 1> 因为有哈希碰撞的问题，数组中每个元素都是链表 2> 数组查找快，插入删除效率低；链表查找需要遍历慢，插入删除直接重新指向下一节点效率高 数组解决查询问题，链表解决插入删除问题 3> 红黑树解决单向链表过长查询效率问题 3> 关键变量 1> table 1> 类型是Entry<K,V>[]，是哈希表中的数组 2> Entry<K,V> 1> 表示链表节点，jdk1.7名称为Entry，1.8改名为Node，红黑树节点为TreeNode 2> 是静态内部类，成员变量有：key，value，hash值（整数），next（Entry<K,V>对象） 3> capacity 1> 数组容量，初始值（定义了常量），值1<<4（1左移4位），也就是16 2> 扩容一次，容量变为原来2倍 4> load_factor 1> 负载因子，初始值（定义了常量），值0.75 5> threshold 1> 扩容阈值，等于capacity*load_factor，数组元素个数大于等于该值，开始扩容 4> put操作 1> 根据key计算哈希值 1> jdk1.7中，一堆的异或和>>>运算 2> jdk1.8中，(key==null)? 0 : (h = key.hashCode()) ^ (h>>>16) 注：key.hashCode()先将值赋值给h变量，再将新的h值无符号右移16位，最后将两边做异或运算。 即key的hashCode值，高16位和低16位进行异或运算。 1010 0011 1100 1111 -> 无符号右移之后 -> 0000 0000 1010 0011 前后做异或运算 1010 0011 1100 1111 0000 0000 1010 0011 ------------------- 1010 0011 0110 1100 注：jdk1.8运算方法，是作者的一个经验，这样做使hash值分布比较均匀，碰撞概率比较低 ------------------------------------------------------------ 注释掉第2步：判断table变量（即HashMap的数组）是否为null，如果为null， 则初始化HashMap的数组，大小为16，扩容阈值为12，元素类型为Node<K,V> ------------------------------------------------------------ 3> 计算数组下标 (n-1) & hash 注：数组容量为n，第一步计算的哈希值为hash 注：n-1转为二进制，不论和什么值做&运算，肯定小于n-1，保证下标就在HashMap数组容量内 4> 判断下表所在位置是否有元素 1> 若没有，则新建一个链表节点，放在该下标位置 2> 若已有元素，则进行进一步判断 1> 如果已有元素的hash值等于当前hash值且key相等或者key的equals相等，则 还是保持原来的元素（后面代码将数组元素的value值重新赋值为当前value） 2> 如果已有元素的类型是TreeNode，则 将当前元素执行挂载红黑树下操作 3> 其余情况（是链表） 1> 循环链表所有节点 2> 在循环中判断节点的下一节点是否为null 3> 如果是null，就时链表的尾巴了，新建一节点，让最后一个节点的next引用指向新节点 4> 判断如果元素个数大于等于转红黑树的一个阈值8，则执行链表转红黑树操作 注：其余情况中，就return了，不会执行下面代码进行++size > threshold判断 是否容量超过扩容阈值。即挂在链表下的不算HashMap数组容量。 5> get操作 1> 根据key计算哈希值 1> jdk1.7中，一堆的异或和>>>运算 2> jdk1.8中，(key==null)? 0 : (h = key.hashCode()) ^ (h>>>16) 2> 计算数组下标 (n-1) & hash 注：jdk1.7和1.8计算数组下表方法一致 3> 判断下表所在位置是否有元素，如果有则 1> 如果hash值和当前hash值一样，且key相等或key的equal相等，则返回第一个节点对象 2> 如果第一个节点的next属性不为null，则 1> 第一个节点类型为TreeNode，则从红黑树取 2> 否则，循环链表节点，比对"hash值和当前hash值一样，且key相等或key的equal相等"， 并返回值Map - 面试
1> HashMap的数据结构 2> HashMap的hash运算是如何实现的？为什么这样实现 1> 提高性能：异或和位移运算，对CPU更友好，减少系统开销 2> 减少hash碰撞：通过异或和位移运算，让hash值变得更复杂，进而影响hash的分布 3> HashMap默认容量是多少？如何扩容 1> 默认16，也可以在构造时传入capacity初始值和load_factor初始值。最大1<<30，即2的30次方 2> 就容量左移1位。即<<1，即扩大为原来的2倍 4> HashMap的put方法的过程 见"源码" 5> HashMap链表节点过深时，为什么选择红黑树 优化查找数据性能：O(n) --> O(logN) 6> 什么是hash碰撞，发生碰撞怎么办 1> 键值的hash值一样，进而计算数组下表一样，导致hash碰撞 2> HashMap中使用的是拉链法 7> JDK1.8对HashMap做了哪些改进 1> 链表长度大于等于8，那么链表将转换为红黑树 2> 发生hash碰撞时，1.7在链表头部插入，1.8在尾部插入 3> 链表节点由Entry转换为Node类（换了一个类名） 4> hash的实现，1.8是(key==null)? 0 : (h = key.hashCode()) ^ (h>>>16)； 1.7中是一堆的异或和>>>运算 8> HashMap和HashTable的区别 1> HashMap是线程不安全的；HashTable是线程安全的。 因为HashTable的put和get方法直接加了synchronized。HashTable效率小于HashMap 3> HashMap允许一个key值为null，多个value值为null；HashTable不允许。 因为HashMap的hash方法，如果key为null，返回0，计算数组下标用(n-1)&hash肯定是0，放在0位置 4> HashMap默认大小16，HashTable是11，扩容前者是两倍，后者是两倍+1 5> HashMap的hash值：(key==null)? 0 : (h = key.hashCode()) ^ (h>>>16)； HashTable的hash值：直接用key.hashCode() 9> HashMap和ConcurrentHashMap的区别 1> ConcurrentHashMap在java.util.concurrent包下，线程安全；HashMap线程不安全。 （1.7用分段锁，1.8用CAS+Synchronized -- 不需要记） 2> CurrentHashMap的键值对都不允许有空值； 10> 我们能否让HashMap实现同步（线程安全）？ 调用工具类Collections的synchronizeMap方法：Map map = Collections.synchronizedMap(hashMapMap - 待解决
1> 来源：https://www.cnblogs.com/zengcongcong/p/11295349.html 2> HashMap在java8之后的特性 初始数据量 数据量扩展到多大，由数组展开为链表 3> 执行put/get方法，下表是根据（n-1）&hash计算的，也就是数组不是顺序放置节点，怎么保证数组全部 用完再扩容。 数组存在的空白的地方，怎么处理 4> 1<<4 1> 位移运算符 << : 左移运算符，num << 1,相当于num乘以2（num表示的二进制数左移一位，低位补0） >> : 右移运算符，num >> 1,相当于num除以2（num表示的二进制数右移一位） >>> : 无符号右移，忽略符号位，空位都以0补齐 2> 来源：https://www.cnblogs.com/hongten/p/hongten_java_yiweiyunsuangfu.html 5> ^ 1> 异或，两个值相异，则结果为真。 2> 二进制运算中，两值相等，则结果为1，不等，则结果为0。比如1^0=1 3> 只有二进制运算有异或运算，所以十进制两个数，需要换算为二进制再进行计算 4> 面试题 int[] numarry = new int[]{1,2,2}; int aim = numarry[0]; for(int i = 1; i < 3; i++) { aim = aim ^ numarry[i]; } System.out.println("最后："+aim); 解决思路：异或运算的结合律 -> a ^ b ^ c = a ^ (b ^ c) = (a ^ b) ^ c 注：结合律这样的运算规律是数学家几代人，得出来的，记住即可。1^2^2 = 1^(2^2)=1^0=1 来源：https://blog.csdn.net/guanminwei/article/details/104022161 6> & 运算规则：两个数都转为二进制，然后从高位开始比较，如果两个数都为1则为1，否则为0。集合整体框架 - Collection
来源：https://www.cnblogs.com/bingyimeiling/p/10255037.html 1> 概述： 1> Collection派生出了三个子接口：List、Set、Queue 2> 其中List代表了有序可重复集合，可直接根据元素的索引来访问； Set代表无序不可重复集合，只能根据元素本身来访问； Queue是队列集合； Map代表的是存储key-value对的集合，可根据元素的key来访问value。 2> List接口 1> 概述： List接口常用的实现类有： ArrayList类，实现了List接口； LinkedList类，同时实现了List接口和Deque接口； Vector类，实现了List接口； Stack类，继承自Vector类； 2> ArrayList类： 1> ArrayList是一个动态数组，初始容量（10），果我们明确所插入元素的多少，最好指定一个初始 容量值，避免过多的进行扩容操作而浪费时间、效率。 2> 在每次向容器中增加元素的同时都会进行容量检查，当快溢出时，就会进行扩容操作。 3> LinkedList类： 1> 除了可以根据索引访问集合元素外，LinkedList还实现了Deque接口，可以当作双端队列来使用， 也就是说，既可以当作"栈"使用，又可以当作队列使用 2> LinkedList的实现机制与ArrayList的实现机制完全不同，ArrayLiat内部以数组的形式保存集合 的元素，所以随机访问集合元素有较好的性能；LinkedList内部以链表的形式保存集合中的元 素，所以随机访问集合中的元素性能较差，但在插入删除元素时有较好的性能 4> Vector类： 与ArrayList相似，但是Vector是同步的。所以说Vector是线程安全的动态数组。它的操作与 ArrayList几乎一样 5> Stack类： Stack继承自Vector，实现一个后进先出的堆栈，基本的push和pop 方法 3> Set接口 1> 概述 1> Set集合不允许存储相同的元素，所以如果把两个相同元素添加到同一个Set集合，则添加操作失 败，新元素不会被加入，add()方法返回false 2> Set接口常用的实现类有： HashSet类，实现了Set接口； LinkedHashSet类，继承自HashSet类，同时实现了Set接口； TreeSet类，实现了SortedSet接口，SortedSet接口继承自Set接口； EnumSet抽象类，实现了Set接口；、 2> HashSet类 1> HashSet不是线程同步的，如果多线程操作HashSet集合，则应通过代码来保证其同步。（HashSet 是按照hash算法来存储元素的，因此具有很好的存取和查找性能。） 2> HashSet存储原理： 1> 位置：当向HashSet集合存储一个元素时，调用该对象的hashCode()方法得到其hashCode 值，然后根据hashCode值决定该对象的存储位置 2> 位置是否已有值：两个对象通过equals()方法比较返回true，两个对象的hashCode()方法返 回值相等。HashSet会以链式结构将两个对象保存在同一位置，这将导致性能下降
5、泛型
来源：https://www.jianshu.com/p/986f732ed2f1 来源：https://www.cnblogs.com/lixuwu/p/10829368.html 1> 概述 1> 泛型的本质是参数化类型，也就是说使用泛型类或者泛型方法，所操作的数据类型被指定为一个参数 注：什么是参数化类型 Collection<String>或LinkedList<String> Collection<E>中的类型也作为了参数。 2> 为什么要引入泛型 1> 在jdk1.5引入泛型之前，使用 Object 来实现通用，缺点 1> 强制转换：每次使用时都需要强制转换成想要的类型 2> 安全：在编译时编译器并不知道类型转换是否正常，运行时才知道，不安全 2> 所以泛型好处 1> 消除强制类型转换：泛型的一个附带好处是，使用时直接得到目标类型 2> 类型安全：编译时期就可以检查出因 Java 类型不正确导致的 ClassCastException 异常 3> 类型的上界和下界（限定泛型类型变量） extends 关键字声明了类型的上界（理解为：类型都需要继承于xxx） super 关键字声明了类型的下界（理解为：类型都需要超越于xxx） 4> 通配符类型 1> 无限制通配符 < ?>： Object 有些相似，用于表示无限制或者不确定范围的场景。 2> 有限制通配形式：< ? super E> 和 < ? extends E> 3> 为了获得最大限度的灵活性，要在表示 生产者或者消费者 的输入参数上使用通配符，使用的规则就是： 生产者有上限、消费者有下限 4> < ? super E> 用于灵活写入；< ? extends E> 用于灵活读取 注：泛型的参数类型还可以是通配符类型，例如 Class（参见"json字符串转对象"） 5> 泛型的类型擦除 1> 当编译器对带有泛型的java代码进行编译时，会将类型替换为它的上级类型，如果是没有限定的泛型参数 类型，就会被替换为Object。所以生成的是普通的不带泛型的字节码。 2> Java中泛型在运行期是不可见的，Java 虚拟机运行时对泛型基本一无所知。 6> 泛型的使用场景 1> 当类中要操作的引用数据类型不确定的时候，过去使用 Object 来完成扩展，JDK 1.5后推荐使用泛型来 完成扩展，同时保证安全性。 7> 数组中不能使用泛型 建议使用 List 来代替 Array，因为 List 可以提供编译期的类型安全保证，而 Array 却不能。 8> Java 中 List 和原始类型 List 之间的区别? 1> 在编译时编译器不会对原始类型进行类型安全检查，却会对带参数的类型进行检查 2> 通过使用Object作为类型，可以告知编译器该方法可以接受任何类型的对象，比如String 或 Integer 3> 你可以把任何带参数的类型传递给原始类型 List，但却不能把 List< String> 传递给接受 List< Object> 的方法，因为泛型的不可变性，会产生编译错误。 9> 如何获取泛型的类型 1> 这里的Type指java.lang.reflect.Type 2> Type superclass = genericType.getClass().getGenericSuperclass(); 10> 一些常用的泛型类型变量 E：元素（Element），多用于java集合框架 K：关键字（Key） N：数字（Number） T：类型（Type） V：值（Value） n> 使用经验（jackson定义工具类） import com.fasterxml.jackson.databind.ObjectMapper; public class JsonUtil<T> { //对象转json字符串 public String obj2Json(T clazz) { ObjectMapper mapper = new ObjectMapper(); String jsonStr = null; try { jsonStr = mapper.writeValueAsString(clazz); } catch (JsonProcessingException e) { e.printStackTrace(); } return jsonStr; } //json字符串转对象 public T json2Obj(String jsonStr,Class<T> clzz) {//通配符类型，例如 Class ObjectMapper mapper = new ObjectMapper(); T jsonObj = null; try { //{"code":"1","data":"1#123456","listenPort":"8881"} jsonObj = mapper.readValue(jsonStr, clzz); } catch (IOException e) { e.printStackTrace(); } return jsonObj; } }
6、JVM
概述
来源：https://www.bilibili.com/video/BV1kJ411S7Ku?p=1 来源（本地方法栈）：https://www.cnblogs.com/yanl55555/p/12624519.html 购买：https://www.javaxxz.com/forum-167-1.html JVM整体架构 JVM类加载器 JVM内存结构 JVM执行引擎JVM内存结构（JVM内存模型）
注：元空间详解https://blog.csdn.net/yuan_qh/article/details/100176771 注：https://blog.csdn.net/m0_37510446/article/details/104121744 **方法区只是一规范，在不同的虚拟机中的实现是不一样的，例如永久代和元空间。 1> JVM组成结构 由3个主要的子系统组成 1> 类加载子系统（ClassLoader） 2> 运行时数据区（内存结构）（Runtime Data Area） 3> 执行引擎（Execution Engine） 2> 运行时数据区组成结构 1> java栈 2> 本地方法栈 3> 程序计数器 4> 方法区 5> 堆 注：方法区和堆是线程共享的，java栈、本地方法栈、程序计数器每个线程都会开辟自己独立的空间。 3> java栈组成结构 1> 线程中每个方法都会在java栈中分配一个空间，是内存单元，叫栈帧 2> java栈和数据结构中栈特性一模一样，先进后出 3> 栈帧中存放方法的数据（包括：见点"4"） 4> 栈帧组成结构 1> 局部变量表 2> 操作数栈 3> 动态链接 4> 方法出口 5> 程序计数器 就是一个指针，指向用来存储指向下一条指令的地址 6> 本地方法栈 native方法，会录入本地方法栈中，而不是java栈中。也是开辟一个栈帧 7> 动态链接 null 8> 执行引擎中包含了垃圾回收器 9> 怎么从理论 -> 验证 1> javap -c Math.class > Class.txt（字节码反编译JVM指令） 2> jvisualvm 10> 垃圾回收 1> java栈、本地方法栈、程序计数器都是"线程独有"的，线程结束，自动释放空间，不需要GC管。 2> JVM调优，指的就是堆空间GC优化 11> 元空间呢 jdk1.6，有永久代，常量池在方法区 jdk1.7，有永久代，常量池在"堆"； jdk1.8，无永久代，常量池在"元空间"（独立于JVM，直接内存） 注：方法区是一种逻辑概念，元空间、永久代都是jdk对这个概念的代码实现 12> 堆空间分为：年轻代（1/3）和老年代（2/3）; 年轻代分为：Eden区（8/10）、Survivor区（2/10）; Survivor区分为：Survivor 0区和Survivor 1区 注：minor GC 轻GC 注：Eden就是伊甸园的意思 13> GC机制 1> 老年代都满了，就会触发full GC 2> STW（stop the work）： 14> java是解释型语言 15> 编译器类型 1> JIT编译器：just in time，即时编译器 2> 字节码解释器 3> mixed mode 16> JVM运行机制 1> javac将java文件转为class字节码文件 2> java运行将调用JVM的"类装载子系统"加载到方法区 17> 如果是超大对象，直接让Eden区和Surivior区都装不下。则会直接放在老年代中。 18> 国外试验数据结构的网站？JVM类加载器
1> 类加载过程 1> 加载 -> 链接 -> 初始化 2> 链接包括：校验 -> 准备 -> 解析 1> 加载：在硬盘上查找并通过IO读入字节码文件 2> 校验：校验字节码文件的正确性 3> 准备：给类的静态变量分配内存，并赋予默认值 4> 解析：类装载器装入类所引用的其他所有类 5> 初始化：对类的静态变量初始化为指定的值，执行静态代码块 2> 类加载器种类 1> 启动类加载器：负责加载JRE的核心类库，比如jre目录下的rt.jar，charsets.jar等 注：启动类加载器是c++写的，调用类名.getClassLoader.getClass.getName得到null 2> 扩展类加载器：负责加载jre目录下的ext目录中的jar包 3> 系统类加载器：负责加载ClassPath路径下的类包 4> 用户自定义加载器：负责加载用户自定义路径下的类包 3> 类加载机制 1> 全盘负责委托机制 2> 双亲委派机制： 3> 为什么要用"双亲委派机制"？ 1> 沙箱安全机制： 2> 避免类的重复加载： 4> 查看类加载过程 1> 类启动加参数：-verbose:class 2> 如果是IDEA：Run -> Edit Configurations -> VM -> -verbose:class 5> 在线画图工具 1> draw.io 2> processon.com 6> JVM加载jar包是否会将包里所有类都加载进内存？ 1> 不会 2> java命令是增加参数-verbose:class -> 如：java -verbose:class MathTest 3> JVM对class文件是按需加载（运行期间动态加载），所以如果类中有对象引用， 外部类加载 -> 连接 -> 初始化，执行到外部引用，才会开始加载内部对象类JVM调优 - 命令
注：jdk目录下的bin目录下自带的工具 1> jinfo 注：查看JVM相关参数 1> 查看某线程：jinfo -flag 进程号 2> 查看所有java信息：jinfo -sysprops 进程 2> jstat 1> 查看堆内存使用量，加载类的数量 2> jstat -class 进程号 3> 垃圾回收统计：jstat -gc 进程号 4> 堆内存统计：jstat -gccapacity 进程号 5> 新生代垃圾回收统计：jstat -gcnew 进程号 6> 新生代内存统计：jstat -gcnewcapacity 进程号 7> 老年代垃圾回收统计：jstat -gcold 进程号 8> 老年代内存统计：jstat -gcoldcapacity 进程号 9> 元空间统计：jstat -gcmetacapacity 进程号 3> jmap 1> 用来查看内存信息 2> 实例个数以及占用内存大小：jmap -histo 进程号 > ./log.txt （可用jhat动态分析） 3> 堆总体信息：jmap -heap 进程号 4> 导出dump文件：jmp ... -> 装入jvisualvm图形界面分析，文件->装载->选地址 注：留下案发现场 -> 启动加参数 -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=./（路 径）。然后拿到dump文件，装载进jvisualvm图形界面进行分析。 4> jstack 1> 排查死锁：jstack 进程号（中间会有线程状态等信息，最后会打印死锁信息） 2> 远程连接jvisualvm：需要手动在项目启动时开JMX端口 1> 启动jar程序开启配置：java -Dcomxxxxx -jar foo.jar 2> tomcat的JMX端口配置：JAVA_OPTS=xxxx 注：jvisualvm远程连接服务器需要在远程服务器上配置host（连接ip主机名），并且要关闭防火墙 3> 查找占用cpu最高的堆栈信息 1> top命令，找到pid进程号 2> 按H，找到tid线程号 3> tid转十六进制 4> 执行statck tidJVM垃圾收集
1> 如果是超大对象，直接让Eden区和Surivior区都装不下。则会直接放在老年代中。 2> java启动加参数： 1> 打印GC日志：-XX:+PrintGCDetails 2> 进入老年代阈值：-XX:MaxTenuringThreshold 3> 如何判断对象可以被回收？ 1> 引用计数法：引用计数器的数量为0时（Math m1 = new Math();Math m2=m1; --> 引用计数器为2） 如果：m1 = null; m2 = null;则垃圾回收器可以对对象进行呢回收。 1> 效率高，初期jdk版本使用，目前主流都不用 2> 不能解决对象之间相互循环引用的问题 2> 可达性算法： 1> 通过"GC Roots"根节点，向下搜索。当一个对象没有和任何"GC Roots根节点"相连的话，就说明 对象不可用。 2> GC Roots根节点：类加载器、static成员、本地变量表、常量引用、本地方法栈的变量、Thread 4> finalize使用 1> 是Object类的一个方法，保证类在垃圾回收之前完成对特定资源的回收。 2> 可达性算法之后，还要经过再标记过程 1> 第一次标记：查看对象是否重写了finalize方法（是Object的方法），没有就回收 2> 有重写finalize方法，则放入一个队列中，之后会有专门线程触发该方法，但不保证方法执行完 成。如果执行finalize方法之后，对象重新有了引用，则移出队列。没有，则被回收。 5> 垃圾回收算法 1> 清除-标记算法 2> 复制算法 3> 清除-整理算法 注：年轻代可以用复制算法；老年代可以用清除-标记算法、清除-整理算法 6> 垃圾回收器 1> serial回收器：最开始串行 2> parNew回收器：最开始并行 3> parallelGC回收器：JDK1.8默认 1> 类似parNew回收器 2> 更大吞吐量，更高效利用CPU 4> CMS收集器： 1> 第一款真正意义的"并发收集器"，之前的是"并行收集器" 2> 步骤：初始标记 -> 并发标记 -> 重新标记等，目的是让STW的时间尽可能短 5> G1回收器：JDK1.9默认（JDK1.7已出现） 1> G1将java堆划分为多个大小相等的独立区域（Region），虽然保留新生代和老年代的概念，但不再 是物理隔阂，它们都是不连续的区域。 2> 新增Humongous区，分配大对象，直接进Humongous区。 3.1> 可预测的停顿，是G1相对CMS最大的优势。内部建立了可预测的停顿时间模型，可指定垃圾回收 在一个时间段（毫秒）内完成。 3.2> G1收集器在后台维护了一个优先列表，每次根据允许的收集时间，有限选择回收价值最大的 Region 4> G1有"YoungGC"和"MixedGC"（MixedGC收集所有新生代和部分老年代）; 如果没有了region可用了，还是会产生"FullGC" 6> ZGC回收器：JDK11默认 回收1T以上的堆空间 总结： 1> 如果老年代->CMS，则新生代->ParNew 2> 如果老年代->Parallel Old，则新生代->Parallel Scavenge 3> 如果老年代->Serial Old，则新生代->Serial 7> 如何选择垃圾回收器 1> 官方推荐： 1> 新生代：Serial、ParNew、Parallel Scavenge 2> 老年代：Serial Old、Parallel Old、CMS 注：配合使用，怎么配合，官方有图 3> 如果选用G1收集器可以同时用在新生代和老年代 2> 原则： 1> 优先调整堆的大小，让服务器自己来选择 2> 如果内存小于100M，使用串行收集器 3> 如果是单核，没有停顿时间，使用串行 4> 如果允许停顿时间超过1s，使用并行 5> 如果响应时间最重要，使用并发JVM调优 - 实战
1> JVM调优的两个指标 1> 停顿时间：STW时间。 -XX:MaxCGPauseMills 2> 吞吐量：垃圾收集时间和总时间的占比：1/(1+n)，吞吐量：1-1/(1+n)。 -XX:CGTimeRatio=n 注：-XX:+PrintGCDetails输出的PSYoungGen就是Parallel Scavenge收集器 2> JVM调优步骤 1> 打印GC日志：-XX:+PrintGCDetails -XX:+PrintGCTimeStamps -Xloggc:./test.txt 参数（将GC日志输出到文件） 2> 分析日志 3> 调优JVM参数 3> 参数（使用不同GC收集器） 1> Parallel Scavenge收集器 + Parallel Old收集器： 2> ParNew收集器 + CMS收集器： 3> Serial收集器 + Serial Old收集器： 4> G1收集器：-XX:+UseG1GC 4> 分析工具 1> gceasy（国外网gceasy.io） 2> gcviewer（客户端）
7、Mysql相关
索引底层数据结构与算法
1> 磁盘存取原理 1> 寻道（速度慢、耗时） 2> 旋转（速度较快） 2> 索引使用的数据结构及原因 1> 为什么不用"二叉树" 1> 什么是二叉树（Binary Tree） 二叉树是每个节点最多有两个子节点的树。 2> 数据量大的时候，深度会很大，可能会出现不平横的情况 2> 为什么不用"红黑树" 1> 什么是红黑树（Red-Black Trees） 1> 红黑树属于平衡二叉树 2> 做了平衡，但是数据量大的时候，深度会很大（高度不可控） 3> 每个节点下最多两个子节点，所以第二行最多2个，第三行最多4个，依次类推。大数据量，很大的 3> 为什么不用"Hash" 1> 定位查找，只需要把字段做hash运算，一次运算就可以知道结果 2> 但是没有办法做范围查询 3> MySQL索引类型包括：B+Tree和Hash 4> 为什么不用"B树" 1> 度（Degree）：节点的数据存储个数 2> 可以有效控制深度（度越大，深度越小） 3> 问题：那么度（Degree）是不是设置的越大越好？ 4> 度大小的设置，磁盘和内存之间一次交互数据量，是以"页"为单位，"页"的整数倍，1"页"大 小"4K"。MySQL会根据计算机硬件条件，设置"度"为一次交换数据量的大小。 注：预读：磁盘一般会顺序向后读取一定长度的数据（页的整数倍）放入内存 5> 使用"B+树" 1> 非叶子节点不存储data，只存储key，可以增大度 MySQL底层已经固定确定了度（Degree）的大小，所以单个数据大小，就决定了一个节点可以 存储的数据多少 2> 叶子节点之间有指针指向（方便范围查询） 3> 数据会有冗余，因为非叶子节点不存储data， 4> B Trees节点的大小设为一页，每次新建节点直接申请一个页的空间，这样就保证一个节点 物理上也存储在一个页里，就实现了一个节点的读入只需要一次I/O 3> MyISAM索引实现（非聚集） 1> 索引文件和数据文件是分离的 2> 一张表有3个文件（.fmt、.myd、.myi即format数据结构、mydata数据，myindex索引） 3> 先到.myi文件中找到所查找数据的地址 4> 再到.myd文件中找到对应数据 5> primary key（主键索引）和secondary key（非主键索引）的存储方式一样 注：二级索引，即非主键索引 4> InnoDB索引实现（聚集） 1> 数据文件本身就是索引文件 2> 聚集索引（主键索引） - 叶节点包含了完整的数据记录 3> 二级索引，叶节点只包含了该字段和主键两个值 4> 第三条解释了，为什么InnoDB表必须要有主键 5> 二级索引，叶子节点存储主键值，是为了一致性和节省空间。（否则维护两个索引文件） 注：二级索引，即非主键索引 注：二级索引，先找到主键，再到主键索引中匹配主键，拿所有数据 （因为主键索引存所有数据，非主键索引只存主键） 5> 联合索引 每个节点中的单个数据，都是多个字段组成的，查找的时候，先比较第一个字段，如果不是，不再比较第二 第三个字段，直接往下比较。Explain查询
1> 各字段含义 1> id列： 数字越大，越先执行。如果id值相等，则从上往下执行，越靠上优先级越高。 2> select_type列： 1> simple：简单查询。查询不包含子查询和union 2> primary：复杂查询中最外层的select 3> subquery：包含在select中的子查询 4> derived：包含在from中的子查询。（MySQL会将查询结果存放在一个临时表中，也称为派生表） 5> union：在union中的第二个和随后的select 6> union result：从union临时表检索结果的select 3> table列： 表名 4> type列（优化时常用）： 1> 标识关联类型或访问类型（即MySQL执行引擎决定怎么查找，查找哪些范围） 2> 效率优先级：system > const > eq_ref >ref > range > index > ALL 1> system：表里总共就1条数据 2> const：由条件查询到结果集就1条数据 3> eq_ref：equal reference（主键/唯一关联）primary key或unique key索引的所有部分 被连接使用，最多只会返回一条符合条件的记录。 除const之外最好的连接类型。 如：表A主键左连接表B字段，A一条对应B多条 4> ref：相比eq_ref，关联字段（或where条件字段）不是唯一索引，而是普通索引。 ref因为普通索引字段，可能查出来多条字段； eq_ref因为主键索引，只会查出一条字段。 5> rang：有between、in、>等 6> index：扫描全表索引，通常比ALL要快（表字段都建了索引） 7> ALL：全表扫描。（表中有字段没有索引，通常需要增加索引进行优化） 注：一般来说，查询级别达到range就可以，最好达到ref 5> ※possible_keys： 执行引擎 分析可能会用到的索引，最终用到的索引是key列，两列可能一样可能不一样 6> ※key列（优化时常用）： 最终用到的索引是key列 7> ※key_len列： 用到了几个索引（字节加起来），比如一个表联合索引的字段都是int，则int类型是4个字节。 key_len就是8 1> 字符串： 1> char(n)：n字节长度 2> varchar(n)：如果是utf-8，则长度3n+2。 （2个字节，是备注字符长度的，int值） （如果允许NULL，则3n+2+1。多出一个字节，是char，备注是否允许为null） 8> ※ref列： 索引关联的字段。比如用到了联合索引中的第一个索引，右关联到一张表的主键，ref列的值就是"一张 表的主键"。如果只是联合索引表自己使用，ref列的值会是联合索引值。 9> rows列： MySQL执行引擎估计会扫描的行数。 10> Extra列（优化时常用）： 1> 附加信息，比较复杂 2> Using index： 覆盖索引，查询的列被索引覆盖。比如表联合索引有3个索引字段，查找的两个字段就在联合索引 中，就会直接从索引中拿值。如果是查询select *则还有其余不是索引的字段。就不会是 Using index 注：where条件中字段是索引的前导列（联合索引最左边的列），是性能高的表现 3> Using where 查询的列未被索引覆盖，where字段不是索引的前导列 4> Using where;Using index： where条件中字段不是索引的前导列，无法利用索引查找（最左前缀），但是查找数据在索引中。 因为通过配置，索引可以加载在内存中，可以不用到硬盘中拿数据。 5> NULL： where条件是索引的前导列，但是查询字段都没有被索引覆盖。（需要回表来实现） 6> Using index condition： where条件中是一个前导列的范围，查询列不完全被索引覆盖 如：where file_id > 10 7> Using temporary： 一些语句，比如select distinct，MySQL执行引擎会建一张临时表，效率较低。 如果distinct字段有索引，被索引覆盖，就不会建临时表 8> Using filesort： order by语句的字段，没有索引的情况。 如果有索引（索引是排好序的数据结构B+Tree底层已经排序了），则Using index 2> explain extended 1> 语法：select语句前加explain extended，第二行写show warnings; 2> 结果：MySQL引擎分析之后，查询优化，得到的最终执行SQL（复杂sql是没办法优化的） 3> 最左前缀原则 注：和select * from db.table_1 order by col1,col2,col3 desc一模一样。 就相当于把上述sql查询结果提前放在了B+Tree结构中。 所以where col2=,col3=或者where col1=,col3=都不会使用索引。 因为抛开col1，col2的顺序就是乱的。 注：只要包含第一个索引，且其余索引连续，比如一共3个索引，where key1=,key2，则内部也是会进行优 化的。也会使用索引。 但是如果没有包含第一个索引，或者使用了第一个索引但是中间有隔开的，都不能使用索引。 4> 最佳实践 1> 全值匹配 联合索引3个字段，则where col1=,col2=,col3= 顺序随便写，MySQL执行引擎会进行优化，顺序不影响引用的使用。 2> 最左前缀原则 详见第三点 3> 不在索引上做任何操作（会导致索引失效） 4> MySQL执行引擎不能使用索引中范围条件右边的列 比如第二个字段用了范围操作，第三个索引就用不上了。它是把第二个索引符合的都搂出来，再循环第 三个字段，已经用不到索引了。 5> 尽量使用覆盖索引 反例：select * from table_1 where col1=,col2=,col3=，则是Using index condition 因为如果索引在内存中，虽然col1,col2,col3是联合索引，顺序也对，但是找到之后，B+Tree 中存储的是索引字段+主键，还需要到主键索引表中，拿数据。 正例：Using index 6> 索引字段使用!=或者<> 联系B+Tree底层结构，没办法走索引。 也会导致全表查询 7> 索引字段使用is null或者is not null 联系B+Tree底层结构，没办法走索引。 也会导致全表查询 8> like加%通配符 1> like '%xx'，不走索引 优化方法：把select * 改为select col1,col2,col3，则Using where;Using index： 2> like 'xx%'，会走索引 注：联系B+Tree底层结构 9> 字符串不加''单引号，索引失效 10> 少用or，索引会失效 少用or或in，用它时，非主键字段的引用会失效，主键索引有时失效，有时失效，和数据量有关。实战
1> 表有3个索引，where后面3个字段都有，顺序不按联合索引的字段顺序，会使用索引吗 答：会，mysql执行引擎会做优化。而且只用两个索引，只要有第一个索引，即where 1,2或者where 2,1 2> where col1=,col2>,col3=，则col2会使用索引吗，col3呢 答：col2会，col3不会。 3> where c1=,c2=,c4>,c3=，哪些字段会走索引？ 答：都会走。即第一点和第二点综合起来。MySQL执行引擎会优化顺序，c3到c4前，而且范围会走索引。 4> where c1>,c2=,c3=，哪些字段会走索引？ 答：都不走。很奇怪，记住结论吧。（第一个索引就用范围） 5> 是否where字段是索引，就一定会走索引 答：不是。mysql会优化，如果觉得走索引还没有全表查询快，就不走索引 =========================================================================================== 注：where中索引用以过滤，order by中索引用以排序（都是利用B+Tree已排序好的数据结构） 注：如果没有使用索引，Extra列会有Using filesort值 注：mysql有两种排序，自带的filesort排序，还有是index索引排序 6> order by 题：where c1=,c2,c4 order by c3，则哪些字段会走索引？ 答：c3会，c4不会。索引都帮忙排好序，mysql肯定不会重新搞一个filesort文件去排序。 但是c4不会，因为"精确定位已经断掉了"，只能是先根据c1，c2精确定位，再排序，再循环找出c4 7> order by 题：where c1=,c2= order by c4，则哪些字段会走索引？ 答：c4不会，因为最左前缀原理 8> order by 题：where c1=,c4= order by c2,c3，则哪些字段会走索引？ 答：会 9> order by 题：where c1=,c4= order by c3,c2，则哪些字段会走索引？ 答：c2和c3不会，因为最左前缀原理 10> order by 题：where c1=,c2= order by c2,c3，则哪些字段会走索引？ 答：会 11> order by 题：where c1=,c2=,c5= order by c2,c3，则哪些字段会走索引？ 答：会 12> order by 题：where c1=,c2=,c5= order by c3,c2，则哪些字段会走索引？ 答：会。因为c2已经是固定值了，mysql经过了优化估算。 13> order by 题：order by c1 asc,c2 desc，则哪些字段会走索引？ 答：不会。因为B+Tree是联合起来做了升序，一升一降已经无法满足了 =========================================================================================== 注：group by底层是先对group by后字段进行order by 注：如果没有使用索引，Extra列会有Using temporary（当然也会有Using filesort）值 注：where的性能高于having，能在where中限定条件就不要去having中限定 13> group by 题：where c1=, c4= group by c2,c3，则哪些字段会走索引？ 答：会。 14> group by 题：where c1=, c4= group by c3,c2，则哪些字段会走索引？ 答：不会。因为底层会先排序。会产生Using filesort，Using temporary，极度恶劣 15> group by 题：where c1> group by c1，则哪些字段会走索引？ 答：不会。第一个字段要避免范围查询。 16> group by 题：where c1 in(,) group by c2,c3，则哪些字段会走索引？ 答：不会 =========================================================================================== 17> in和exists区别 1> in里面有数量限制 之前在oracle测试过，超过500好像，版本忘了，一条数据都查不出来。 用exists代替解决了 2> 规则就是"小表驱动大表" 1> select * from table where col in()，先执行in里面子查询，需要子查询是小表，外面大表 2> select * from table where exists (select 1)，先执行外面，需要小表，exists里是大表锁
1> 锁分类 1> 性能分：乐观锁和悲观锁 2> 对数据库操作：读锁和写锁 3> 对数据操作粒度：表锁和行锁 2> 读锁（共享锁）、写锁（排他锁） 1> 读锁，会阻塞写，不会阻塞读 注：共享锁 - 用来数据迁移，锁起来，都不能写，都可以读。 只能读，不能写（包括自己和其他session都不能写，自己报错，其他阻塞） 2> 写锁，会把读和写都阻塞 注：排他锁 - 用来增删改查前，锁起来； 锁起来，只能自己读+写（其他session读、写都不能做） 3> 表锁（偏读 - 打开表，尽量批量读） 注：MyISAM引擎偏向于表锁 1> 手动给表加锁（读锁/写锁） lock table xxx read lock table xxx write 2> 查看加过锁的表 show open tables 3> 删除表锁 unlock tables 注：读锁常用在数据迁移，给表加上锁，可以读，但是自己和其他session都不能写。 注：MyISAM在执行SELECT语句时，会给涉及到的表加读锁；执行增删改查前，会给涉及的表加写锁。 4> 行锁（偏写 - 逐行写，逐行关） 注：InnoDB引擎偏向于行锁 注：行锁支持事务 1> 开启事务 begin; 2> 关闭事务 commit; 3> 回滚事务 rollback; 注：一个session开启事务，update一行数据，没有commit之前，会给该行数据加行锁。 其他session不能update这行数据，阻塞。但是不影响update其他行数据。 5> 事务（事务特性+并发中事务出现问题） 1> 事务特性： ACID，即原子性、一致性、隔离性、持久性 2> 事务让并发变为可能（但是仍会出现问题） 脏读、幻读、不可重读、更新丢失 注：脏读，为什么一个session没有提交的数据，另一个session会读到。 因为有"隔离级别"的不同。 1> 脏读：一个事务读取了另一个事务还没有提交的数据 2> 不可重复读：一个事务读取了另一个事务已经提交的修改数据 3> 幻读：一个事务读取了另一个事务提交的新增数据 6> 事务隔离级别（mysql如何机制解决并发事务问题） 注：事务隔离级别底层可以帮我们解决脏读、幻读、不可重复读的问题（都是读一致性问题） 1> 不同的事务隔离级别 隔离级别 脏读 不可重复读 幻读 读未提交 可能 可能 可能 读已提交 不可能 可能 可能 可重复读 不可能 不可能 可能 可串行化 不可能 不可能 不可能 2> 命令 1> 查看当前事务隔离级别：select @@tx_isolation from dual;（tx-transaction） 2> 设置新的事务隔离级别：set tx_isolation='read-uncommitted'（比如设置读未提交） 3> 可重复读（MySQL默认隔离级别） 1> 现象：字段原来是450，两个事务同时开启，A事务update字段为400，B事务读字段还是450； 但是B事务update col=col-50，结果却变为350。 注：可以这么记 - 可重复读，强调的是"读"是没问题的，没有说可以用来"写"。 2> 解释：可重复读隔离级别下使用了MVCC（multi-version concurrent control）机制， select操作不会更新版本号，是读快照（历史版本）；insert/update/delete会更新版本号， 是当前读（当前版本） 3> 所以更新"库存"sql应写成update table set balance=balance-10。而不能先在代码中计算出 减法之后，再直接update减后的数字。 4> 现象：一共4条数据，事务A插入一条数据，事务B去select，结果还是4条。（因为读的是快照） 但是事务B去update事务A新插入的数据，是可以成功的。（因为MVCC机制，和幻读没有解决） 4> 可串行化（Serializable） 已经没有并发了，一个事务完了，在开始另一个事务。这压根没有效率 5> 解决幻读（非代码级别，用MySQL解决） 间隙锁：通过范围去加锁，即使记录不存在，也会预先加上锁。 共5要记录，事务A更新id=5：update table set col = where id>4 and id<=20 事务B执行insert语句：insert into values (6,'','')，会等待阻塞，超时之后报错。 7> 死锁 session 1：begin; 开启事务 session 2：begin; 开启事务 session 1：select * from table where id=1 for update; 第一行加锁 session 2：select * from table where id=2 for update; 第二行加锁 session 1：select * from table where id=2 for update; 第二行加锁（阻塞，等待s2放锁） session 2：select * from table where id=1 for update; 第一行加锁（阻塞，等待s1放锁） 结果：第四行命令执行完，立马报错 Deadlock found when trying to get lock; try restarting transaction 解释：两个事务相互等待时，会发生死锁 命令：杀掉死锁 v$locked_object v$session
8、Spring相关
预备
1> 备注： 1> SqlSessionFactoryBean 2> 注入方式：https://www.cnblogs.com/icehand1214/p/9708174.html 3> idea创建spring项目：https://www.cnblogs.com/chenyulin/p/creatSpringproject.html 2> 快捷键： 1> IDEA生成图谱： ctrl + alt + u，详细图谱 ctrl + alt + shift + u 来源：https://www.cnblogs.com/deng-cc/p/6927447.html 2> IDEA在debug时evaluate： alt + f8 3> 查找接口的实现类： ctrl+h 4> 查看类中所有方法 ctrl + f12 注：过滤结果搜索，不需要ctrl+f等，直接按键盘即可。 5> 全局搜索 edit -> find -> find in path ctrl + shift +f 6> 条件断点IoC容器设计理念
前提： "IoC中如果没有依赖注入"，那这个框架就只能帮我们构建一些简单的Bean，而之前所说的复杂Bean 的构建问题将无法解决，Spring框架就不可能像现在这样成功。 1> 没有Spring的时候，怎么创建"依赖对象" 1> 外部new出来，传入调用对象 1> 构造方法传入 2> 属性set方法传入 3> 调用方法时，动态传入 2> 内部自己new出来 1> 属性赋初始值直接new 2> 初始化方法中直接new 3> 其他业务方法中直接new 比如：外部new =================== Test t = null; public Test2 (Test t) { this.t = t; } =================== Test t = new Test(); Test2 t2 = new Test2(t); 2> 为什么使用Spring 注：如果是一个简单的对象，用不用Spring没有太大区别。 传统方法 Goods water = new Water(); Train train = new Train(water); Spring方法 context.getBean("train"); 1> 来源： https://zhuanlan.zhihu.com/p/70147855 基于POJO的轻量级和最小侵入性编程； 通过依赖注入和面向接口实现松耦合； 基于切面和惯例进行声明式编程； 通过切面和模板减少样板式代码。 2> 解释： 1>================================================================================ 没有Spring的时候，每个对象负责管理着依赖的对象引用 注：因为Water水和coal煤都可以实现Goods物品接口，都实现doSomthing方法 public class Train implements Transport{ private Goods goods; public Train() { goods = new Water(); } public void catchGoods(){ goods.doSomthing(); //水的话，是用来浇灌庄稼 } } 注：上面创建"依赖对象"方法是 - "内部自己new出来"。这样就造成这两个对象的紧耦合，这个火车 可以运水来浇灌农田，但是如果让这个火车来运煤供暖，可能就不太符合了。 因为Water水和coal煤都可以实现Goods物品接口，如果想运送煤炭，就需要修改代码。 2>================================================================================ 所以，为了解决紧耦合，可以采用创建"依赖对象"另一种方法，"外部new出来，传入调用对象" public class Train implements Transport{ private Goods goods; public Train(Goods goods) { this.goods = goods; } public void catchGoods(){ goods.doSomthing(); } } 注：外部创建对象 Goods coal = new Coal(); 外部对象传入 Train train = new Train(coal); 或者 外部创建对象 Goods water = new Water(); 外部对象传入 Train train = new Train(water); 实现了"松耦合" 3>================================================================================ 但是，虽然实现了松耦合，还有问题。（利用"外部new出来，传入调用对象"） 如果一个对象具有"复杂的依赖关系"，在调用对象的时候，就需要在代码中写繁琐的创建对象代码。 比如A依赖B，B依赖C，C依赖D 创建A对象： D d = new D(); C c = new C(d); B b = new B(c); A a = new A(a); 注：需要代码来维护"复杂的依赖关系" 所以，可以使用Spring的"依赖注入"，让Spring来管理复杂的依赖关系，调用时从上下文对象中拿出 即可。 3> 实体Bean的构建 1> 基于Class构建（无参构造器） 2> 构造方法构建（有参构造器） 3> 静态工厂方法构建（工厂方法创建对象） 4> FactoryBean构建（实现FactoryBean方法，不是有构造器/工厂类创建对象的情况） =========================================================================== 1> 基于Class构建： <bean class="com.guozi.HelloWorld"></bean> 注：底层基于class属性，反射进行构建（无参构造器） 2> 构造方法构建： <bean id="user1" class="com.boss.domain.User1"> <constructor-arg name="username" value="李四" /> <constructor-arg index="1" value="25" /> </bean> 3> 静态工厂方法构建 <bean class="com.boss.domain.User1" factory-method="build"> <constructor-arg name="username" value="李四" /> </bean> 4> FactoryBean构建 注：bean配置和普通bean一样 class类实现FactoryBean接口 3> 依赖注入 1> 概述 试想IoC中如果没有依赖注入，那这个框架就只能帮我们构建一些简单的Bean，而之前所说的复杂Bean 的构建问题将无法解决，Spring框架就不可能像现在这样成功。 2> 依赖注入的方式 1> set方法注入 2> 构造方法注入 3> 自动注入（byName，byType） =========================================================================== 1> "通过set方法"注入 <bean id="userDao" class="com.boss.dao.imp.UserDaoimpl" /> <bean id="userService" class="com.boss.service.imp.UserServiceImpl"> <property name="userDaoImpl" ref="userDao" /> </bean> 注：底层基于class属性，反射进行构建（有参构造器） 2> "通过构造器方法"注入 <bean id="user1" class="com.boss.domain.User1"> <constructor-arg name="userDao" ref="userDao" /> </bean> 3> 自动注入 <!--自动注入 byType--> <bean class="com.guozi.HelloIoc"/> <bean id="helloSpring" class="com.guozi.HelloSpring" autowire="byType"/> public class HelloSpring { private HelloIoc helloIoc; } <!--自动注入 byName--> <bean id="helloIoc" class="com.guozi.HelloIoc"/> <bean id="helloSpring" class="com.guozi.HelloSpring" autowire="byName"/> public class HelloSpring { private HelloIoc helloIoc; } 注：byName是根据class中属性名，和xml中id和name想匹配知道，并自动注入的。 注：还有一种是default，需要<beans>标签加属性default-autowired 注： 1> set注入，需要property标签，类中需要set/get方法 2> 构造器注入，需要constructor-arg标签，类中需带参要构造器 3> 自动注入，xml和class都不需要配置。Spring自动判别 4> bean的基本特性 1> 作用范围 1> 类型有：prototype（getBean获取到的是多例）、singleton（getBean获取到的是单例） 2> singleton的话，会缓存在IoC的容器中 3> "bean标签中的属性"：<bean class="com.HelloSpring" scope="singleton"></bean> 注： @Controller的Bean默认是单例的，所以避免加属性成员变量 2> 生命周期 1> Bean对象的创建、初始化、销毁就是Bean的生命周期。 2> "bean标签中的属性"：init-method、destroy-method指定初始化和销毁时调用的方法 3> 加载机制 1> 懒加载：使用的时候，才创建Bean 2> 非懒加载：容器启动时即创建对象 3> 懒加载容器启动更快，非懒加载可以在容器启动时更快发现程序中的错误。 4> "bean标签中的属性"：<bean class="com.HelloSpring" lazy-init="false"></bean> 注： 当scope="prototype" (多例)时，默认以懒加载的方式产生对象。 当scope="singleton" (单例)时，默认以非懒加载的方式产生对象。源码学习-IoC
注：学习目标 1> Bean工厂如何生产Bean 2> Bean依赖关系由谁来解决 3> Bean工厂和应用上下文的区别 1> Bean工厂如何生产Bean 注：目标 1> xml配置的bean转变为哪个Class对象 2> 把bean标签变为Class对象，是谁来完成的 3> 这些Class对象都保存在了哪儿 1> xml配置的bean转变为哪个Class对象 1> BeanDefinition（Bean定义） 1> 概述： xml的Bean信息最后都将保存在BeanDefinition对象中， 每个Bean创建一个BeanDefinition对象。 2> xml和BeanDefinition属性对应关系 XML-Bean BeanDefinition class beanClassName scope scope lazy-init lazyInit constructor-arg ConstructorArgument property MutablePropertyValues factory-method factoryMethodName 3> id属性作为Bean的key注册到BeanDefinitionRegistry注册器中。 name属性作为别名key注册到AliasRegistry注册中心。 最后都是指向其对应的BeanDefinition。 2> BeanDefinitionRegistry（Bean注册器） 1> "注册进去" id放在了BeanDefinitionRegistry接口中，如下方法： void registerBeanDefinition( String beanName, BeanDefinition beanDefinition) 第一个参数，就是id值 第二个参数，就是Bean的承载对象 2> "取出来" 所以，一个id只有一个Bean，一个Bean可以有多个id还是注册类中，我们可以通过id获取 到BeanDefinition对象： BeanDefinition getBeanDefinition(String beanName) 注：name属性值放在了接口AliasRegistry中，即注册接口继承的接口 3> BeanDefinitionReader（Bean读取、创建、注册总操控） 代码模拟Spring构建Bean public static void main(String[] args) { //注册中心 BeanDefinitionRegistry registry = new SimpleBeanDefinitionRegistry(); //读取器 XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(registry); //资源加载器 DefaultResourceLoader loader = new DefaultResourceLoader(); Resource resource = loader.getResource("spring-cfg.xml"); //装在构建Bean reader.loadBeanDefinitions(resource); //所有构建出来的Bean String[] allBeanDefinitions = registry.getBeanDefinitionNames(); System.out.println(Arrays.toString(allBeanDefinitions)); //注册器中通过拿name别名 registry.getAliases("helloWorld"); //注册器中通过id拿Bean registry.getBeanDefinition("helloWorld"); } 注：BeanDefinition对象只能通过id来获取 2> 把bean标签变为Class对象，是谁来完成的 概述：有了bean定义就相当于有了配方，现在缺工厂来进行加工生产出Bean 2> Bean依赖关系由谁来解决Spring事务
1> Spring事务特点 1> 在数据库事务基础上进行封装扩展 2> 加入事务传播的概念 3> 提供声明式事务，让业务代码和事务分离 2> Spring提供API实现事务控制 1> TransactionDefinition（事务定义） 2> PlatformTransactionManager（事务管理） 3> TransactionStatus（事务运行时状态） 4> 示例代码（Spring提供事务使用接口）： 注：spring提供了@transactionTemplate 方法级别的事务注解，使用方便 但是 方法级别的事务，粒度不够细。 因此 可以使用spring提供的TransactionTemplate 工具类来控制细粒度事务。 public static void main(String[] args) { //创建TransactionTemplate final DataSource ds = new DriverManagerDataSource(url, username, pwd); TransactionTemplate template = new TransactionTemplate(); template.setTransactionManager(new DataSourceTransactionManager(ds)); //使用TransactionTemplate template.execute(new TransactionCallback<Object>() { public Object doInTransaction(TransactionStatus status) { Connection conn = DataSourceUtils.getConnection(ds); try { PreparedStatement ps = conn.prepareStatement( "insert into dushu values (?,?,?,?)"); ps.setInt(1,1); ps.setString(2,"淳熙严州图经"); ps.setString(3,"宋·陈公亮"); ps.setString(4,"暂缺简介..."); ps.executeUpdate(); int i = 1/0; } catch (Exception e) { status.setRollbackOnly(); System.out.println("回滚操作："+e.getMessage()); } return null; } }); } 注：通过Connection conn = DataSourceUtils.getConnection(ds);后去链接是同一个 3> 声明式事务 1> 概述： 第三点通过调用API来实现对事务的控制，非常繁琐，与直接操作JDBC事务没有多大改善，所以Spring 提出了声明式事务。让业务代码和事务分离，不需要程序猿关心事务 2> 示例： 配置文件中，配置bean - DataSourceTransactionManager，这个类实现了 PlatformTransactionManager接口，所以有事务提交和回滚的方法。 最重要：添加事务的注解驱动 <tx:annotation-driven transaction-manager="txManager"></tx:annotation-driven> 注：txManager就是DataSourceTransactionManager这个Bean 4> 事务传播机制 注：这些定义，都是占在内层方法，即被调用方法的出发点来定义的。 比如required，就是内层方法发现外层方法已有事务，则加入该事务，如果发现没有，就只给自己创 建一个新事务：Creating new transaction with name（内层事务创建） 1> 类别和特性 类别 事务传播类型 说明 支持当前事务 required(必须的) 先探测事务，若已有，则加入，若没有，为自己新建一个 supportes(支持) 先探测事务，若已有，则加入，若没有，以非事务执行 mandatory(强制) 先探测事务，若没有，否则报错 不支持当前事务 requires_new(隔离) 无论如何，先新建事务，若已有，则挂起，完成后resume not_supported(不支持)无论如何，非事务执行，若已有，则挂起，完成后resume never(强制非事务) 无论如何，非事务执行，若已有，则挂起，就抛异常 套事务 nested(嵌套事务) 若已有，则在嵌套事务内执行 2> 测试示例 不要看视频的，看如下博客：https://blog.csdn.net/qq_26323323/article/details/81908955 自己做示例，外层required，内层not_supported 1> Creating new transaction with name（外层事务创建） 2> Executing prepared SQL statement [insert into dushu （执行外层操作） 3> Suspending current transaction (内层挂起外层事务) 4> Executing prepared SQL statement [insert into dushu （执行内层操作） 5> Resuming suspended transaction after completion of inner transaction（还原事务） 注：所以，如果内层报错（在update之后报错），内层插入数据库成功，外层失败回滚。 3> 引出声明式事务的底层原理 示例：如果外层required，内层required_new，外层报错。 本来结果应该是，内层成功，外层回滚。 但如果内外层方法，都放在一个类中，外层调用内层，结果却是：都失败 引出：声明式事务底层原理是，通过aop动态代理，内部相当于this.add()不会动态代理SpringMVC
1> 组件初始化 DispatcherServlet类中的initStrategies方法中 2> HandlerMapping 1> 目前主流的三种mapping 1> BeanNameUrlHandlerMapping 2> SimpleUrlHandlerMapping 3> RequestMappingHandlerMapping 2> 在IoC中实例化这些类之后，DispatherServlet就会通过getHandler方法查找对应Handler，但是返回 的是一个Object类型，还需要适配器adaptor适配这个Object调用哪种handler。 3> HandlerAdaptor 1> spring mvc通过适配器模式来适配调用指定的Handler 2> Handler和HandlerAdaptor对应关系如下： Handler类型 对应适配器 描述 Controller SimpleControllerHandlerAdaptor 标准控制器，返回ModelAndView HttpRequestHandler HttpRequestHandlerAdaptor 业务自行处理，不需返回ModelAndV Servlet SimpleServletHandlerAdaptor 基于标准的Servlet处理 HandlerMethod RequestMappingHandlerAdaptor 基于@RequestMapping对应方法 注： 源码较简单，后面一定要看一下SpringAOP
1> 概述 aop是要实现的目的，SpringAOP是它的一种实现。 2> 应用场景 1> 日志记录 2> 权限验证 3> 效率检查 4> 事务管理 3> SpringAOP底层原理 1> JDK动态代理 2> CGLIB代理 4> SpringAOP和AspectJ关系（使用） 注：SpringAOP提供两种，基于xml和基于注解 1> 加入jar包aspectjweaver 2> 打开aspectj自动代理（xml配置或者写java配置类：@Configuration和@EnableAspectJAutoProxy） 3> 定义Aspect（@Aspect切面，必须交给IoC容器管理） 4> 定义PointCut（@PointCut切点，springel有好多种写法） 5> 定义Advice（@Before/@After通知） 5> 源码分析 1> 一个类，没有实现接口，则IoC容器中保存的是类名.class， UserServcieImpl userServcieImpl = context.getBean(UserServcieImpl.class); userServcieImpl.buyService(); 注：UserServcieImpl是类，发现userService类型CglibAopProxy 2> 一个类，实现了接口，则IoC容器中保存的是接口名.class， UserServcie userServcie = context.getBean(UserServce.class); userServcie.buyService(); 注：UserServce是接口，发现userService类型JdkDynamicAopProxy@2662 注：因为Jdk动态代理，底层已经继承了Proxy类，所以只能用过实现接口来完成代理。 3> 关键类 1> 单例对象转变为"代理类对象" AbstractBeanFactory.java:245 Object sharedInstance = getSingleton(beanName); 2> 多例对象转变为"代理类对象" AbstractBeanFactory.java:330 prototypeInstance = createBean(beanName, mbd, args);Spring5新特性
9、MyBatis相关
10、StringBuilder
https://www.cnblogs.com/shamao/p/10942203.html 1> 可变与不可变 String是不可变字符串对象，StringBuilder和StringBuffer是可变字符串对象（其内部的字符数组长度 可变）。 2> 是否多线程安全 String中的对象是不可变的，也就可以理解为常量，显然线程安全。StringBuffer与StringBuilder中的 方法和功能完全是等价的，只是StringBuffer中的方法大都采用了synchronized关键字进行修饰，因此是 线程安全的，而StringBuilder没有这个修饰，可以被认为是非线程安全的。 3> 执行效率 StringBuilder > StringBuffer > String 当然这个是相对的，不一定在所有情况下都是这样。比如 String str = "hello" + "world"; 的效率就 比 StringBuilder builder = new StringBuilder().append("hello").append("world"); 要高。 4> 因此，这三个类是各有利弊，应当根据不同的情况来进行选择使用： 当字符串相加操作或者改动较少的情况下，建议使用String这种形式； 当字符串相加操作较多的情况下，建议使用StringBuilder，如果采用了多线程，则使用StringBuffer。 注： 1> String类其实是通过char数组来保存字符串的。所有对String类的操作都不是在原有的字符串上进行 的，而是重新生成了一个新的字符串对象 2> 每当我们创建字符串常量时，JVM会首先检查字符串常量池。如果该字符串已经存在常量池中，那么就直 接返回常量池中的实例引用。如果字符串不存在常量池中，就会实例化该字符串并且将其放到常量池 中，同时返回对该实例的引用
11、数据结构
1> 大纲： https://blog.csdn.net/yeyazhishang/article/details/82353846#2%E6%A0%88 1、数组 数组的大小固定后就无法扩容了 2、栈 先进后出（入栈、出栈） 3、队列 先进先出（入队、出队） 4、链表 数据域 + 指针域 5、树 在日常的应用中，我们讨论和用的更多的是树的其中一种结构，就是二叉树 6、散列表 散列表，也叫哈希表 7、堆 可以被看做一棵树的数组对象 因为堆有序的特点，一般用来做数组中的排序，称为堆排序。 8、图 图是一种比较复杂的数据结构，在存储数据上有着比较复杂和高效的算法 1> 红黑树特性 https://zhuanlan.zhihu.com/p/31805309 1> 二叉查找树的3个特性 2> 红黑树除了具有二叉查找树的特性，还具有的3个特性（节点是红色/黑色、根节点是黑色不算） 3> 增加节点导致打破平衡，调整的2种方法
12、注解
java实现自定义注解 来源：https://blog.csdn.net/zt15732625878/article/details/100061528
13、内存机制
注：详见"JVM"，下面内容不需看 https://www.jianshu.com/p/8624e27ae45d https://www.cnblogs.com/shamao/p/10938028.html
14、ClassLoader类装载器
注：详见"JVM"，下面内容不需看 来源：https://segmentfault.com/a/1190000008491597 大牛：https://blog.csdn.net/hupoling/article/details/90938342 面试：写一个自定义的类加载器 + 哪些情况需要自定义类加载器 ------------------------------------------------------------------------------------------- 1> 为什么要自定义ClassLoader 因为系统的ClassLoader只会加载指定目录下的class文件,如果你想加载自己的class文件,那么就可以自定 义一个ClassLoader 2> 如何自定义ClassLoader
15、native本地方法
1> 因为你会c语言，肯定会问你native方法 java语言和c语言交互的方法 2> JNI是Java Native Interface的缩写,中文为JAVA本地调用 3> DLL的全称是Dynamic Link Library,中文叫做“动态链接文件” 4> JNIEXPORT和JNICALL宏定义： https://blog.csdn.net/shulianghan/article/details/104072587 window平台： 方法返回值前加：JNIEXPORT ，方法名前加：JNICALL 4> java调用c接口： https://blog.csdn.net/WeiHao0240/article/details/99568579 注：window和linux具体实现不太一样 注： "注意"：写一个Java类是为了生成.h和.c的格式 其中，java的类名，包名，方法名，都必须和项目中java类保持一致 1> 如何把c文件编译成dll gcc -shared -o demo.dll demo.c 2> java调用c（单独java文件） https://blog.csdn.net/u011181989/article/details/92242435 生成so文件不需要，直接用第一点，生成dll文件 还需要注意一点，找jni文件，https://blog.csdn.net/WeiHao0240/article/details/99568579 还需要注意一点，java -d 和 javah 的命令都写错了，文件名都应该是HelloMyJni.java 还需要注意一点，javah生成的.h文件，include <jni.h>应该改为"jni.h" 还需要注意一点，接上面一点，把java中jni.h和jni_md.h都和java文件放一起。所以""， <>是系统文件的意思 还需要注意一点，如果只是简单调用，生成的dll文件和java文件放一起就可以了。 若果是系统中随处可调用，就需要放在 window：java安装目录下的bin目录 1> 报错： 如果文件第一行是package xx，指定了包名则： 编译：需要指定路径加-d参数，值为当前即点 --> javac -d . HelloMyJni.java 运行：需要包名.类名 --> java com.guozi.test.HelloMyJni 头文件：需要包名.类名 --> javah -jni com.guozi.test.HelloMyJni 3> java调用c（项目） 前提： 比如我的项目中，工具类HelloMyJni.java放在目录com.guozi.test下。 外部写单个java类测试： 1> java类必须加package com.guozi.test System.loadLibrary("dll名称"); 2> 编译：javac -d . HelloMyJni.java 3> 生成头文件：javah -jni com.guozi.test.HelloMyJni 头文件：com_guozi_test_HelloMyJni.h 方法名：Java_com_guozi_test_HelloMyJni_helloWorld 可知：如果模拟项目应用java调c，java类必须加package，因生成文件名和方法名不一样 注：将.h文件中include <jni.h>改为include "jni.h" 4> 写c文件： 1> #include "jni.h" 2> #include "com_guozi_test_HelloMyJni.h" 3> JNIEXPORT void JNICALL Java_com_guozi_test_HelloMyJni_helloWorld(JNIEnv * env, jobject obj) 4> 生成dll文件：gcc -shared -o HelloWorld.dll HelloWorld.c 5> dll文件位置：放在java目录bin下（其实随便path扫到的目录下即可） 好像会先找java.class.path，如果找不到，再找系统的路径。 项目中应用： 定义工具类，写入HelloMyJni内容，向外提供调用方法。完成！ 注：HelloMyJni的所在目录必须是和"前提"中说的一样 --> com.guozi.test
16、java/c/python区别
1> C语言是一门面向过程设计语言; 2> Java是一门面向对象编程语言，而Java语言是从C语言衍生而来，它吸收了C++语言的各种优点，并且摒弃了 C++里难以理解的多继承、指针等概念。 3> python和java的区别： Java是一种静态类型语言，Python是一种动态类型语言 Java中的所有变量需要先声明（类型）才能使用，Python中的变量不需要声明类型 （Java编译以后才能运行，Python直接就可以运行） 注： 1> 面向对象编程和面向过程编程的区别 https://www.cnblogs.com/qianxiaoruofeng/p/11561188.html 2> 静态语言和动态语言的区别 https://www.cnblogs.com/raind/p/8551791.html 像Java，c，c++这种就属于静态语言。静态语言（强类型语言） 像JavaScript，Python这种就属于动态语言。动态语言（弱类型语言） 注：java是动态语言还是静态语言，见第二个"注" 3> 解释型语言和编译性语言的区别 见：https://www.zhihu.com/question/19608553/answer/27896401 "温悦"用户回答 注： 1> c语言经过编译之后变成的是是"机器码"，二进制语言，机器可识别的 2> java是解释型语言还是编译性语言 不好严格区分 一般认为是"解释型语言" JIT技术将运行频率很高的字节码直接编译为机器指令执行以提高性能 java的编译结果是被jvm“解释执行”的， https://blog.csdn.net/weixin_34114823/article/details/88675337 3> java是动态语言还是静态语言 不好严格区分 一般认为是"静态语言" 但是（interface，reflection和dynamic class loading）运行时才能确定的特性 注： 1> python效率低的原因 https://blog.csdn.net/lmseo5hy/article/details/81875518 执行时：Python解释器将源代码转换为字节码，然后再由Python解释器来执行这些字节码。 其每次运行都要进行转换成字节码，然后再有虚拟机把字节码转换成机器语言，最后才能在硬件 上运行。 并不是和java一样，先显示编译为字节码，存在磁盘或内存，可以复用。 2> AOT和JIT JIT：后端编译/即时(JIT)编译 AOT：静态提前编译（Ahead Of Time，AOT编译） 目前来看，流行框架太依赖反射和各种奇门优化，这东西应用于后台开发还不太现实 AOT牺牲了跨平台性，直接由源码搞到了机器码https://www.zhihu.com/question/54842396
17、创建对象方式
1> 概述 我们还可以使用反射机制(Class类的newInstance方法、使用Constructor类的newInstance方法)、使用 Clone方法、使用反序列化等方式创建对象 2> 地址： https://blog.csdn.net/justloveyou_/article/details/72466416
18、看过哪些源码
1> HashMap的部分源码：put和get方法 2> Spring IoC的部分源码 3> Spring AOP的部分源码 4> Spring MVC的部分源码 5> Ribbon & Feign
19、线程池+多线程
20、zookeeper相关
21、类加载顺序
来源1：https://blog.csdn.net/yy339452689/article/details/104014732?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.edu_weight&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.edu_weight 来源2：https://blog.csdn.net/u014745069/article/details/82655339 父类的静态字段——>父类静态代码块——>子类静态字段——>子类静态代码块——> 父类成员变量（非静态字段）——>父类非静态代码块——>父类构造器——>子类成员变量——>子类非静态代码块——>子类构造器
22、Dubbo源码
23、CGLIB和Java动态代理
1> Java动态代理只能够对接口进行代理，不能对普通的类进行代理（因为所有生成的代理类的父类为Proxy， Java类继承机制不允许多重继承）； Java动态代理使用Java原生的反射API进行操作，在生成类上比较高效； Java反射机制 2> CGLIB能够代理普通类； CGLIB使用ASM框架直接对字节码进行操作，在类的执行过程中比较高效 它允许我们在运行时对字节码进行修改和动态生成 注： 1> ASM详解：https://www.cnblogs.com/zt007/p/6377789.html 2> Proxy详解：https://www.cnblogs.com/incognitor/p/9759987.html 1> java静态代理： 设计模式中的代理模式 静态代理的缺点是冗余，因为一个代理类只能代理一个接口 2> java动态代理： 主要方法：Proxy.newProxyInstance 接口方法调用实质是InvocationHandler.invoke()方法 注：两种对比 https://www.cnblogs.com/CarpenterLee/p/8241042.html
24、编码格式相关
搞清楚了ASCII、Unicode和UTF-8的关系 ASCII编码是1个字节，而Unicode编码通常是2个字节（如果要用到非常偏僻的字符，就需要4个字节） 注* 存储和传输 上就十分不划算 本着节约的精神，又出现了把Unicode编码转化为“可变长编码”的UTF-8编码 常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4-6个字节 在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，转换为UTF-8编 码。
25、通信协议相关
26、多线程
1> 线程排查死锁的方法 1> jsp找到对应线程号 2> jstack 线程号 2> 线程的所有状态 查看图片：H:\desktop\面试相关\面试\2019年面试\7、thread 来源：https://blog.csdn.net/dupengshixu/article/details/83689719 1> yield Thread.yield()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。 即：主动放弃自己线程得到的cpu的"cpu时间片时间片" yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转 到可运行状态，但有可能没有效果。 2> wait和notify 等待池：假设一个线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁后，进入到了该对 象的等待池，等待池中的线程不会去竞争该对象的锁。 锁池：只有获取了对象的锁，线程才能执行对象的 synchronized 代码，对象的锁每次只有一个线程 可以获得，其他线程只能在锁池中等待（唤醒之后，b、c争夺锁） 区别： notify() 方法随机唤醒对象的等待池中的一个线程，"进入锁池"； notifyAll() 唤醒对象的等待池中的所有线程，进入锁池。 来源：https://blog.csdn.net/meism5/article/details/90238268 3> join thread.Join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。 比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。 注：当前线程，即"main线程"，main线程调用了a线程的join方法，直到线程a执行完毕后，才会继续 执行线程main。即b/c线程的start方法。 3> 线程池的所有状态 RUNNING ：能接受新提交的任务，并且也能处理阻塞队列中的任务； SHUTDOWN：关闭状态，不再接受新提交的任务，但却可以继续处理阻塞队列中已保存的任务。在线程池处于 RUNNING 状态时，调用 shutdown()方法会使线程池进入到该状态。（finalize() 方法在执行过程 中也会调用shutdown()方法进入该状态）； STOP：不能接受新任务，也不处理队列中的任务，会中断正在处理任务的线程。在线程池处于 RUNNING 或 SHUTDOWN 状态时，调用 shutdownNow() 方法会使线程池进入到该状态； TIDYING：如果所有的任务都已终止了，workerCount (有效线程数) 为0，线程池进入该状态后会调用 terminated() 方法进入TERMINATED 状态。 TERMINATED：在terminated() 方法执行完后进入该状态，默认terminated()方法中什么也没有做。 4> 线程实现方式 1> 实现Runnable接口 2> 继承Thread类 3> 实现Callable接口，实现call方法（java1.5之后提供的方式） 第1/2种方式，需重写/实现run方法，该方法没有返回值 Callable接口有泛型 call方法有返回值，值类型是Callable接口标识的泛型 <源码有点复杂，FuturTask是实现接口实现类，源码复杂，暂时不看> 5> java中有几种线程池 来源：https://baijiahao.baidu.com/s?id=1652900816694167505&wfr=spider&for=pc 1> 阻塞队列 ArrayBlockingQueue：有界队列（基于数组的） LinkedBlockingQueue：有/无界队列（基于链表的，传参就是有界，不传就是无界） SynchronousQueue：同步移交队列（需要一个线程调用put方法插入值， 另一个线程调用take方法删除值） 2> handler：拒绝处理策略 ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常 注：抛异常 ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常 注：扔掉新的 ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务 注：扔掉旧的（重复此过程） ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务 3> 常用的线程池 1> newCachedThreadPool() 核心线程数为0，最大线程数几乎无限，阻塞队列使用的是 SynchronousQueue：同步移交队列 注意事项：使用时要注意控制线程的数量，防止因线程数太多导致OOM。 2> newFixedThreadPool(int nThreads) 创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程，如果工作线程数 量达到线程池初始的最大数，则将提交的任务存入到池队列中。 FixedThreadPool是一个典型且优秀的线程池，它具有线程池提高程序效率和节省创建线程时所 耗的开销的优点。但是，在线程池空闲时，即线程池中没有可运行任务时，它不会释放工作线 程，还会占用一定的系统资源。 线程数量固定，传入的即是核心线程数，也是最大值；阻塞队列用的是无界的。 注意：使用时要注意控制无界队列的大小，防止因队列中等待的线程数太多导致OOM。 3> newSingleThreadExecutor() 核心线程数和最大线程数都是1，阻塞队列是无限的（单一线程，一次执行一个线程） 4> ScheduledThreadPoolExecutor 来源：https://www.cnblogs.com/despacito/p/11171383.html 从构造函数可以看出ScheduledThreadPoolExecutor还是调用的父类ThreadPoolExecutor的构造方 式，唯一区别是工作队列固定为DelayedWorkQueue。 6> 线程池源码（核心） 1> 主线程调用ThreadPoolExecutor类的submit方法，submit方法内部直接调用了execute方法， execute方法是顶层接口Executor定义，在ThreadPoolExecutor类中实现 2> execute方法中，调用addWork方法，会new一个Work对象，后面调用work的start方法。 3> work是ThreadPoolExecutor类的内部类，实现了Runnable接口，实现了run方法，方法内直接调用了 runWork方法 4> run方法中，通过getTask方法拿到任务，getTask方法是从workQueue队列中poll方法拿到任务。 5> workQueue队列是在创建ThreadPoolExecutor类对象的构造器中定义的 6> 从队列中拿到任务之后，会调用任务对象的run方法 7> 核心线程和非核心线程的区别 来源：https://blog.csdn.net/qq_30596077/article/details/88658264 1> 核心线程 ： 固定线程数 可闲置 不会被销毁 ThreadPoolExecutor的allowCoreThreadTimeOut属性设置 为true时，keepAliveTime同样会作用于核心线程 2> 非核心线程数： 非核心线程闲置时的超时时长，超过这个时长，非核心线程就会被回收 注： 1> 核心线程池不会销毁，可以重复使用的，所以优先判断核心线程是否满了。 2> 如果核心线程满了，就往队列中放，因为还是正常排队使用核心线程工作。 3> 如果队列都满了，不得已再看非核心线程是否满了。（因为这家伙会销毁，耗费性能） 8> 并发原子类AtomicInteger https://baijiahao.baidu.com/s?id=1647621616629561468&wfr=spider&for=pc 9> CAS机制 https://baijiahao.baidu.com/s?id=1647620168550407271&wfr=spider&for=pc
0、Spring
0、概念
1.Spring是什么? 概述：Spring是一个'轻量级'的'IoC和AOP'的'容器框架'。 目的：用于'简化'企业应用程序的开发，它使得开发者只需要关心业务需求 主要模块有： 1> Spring Core：提供IOC服务；(核心类库) 2> Spring AOP：提供AOP服务； 3> Spring MVC：提供面向Web应用的Model-View-Controller'实现'。 4> Spring ORM：提供对现有的ORM框架的支持； 来源：https://blog.csdn.net/a745233700/article/details/80959716
1、优点
2.Spring 的优点？ 1> spring属于'低侵入式'设计，代码的污染极低； 2> spring的'DI机制'将对象之间的依赖关系交由框架处理，减低组件的'耦合性'； 3> Spring提供了AOP技术，支持将一些'通用任务进行集中式管理'，从而提供更好的复用。 如安全、事务、日志、权限等 4> spring对于'主流的应用框架'提供了集成支持。（略）
2、AOP理解
3.Spring的AOP理解 注* 一个概念，一个原理。优点不谈。 1> 概述： a. OOP面向对象，允许开发者定义纵向的关系，但并不适用于定义横向的关系，导致了大量代码的重复 b. AOP，一般称为面向切面，作为面向对象的一种补充。 c.切面： 用于将那些'与业务无关，但却对多个对象产生影响'的公共行为和逻辑，抽取并封装为一个可重用 的模块，这个模块被命名为'切面'（Aspect）， 2> 优点：（略） 减少重复代码， 降低耦合度，（模块间的） 提高可维护性。 3> 原理： AOP实现的关键在于 '代理模式'， AOP代理主要分为静态代理和动态代理。 静态代理的代表为AspectJ；动态代理则以Spring AOP为代表 4> 静态代理和动态代理理解（略） a. 静态代理： 就是AOP框架会在'编译阶段'生成AOP代理类。 他会在编译阶段将AspectJ(切面)织入到Java字节码中，运行的时候就是增强之后的AOP对象 b. 动态代理 AOP框架不会去修改字节码，而是'每次运行'时在内存中临时为方法生成一个AOP对象 这个AOP对象包含了目标对象的全部方法，并且在特定的切点做了增强处理，并回调原对象的方法 5> Spring AOP中的动态代理主要有两种方式（略） a JDK动态代理 b CGLIB动态代理 注* 目标对象有实现接口，spring会自动选择“JDK代理” // 目标对象没有实现接口， spring会用“cglib代理” 来源：https://www.cnblogs.com/guzhou-ing/p/6445159.html 6> 静态代理和动态代理的区别（略） 上接4> 相对来说AspectJ的静态代理方式具有更好的性能 但是AspectJ需要特定的'编译器'进行处理
3、IoC理解
4.Spring的IoC理解 注* 一个概念，一个原理。优点不谈。 1> 概述： IOC就是控制反转，是指创建对象的控制权的转移。以前创建对象的主动权和时机是由自己把控的，而现 在这种权力转移到Spring容器中，并由容器根据配置文件去创建实例和管理各个实例之间的依赖关系。 2> 优点： 对象与对象之间松散耦合 也利于功能的复用 3> 原理： 使用java的'反射机制'，根据配置文件在运行时'动态的'去创建对象以及管理对象，并调用对象的方法 的。 4> 注入方式： 基于XML的注入： 子来源：https://blog.csdn.net/a909301740/article/details/78379720 a.构造方法注入 <!-- 注册userService --> <bean id="userService" class="com.lyu.spring.service.impl.UserService"> <constructor-arg ref="userDaoJdbc"></constructor-arg> </bean> <!-- 注册jdbc实现的dao --> <bean id="userDaoJdbc" class="com.lyu.spring.dao.impl.UserDaoJdbc"></bean> b.setter注入 <!-- 注册userService --> <bean id="userService" class="com.lyu.spring.service.impl.UserService"> <property name="userDao" ref="userDaoMyBatis"></property> </bean> <!-- 注册mybatis实现的dao --> <bean id="userDaoMyBatis" class="com.lyu.dao.impl.UserDaoMyBatis"></bean> 注* 如果通过set方法注入属性，那么spring会通过默认的空参构造方法来实例化对象 c.静态工厂注入 d.实例工厂注入 基于注解的注入： 子来源：https://www.cnblogs.com/wangbin2188/p/9014400.html 描述依赖关系主要有两种： @Resource 默认以byName的方式去匹配与属性名相同的bean的id， 如果没有找到就会以byType的方式查找。 如果byType查找到多个的话，使用@Qualifier注解指定某个具体名称的bean @Autowired 默认是以byType的方式去匹配类型相同的bean 注* 实现步骤 1 导入AOP的Jar包。因为注解的后台实现用到了AOP编程。 2 需要更换配置文件头，即添加相应的约束。 3 需要在Spring配置文件中配置组件扫描器，用于在指定的基本包中扫描注解。
4、自动装配
9.Spring的自动装配 0> 来源： https://blog.csdn.net/tanga842428/article/details/54694484 1> 概述： Spring注入中byType和byName的总结 区分清楚什么是byType，什么是byName 2> 示例： <bean id="userServiceImpl" class="cn.com.bochy.service.impl.UserServiceImpl" autowire="byName"> </bean> <bean id="userDao" class="cn.com.bochy.dao.impl.UserDaoImpl"></bean> 3> 详解： 比如说如上这段代码，byName就是通过Bean的id或者name，byType就是按Bean的Class的类型。 若autowire="byType"意思是通过 class="cn.com.bochy.dao.impl.UserDaoImpl"来查找 UserDaoImpl下所有的对象。 代码autowire="byName"意思是通过id="userDao"来查找Bean中的userDao对象 4> @Autowired和@Resource之间的区别 a.@Autowired默认是按照'类型'装配注入的 b.@Resource默认是按照'名称'来装配注入的，只有当找不到与名称匹配的bean才会按照类型来装配注 入。
5、用到的设计模式
10.Spring 框架中都用到了哪些设计模式？ 1> 工厂模式：BeanFactory就是简单工厂模式的体现，用来创建对象的实例； 2> 单例模式：Bean默认为单例模式。 3> 代理模式：Spring的AOP功能用到了JDK的动态代理和CGLIB字节码生成技术； 4> （略） 模板方法：用来解决代码重复的问题。比如. RestTemplate, JmsTemplate, JpaTemplate。 5> （略） 观察者模式：定义对象间一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象 都会得到通知被制动更新，如Spring中listener的实现--ApplicationListener。
6、事务
11.Spring事务的实现方式和实现原理 1> 概述： Spring事务的本质其实就是数据库对事务的支持，没有数据库的事务支持， spring是无法提供事务功能的。真正的数据库层的事务提交和回滚是通过binlog或者redolog实现的。 2> Spring事务的种类 Spring支持'编程式'事务管理和'声明式'事务管理两种方式 3> 声明式事务的优缺点 原理： 声明式事务管理建立在'AOP'之上的。其本质是通过AOP功能，对'方法前后'进行'拦截'，将事务 处理的功能'编织'到拦截的方法中.也就是在目标方法开始之前加入一个事务，在执行完目标方法 之后根据执行情况提交或者回滚事务。 优点： 不需要在业务逻辑代码中'掺杂'事务管理的代码 这正是spring倡导的'非侵入式'的开发方式 缺点： '最细粒度'只能作用到'方法级别'，无法做到像编程式事务那样可以作用到'代码块级别'。
7、其他
5.BeanFactory和ApplicationContext有什么区别（略） 0> 概述： BeanFactory和ApplicationContext是Spring的两大核心接口，'都可以当做Spring的容器'。 其中ApplicationContext是BeanFactory的子接口。 1> 区别： a.BeanFactroy采用的是'延迟加载'形式来注入Bean的，即只有在使用到某个Bean时(调用 getBean())，才对该Bean进行加载实例化。 注* 配置问题不易发现。 b.ApplicationContext，它是在容器'启动'时，一次性创建了所有的Bean 注* 占用内存空间。当应用程序配置Bean较多时，程序启动较慢。 6.请解释Spring Bean的生命周期？（略） 1> 实例化Bean 对于BeanFactory容器 对于ApplicationContext容器 2> 设置对象属性（依赖注入） 3> 处理Aware接口 4> BeanPostProcessor 5> InitializingBean 与 init-method 6> BeanPostProcessor 7> DisposableBean 当Bean不再需要时，会经过清理阶段，如果Bean实现了DisposableBean这个接口，会调用其实现的 destroy()方法； 8> destroy-method 最后，如果这个Bean的Spring配置中配置了destroy-method属性，会自动调用其配置的销毁方法 7.解释Spring支持的几种bean的作用域。（略） 1> singleton 默认，'每个容器'中只有一个bean的实例 2> prototype 为'每一个bean请求'提供一个实例 3> request 4> session 5> global-session 8.Spring如何处理线程并发问题？ ThreadLocal 早在JDK 1.2的版本中就提供java.lang.ThreadLocal， ThreadLocal为解决多线程程序的并发问题提供了一种新的思路。 使用这个工具类可以很简洁地编写出优美的多线程程序。 12.spring的事务传播行为（略） spring事务的传播行为说的是，当多个事务同时存在的时候，spring如何处理这些事务的行为。 13.Spring中的隔离级别（略） 14.Spring框架中有哪些不同类型的事件（略） 15.解释一下Spring AOP里面的几个名词（待完善） 1> 切面（Aspect） 2> 连接点（Join point） 3> 通知（Advice） 4> 切入点（Pointcut） 5> 引入（Introduction） 6> 目标对象（Target Object） 7> 织入（Weaving） 16.面向切面编程 1> 来源： https://blog.csdn.net/seashouwang/article/details/80232811 springboot-aop面向切面编程 2> 来源： https://www.cnblogs.com/guzhou-ing/p/6445159.html -- 代码 https://blog.csdn.net/MrLeeYongSheng/article/details/78643671 -- 需要所有jar包 https://www.cnblogs.com/hzg110/p/6760653.html -- 需要jar包 spring基于注解和XML实现AOP编程 注* 面向切面编程，创建一个最简单的Spring项目 来源：https://www.cnblogs.com/hzg110/p/6760653.html 注意：application.xml报错，是因为jar包不够，引入来源中的jar包之后，报错消失。 问题1：ClassPathXmlApplicationContext加载多个XML文件 来源：https://blog.csdn.net/weinichendian/article/details/72842929
1、SpringMVC
0、流程
2.SpringMVC的流程？ 1> 用户发送请求至'前端控制器'DispatcherServlet； 2> DispatcherServlet收到请求后，调用HandlerMapping'处理器映射器'，请求获取Handle； 3> 处理器映射器HandlerMapping根据请求url'找到'具体的处理器Handler，生成处理器对象及处理器拦截 器（如果有则生成）一并返回给DispatcherServlet； 4> DispatcherServlet 调用 HandlerAdapter'处理器适配器'； 5> HandlerAdapter 经过适配'调用' '具体处理器'(Handler，也叫后端控制器)； 6> Handler执行完成返回ModelAndView； 7> HandlerAdapter将Handler执行结果ModelAndView返回给DispatcherServlet； 8> DispatcherServlet将ModelAndView传给ViewResolver'视图解析器'进行解析； 9> ViewResolver解析后返回'具体View'； 10> DispatcherServlet对View进行'渲染'视图（即将模型数据填充至视图中） 11> DispatcherServlet响应用户。
1、优点
3.Springmvc的优点（略） 1> 可以支持各种视图技术,而不仅仅局限于JSP； 2> 与Spring框架集成（如IoC容器、AOP等）； 3> 清晰的角色分配：前端控制器(dispatcherServlet) , 请求到处理器映射（handlerMapping), 处理 器适配器（HandlerAdapter), 视图解析器（ViewResolver）。 4> 支持各种请求资源的映射策略。
2、和Struts2的区别
5.springMVC和struts2的区别有哪些? 1> 入口 springmvc的入口是一个servlet即前端控制器（DispatchServlet）， 而struts2入口是一个filter过虑器（StrutsPrepareAndExecuteFilter）。 2> 开发原理 springmvc是基于'方法'开发(一个url对应一个方法)，请求参数传递到方法的形参。 struts2是基于'类'开发，传递参数是通过类的属性。 3> 请求/响应的数据存储 a. Struts采用'值栈'存储请求和响应的数据，通过OGNL存取数据， b. springmvc通过'参数解析器'是将request请求内容解析，并给方法形参赋值，将数据和视图封装成 'ModelAndView对象'，最后又将ModelAndView中的模型数据通过reques域传输到页面。
3、函数返回值类型
17.SpringMvc中函数的返回值是什么？ 子来源：https://blog.csdn.net/qq_35192741/article/details/79085815 1> ModelAndView ModelAndView mv = new ModelAndView(); mv.addObject("content", "springMVC HelloWorld:"+param); mv.setViewName("springMVC/helloWorld"); return mv; 2> String //返回值为String类型的,视图名就是返回值 @RequestMapping(value="/returnString",method=RequestMethod.GET) public String returnString(Model model) { model.addAttribute("test", "return string!!!"); System.out.println("springMVC测试：helloWorld;"); return "return/returnString"; } 3> void //返回值是void类型的，由于没有返回值 //它默认的展示视图名和url中的一段是一样的即returnVoid.jsp @RequestMapping("/returnVoid") public void returnVoid(Model model){ model.addAttribute("test", "return void!!!"); } 4> Map //返回值是void类型的，由于没有指定视图名 //它默认的展示视图名和url中的一段是一样的即returnVoid.jsp @RequestMapping("/returnModel") public Model returnModel(Model model){ model.addAttribute("test", "return Model!!!"); return model; } 5> Model //返回值是void类型的，由于没有指定视图名 //它默认的展示视图名和url中的一段是一样的即returnVoid.jsp @RequestMapping("/returnMap") public Map returnMap(Model model){ Map map = new HashMap<String,String>(); map.put("test", "return map!!!"); return map; }
来源：https://blog.csdn.net/a745233700/article/details/80963758 0.对Spring MVC的理解 ？ 注* 一个概念，一个原理（即流程）。优点不谈。 1.什么是Spring MVC ？ 1> Spring MVC是'轻量级'的实现了'MVC设计模式'的'Web框架'， 2> （略） 通过把Model，View，Controller分离，把复杂的web应用分成逻辑清晰的几部分， 3> （略） 简化开发，减少出错，方便组内开发人员之间的配合。 4.Spring MVC的主要组件？（略） 注意：Handler和View 1> 前端控制器 DispatcherServlet（不需要程序员开发） 接收请求、响应结果，相当于转发器，有了DispatcherServlet 就减少了其它组件之间的耦合度。 2> 处理器映射器HandlerMapping（不需要程序员开发） 根据请求的URL来查找Handler 3> 处理器适配器HandlerAdapter 在编写Handler的时候要按照HandlerAdapter要求的规则去编写，这样适配器HandlerAdapter才可以 正确的去执行Handler。 4> 处理器Handler（需要程序员开发） 5> 视图解析器 ViewResolver（不需要程序员开发） 进行视图的解析，根据视图逻辑名解析成真正的视图（view） 6> 视图View（需要程序员开发jsp） View是一个接口，它的实现类支持不同的视图类型（jsp，freemarker，pdf等等） 6.SpringMVC怎么样设定重定向和转发的？ 1> 转发：在返回值前面加"forward:"，譬如"forward:user.do?name=method4" 2> 重定向：在返回值前面加"redirect:"，譬如"redirect:http://www.baidu.com" 7.SpringMvc怎么和AJAX相互调用的？ 通过Jackson框架就可以把Java里面的对象直接转化成Js可以识别的Json对象。具体步骤如下 ： 1> 加入Jackson.jar 2> （略） 在配置文件中配置json的映射 3> 在接受Ajax方法里面可以直接返回Object,List等,但方法前面要加上@ResponseBody注解。 8.如何解决POST请求中文乱码问题，GET的又如何处理呢？ 1> 解决post请求乱码问题： 在web.xml中配置一个CharacterEncodingFilter过滤器，设置成utf-8； <filter> <filter-name>CharacterEncodingFilter</filter-name> <filter-class>org.springframework.web.filter.CharacterEncodingFilter </filter-class> <init-param> <param-name>encoding</param-name> <param-value>utf-8</param-value> </init-param> </filter> <filter-mapping> <filter-name>CharacterEncodingFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> 2> get请求中文参数出现乱码解决方法有两个： 方法1： 修改tomcat配置文件添加编码与工程编码一致，如下： <ConnectorURIEncoding="utf-8" connectionTimeout="20000" port="8080" protocol="HTTP/1.1" redirectPort="8443"/> 方法2： 另外一种方法对参数进行'重新编码'： String userName = new String(request.getParamter("userName").getBytes("ISO8859- 1"),"utf-8") 注* ISO8859-1是tomcat默认编码，需要将tomcat编码后的内容按utf-8编码。 9.Spring MVC的异常处理 ？ 子来源：https://www.cnblogs.com/junzi2099/p/7840294.html 一共三种方法 方法1：使用 @ ExceptionHandler 注解 使用该注解有一个不好的地方就是：进行异常处理的方法必须与出错的方法在同一个Controller里面。 使用如下： @Controller public class GlobalController { //处理异常 @ExceptionHandler({MyException.class}) public String exception(MyException e) { System.out.println(e.getMessage()); e.printStackTrace(); return "exception"; } @RequestMapping("test") public void test() { throw new MyException("出错了！"); } } 可以看到，这种方式最大的缺陷就是不能全局控制异常。每个类都要写一遍。 方法2：实现 HandlerExceptionResolver 接口 这种方式可以进行全局的异常控制。例如： @Component public class ExceptionTest implements HandlerExceptionResolver{ public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) { System.out.println("This is exception handler method!"); return null; } } 方法3：使用 @ControllerAdvice+ @ ExceptionHandler 注解（略） 10. SpringMvc的控制器是不是单例模式，如果是,有什么问题，怎么解决？ 子来源（大神文章-通俗易懂）：https://www.cnblogs.com/eric-fang/p/5629892.html 解决： 1、不要在controller中定义成员变量。 2、万一必须要定义一个非静态成员变量时候，则加注解@Scope("prototype")，将其设置为多例模式 11. SpringMVC常用的注解有哪些？ 1> @RequestMapping 用于处理请求 url 映射的注解，可用于类或方法上。用于类上，则表示类中的所有响应请求的方法都 是以该地址作为父路径。 2> @RequestBody 注解实现接收http请求的json数据，将json转换为java对象。 3> @ResponseBody 注解实现将conreoller方法返回对象转化为json对象响应给客户。 12.SpingMvc中的控制器的注解一般用那个,有没有别的注解可以替代？ 一般用@Conntroller注解,表示是表现层,不能用别的注解代替。 13.如果在拦截请求中，我想拦截get方式提交的方法,怎么配置？ 可以在@RequestMapping注解里面加上method=RequestMethod.GET 14.怎样在方法里面得到Request,或者Session？ 直接在方法的形参中声明request,SpringMvc就自动把request对象传入。 15.如果想在拦截的方法里面得到从前台传入的参数,怎么得到？ 方法1：直接在形参里面声明这个参数就可以,但必须名字和传过来的参数一样。 方法2：使用@RequestParam注解 16.如果前台有很多个参数传入,并且这些参数都是一个对象的,那么怎么样快速得到这个对象？ 直接在方法中声明这个对象,SpringMvc就自动会把属性赋值到这个对象里面。 或者 使用@RequestBody注解 18.SpringMvc用什么对象从后台向前台传递数据的？ 通过Model或者Map对象,可以在这个对象里面调用put方法,把对象加到里面,前台就可以通过el表达式拿到。 model --> model.addAttribute("test", "return Model!!!"); map --> map.put("test", "return map!!!"); 19.怎么样把Model/Map里面的数据放入Session里面？ 子来源：https://blog.csdn.net/u012325167/article/details/52426523 可以在类上面加上@SessionAttributes注解,里面包含的字符串就是要放入session里面的key。 20.SpringMvc里面拦截器是怎么写的： 子来源：https://blog.csdn.net/binggetong/article/details/78831681 有两种写法： 一种是实现HandlerInterceptor接口， 另外一种是继承适配器类，接着在接口方法当中，实现处理逻辑； 然后在SpringMvc的配置文件中配置拦截器即可 配置文件示例： <mvc:interceptors> <!-- 使用bean定义一个Interceptor，直接定义在mvc:interceptors根下面的Interceptor将拦截 所有的请求 --> <bean class="com.host.app.web.interceptor.AllInterceptor"/> <mvc:interceptor> <mvc:mapping path="/test/number.do"/> <!-- 定义在mvc:interceptor下面的表示是对特定的请求才进行拦截的 --> <bean class="com.host.app.web.interceptor.LoginInterceptor"/> </mvc:interceptor> <mvc:interceptor> <!-- 授权拦截 --> <mvc:mapping path="/**" /> <bean class="cn.itcast.interceptor.PermissionInterceptor"></bean> </mvc:interceptor> </mvc:interceptors> 21.注解原理：（略） 子来源（强的一批）： https://www.cnblogs.com/yangming1996/p/9295168.html 来源： 注解本质是一个继承了Annotation的特殊接口，其具体实现类是Java运行时生成的动态代理类。我们通过反 射获取注解时，返回的是Java运行时生成的动态代理对象。通过代理对象调用自定义注解的方法，会最终调 用AnnotationInvocationHandler的invoke方法。该方法会从memberValues这个Map中索引出对应的值。 而memberValues的来源是Java常量池。
####
291
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
