208道Java常见的面试题

JRE=JVM+各种基础类库+java类库（String\System）

JDK>JRE>JVM

JRE：是java运行时环境  JDK：是java开发工具包

1、对象类型不同：a:equals():是超类Object中的方法。b:==:是操作符。

2、比较的对象不同：a:equals():用来检测两个对象是否相等，即两个对象的内容是否相等。b:==:用于比较引用和比较基本数据类型时具有不同的功能。

3、运行速度不同：a:equals():没有==运行速度快。b:==:运行速度要比equals()快，因为==只是比较引用。

不对，两个对象的 hashCode()相同，equals()不一定 true。

final:作为java中的关键字可以用于三个地方。用于修饰类、类属性和类方法。特征：凡是引用final关键字的地方皆不可修改！

(1)、修饰类：表示该类不能被继承。

(2)、修饰方法：表示该方法不能被重写。

(3)、修饰变量：表示变量只能一次赋值以后值不能被修改（常量）。

round是四舍五入 负数5是舍的 所以Math.round(-1.5)等于-1 Math.round(1.5)值是2

不是

基本数据类型包括byte、int、char、long、float、double、boolean和short。 
String是引用类型的一个类，java.lang.String类是final类型的。

因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类。

String、StringBuffer、StringBuilder

String是不可变的对象，对每次对String类型的改变时都会生成一个新的对象，StringBuffer和StringBuilder是可以改变对象的。

对于操作效率：StringBuilder > StringBuffer > String

对于线程安全：StringBuffer 是线程安全，可用于多线程；StringBuilder 是非线程安全，用于单线程。

不频繁的字符串操作使用 String。反之，StringBuffer 和 StringBuilder 都优于String。

不一样，因为他们不是同一个对象。

有多种方法：

第一种：

第二种：

第三种：

从对字符常规操作来看：

增-删-改-查

删：trim subString 

改：valueOf toUpperCase toLowerCase

查：length indexOf charAt startsWith endsWith

抽象类中不一定要包含抽象方法。也就是抽象中可以没有抽象方法，反之，类中含有抽象方法，那么类必须声明为抽象类。

抽象类不能被实例；抽象类不能有构造函数，抽象方法也不能被声明为静态；抽象类可以有抽象方法；抽象类的抽象方法必须被非抽象子类继承。

不能，抽象类中的抽象方法是未来继承之后的重写方法，而用final修饰的类，无法被继承。final关键字不能用来抽象类和接口。

抽象类是被子类继承，接口是被类实现；接口只能做方法申明，抽象类可以做方法申明，也可以做方法实现；接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普遍变量；接口是设计的结果。抽象类是重构的结果。

4中：字节输入流(InputStream)；字节输出流(OutputStream)；字符输入流(Reader)；字符输出流(Writer)

BIO和NIO是两种不同的网络通信模型，现如今NIO已经大量应用在Jetty、ZooKeeper、Netty等开源框架中。一个面向流、一个面向缓冲区；一个是阻塞式的、一个是非阻塞；一个没有io多路复用器、一个有io多路复用器。

创建：
createNewFile()在指定位置创建一个空文件，成功就返回true，如果已存在就不创建，然后返回false。
mkdir() 在指定位置创建一个单级文件夹。
mkdirs() 在指定位置创建一个多级文件夹。
renameTo(File dest)如果目标文件与源文件是在同一个路径下，那么renameTo的作用是重命名， 如果目标文件与源文件不是在同一个路径下，那么renameTo的作用就是剪切，而且还不能操作文件夹。

删除：
delete() 删除文件或者一个空文件夹，不能删除非空文件夹，马上删除文件，返回一个布尔值。
deleteOnExit()jvm退出时删除文件或者文件夹，用于删除临时文件，无返回值。
判断：
exists() 文件或文件夹是否存在。
isFile() 是否是一个文件，如果不存在，则始终为false。
isDirectory() 是否是一个目录，如果不存在，则始终为false。
isHidden() 是否是一个隐藏的文件或是否是隐藏的目录。
isAbsolute() 测试此抽象路径名是否为绝对路径名。
获取：
getName() 获取文件或文件夹的名称，不包含上级路径。
getAbsolutePath()获取文件的绝对路径，与文件是否存在没关系
length() 获取文件的大小（字节数），如果文件不存在则返回0L，如果是文件夹也返回0L。
getParent() 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回null。
lastModified()获取最后一次被修改的时间。

文件夹相关：
static File[] listRoots()列出所有的根目录（Window中就是所有系统的盘符）
list() 返回目录下的文件或者目录名，包含隐藏文件。对于文件这样操作会返回null。
listFiles() 返回目录下的文件或者目录对象（File类实例），包含隐藏文件。对于文件这样操作会返回null。
list(FilenameFilter filter)返回指定当前目录中符合过滤条件的子文件或子目录。对于文件这样操作会返回null。
listFiles(FilenameFilter filter)返回指定当前目录中符合过滤条件的子文件或子目录。对于文件这样操作会返回null。

List、Set、Map

Collection是集合类的顶级接口，其派生了两个子接口Set和List。Collections则是集合类的一个工具类/帮助类，其中提供了一系列静态方法，用于对象对集合元素进行排序、搜索以及线程安全等各种操作。Collection是一个接口，而Collections是个类。

List：a、可以允许重复对象；b、可以插入多个null元素；c、是一个有序容器。Set：a、不允许重复对象；b、只允许一个null元素；c、无序容器。Map：a、Map不是collection的子接口或实现类。Map是一个接口；b、Map的每个Entry都特有两个对象，也就是一个键一个值，Map可能会持有相同的值对象但键对象必须是唯一的；c、Map里可以拥有随意null值但最多只能有一个null键。

存储：HashMap运行key和value为null，而HashTable不允许；线程安全：HashTable是线程安全的，而HashMap是非线程安全的。

对于在 Map 中插入、删除、定位一个元素这类操作，HashMap 是最好的选择，因为相对而言 HashMap 的插入会更快，但如果你要对一个 key 集合进行有序的遍历，那 TreeMap 是更好的选择。

https://blog.csdn.net/vking_wang/article/details/14166593

https://www.cnblogs.com/chengxiao/p/6059914.html

https://www.cnblogs.com/skillking/p/7250606.html

ArrayList与LinkedList都实现了list接口；ArrayList是线程表，底层是使用数组实现的，它在尾端插入和访问数据时效率较高；LinkedList是双向链表，它在中间插入或者插入时效率较高，在访问数据时效率较低。

数组转list：Arrays.asList();list转数组：list.toArray()

https://blog.csdn.net/u011419651/article/details/83831156

Array 与 ArrayList 都是用来存储数据的集合。ArrayList 底层是使用数组实现的，但是ArrayList对数组进行了封装和功能扩展

https://blog.csdn.net/qq_36101933/article/details/83145869

线程安全的集合对象：Vector、HashTable、StringBuffer       非线程安全的集合对象：ArrayList、LinkedList、HashMap、HashSet、TreeMap、TreeSet、StringBulider                 https://www.cnblogs.com/huangdabing/p/9249233.html

Iterator接口提供了很多对集合元素进行迭代的方法。每一个集合类都包括了可以返回迭代器实例的迭代方法。迭代器可以在迭代过程中删除底层集合的元素，但是不可以直接调用集合的remove(Object obj)删除，可以通过迭代器的remove()方法删除                                            https://blog.csdn.net/qq_18433441/article/details/78223502

https://www.cnblogs.com/xujian2014/p/5846128.html

https://www.cnblogs.com/xujian2014/p/5846128.html

https://blog.csdn.net/timchen525/article/details/80517517

并发：并发在单核和多核都可存在，就是同一时间有多个可以执行的进程。但是在单核中同一时刻只有一个进程获取CPU，虽然宏观上你认为多个进程都在进行。                           并行：并行是指同一时间多个进程在微观上都在真正的执行，这就只有在多核的情况下了。

• 线程：是程序执行流的最小单元，是系统独立调度和分配CPU（独立运行）的基本单位
• 进程：是资源分配的基本单位。一个进程包括多个线程

区别：地址空间、资源拥有

1. 线程与资源分配无关，它属于某一个进程，并与进程内的其他线程一起共享进程的资源
2. 每个进程都有自己一套独立的资源（数据），供其内的所有线程共享
3. 不论是大小，开销线程要更“轻量级”
4. 一个进程内的线程通信比进程之间的通信更快速，有效。（因为共享变量）

守护线程是个服务线程，服务于其他线程    典型案列：垃圾回收线程

继承Threa类创建线程；实现Runnable接口创建线程；通过Callable和Future创建线程。

runnable没有返回值，callable可以拿到有返回值，callable可以看作是runnable的补充。

创建、就绪、运行、阻塞、死亡

sleep()可以在任何地方使用；wait()只能在同步方法或者同步块中使用。

notify()是唤醒某个线程；notifyAll()是唤醒所有暂停的线程。

run()相当于线程的任务处理逻辑的入口方法；start()的作用是启动相应的线程。

线程池创建有七种方式，最核心的是最后一种：

• newSingleThreadExecutor()：它的特点在于工作线程数目被限制为 1，操作一个无界的工作队列，所以它保证了所有任务的都是被顺序执行，最多会有一个任务处于活动状态，并且不允许使用者改动线程池实例，因此可以避免其改变线程数目；
• newCachedThreadPool()：它是一种用来处理大量短时间工作任务的线程池，具有几个鲜明特点：它会试图缓存线程并重用，当无缓存线程可用时，就会创建新的工作线程；如果线程闲置的时间超过 60 秒，则被终止并移出缓存；长时间闲置时，这种线程池，不会消耗什么资源。其内部使用 SynchronousQueue 作为工作队列；
• newFixedThreadPool(int nThreads)：重用指定数目（nThreads）的线程，其背后使用的是无界的工作队列，任何时候最多有 nThreads 个工作线程是活动的。这意味着，如果任务数量超过了活动队列数目，将在工作队列中等待空闲线程出现；如果有工作线程退出，将会有新的工作线程被创建，以补足指定的数目 nThreads；
• newSingleThreadScheduledExecutor()：创建单线程池，返回 ScheduledExecutorService，可以进行定时或周期性的工作调度；
• newScheduledThreadPool(int corePoolSize)：和newSingleThreadScheduledExecutor()类似，创建的是个 ScheduledExecutorService，可以进行定时或周期性的工作调度，区别在于单一工作线程还是多个工作线程；
• newWorkStealingPool(int parallelism)：这是一个经常被人忽略的线程池，Java 8 才加入这个创建方法，其内部会构建ForkJoinPool，利用Work-Stealing算法，并行地处理任务，不保证处理顺序；
• ThreadPoolExecutor()：是最原始的线程池创建，上面1-3创建方式都是对ThreadPoolExecutor的封装。

https://blog.csdn.net/meism5/article/details/90261021

• RUNNING：这是最正常的状态，接受新的任务，处理等待队列中的任务。
• SHUTDOWN：不接受新的任务提交，但是会继续处理等待队列中的任务。
• STOP：不接受新的任务提交，不再处理等待队列中的任务，中断正在执行任务的线程。
• TIDYING：所有的任务都销毁了，workCount 为 0，线程池的状态在转换为 TIDYING 状态时，会执行钩子方法 terminated()。
• TERMINATED：terminated()方法结束后，线程池的状态就会变成这个。

execute()：只能执行Runnable类型的任务；submit()：可以执行Runnable和Callable类型的任务。

方法一：使用安全类，比如java.util.concurrent下的类。方法二：使用自动锁synchronized。方法三：使用手动锁Lock。

synchronized 锁升级原理：在锁对象的对象头里面有一个 threadid 字段，在第一次访问的时候 threadid 为空，jvm 让其持有偏向锁，并将 threadid 设置为其线程 id，再次进入的时候会先判断 threadid 是否与其线程 id 一致，如果一致则可以直接使用此对象，如果不一致，则升级偏向锁为轻量级锁，通过自旋循环一定次数来获取锁，执行一定次数之后，如果还没有正常获取到要使用的对象，此时就会把锁从轻量级升级为重量级锁，此过程就构成了 synchronized 锁的升级。

锁的升级的目的：锁升级是为了减低了锁带来的性能消耗。在 Java 6 之后优化 synchronized 的实现方式，使用了偏向锁升级为轻量级锁再升级到重量级锁的方式，从而减低了锁带来的性能消耗。

当线程A持有独占锁a，并尝试去获取独占锁b的同时，线程B持有独占锁b，并尝试获取获取独占锁a的情况下，就会发生AB两个线程由于相互持有对方需要的锁，而发生了阻塞的现象，称为死锁。

尽量使用tryLock的方法，设置超时时间，超时可以退出防止死锁；尽量使用java.util.concurrent并发类代替自己手写锁；尽量降低锁的使用粒度，尽量不要几个功能用同一把锁；尽量减少同步的代码块。

ThreadLocal用于保存某个线程共享变量。使用场景：解决数据库连接，Session管理

synchronized 是由一对 monitorenter/monitorexit 指令实现的，monitor 对象是同步的基本实现单元。在 Java 6 之前，monitor 的实现完全是依靠操作系统内部的互斥锁，因为需要进行用户态到内核态的切换，所以同步操作是一个无差别的重量级操作，性能也很低。但在 Java 6 的时候，Java 虚拟机 对此进行了大刀阔斧地改进，提供了三种不同的 monitor 实现，也就是常说的三种不同的锁：偏向锁（Biased Locking）、轻量级锁和重量级锁，大大改进了其性能。

• volatile 是变量修饰符；synchronized 是修饰类、方法、代码段。
• volatile 仅能实现变量的修改可见性，不能保证原子性；而 synchronized 则可以保证变量的修改可见性和原子性。
• volatile 不会造成线程的阻塞；synchronized 可能会造成线程的阻塞。

• synchronized 可以给类、方法、代码块加锁；而 lock 只能给代码块加锁。
• synchronized 不需要手动获取锁和释放锁，使用简单，发生异常会自动释放锁，不会造成死锁；而 lock 需要自己加锁和释放锁，如果使用不当没有 unLock()去释放锁就会造成死锁。
• 通过 Lock 可以知道有没有成功获取锁，而 synchronized 却无法办到。

synchronized 早期的实现比较低效，对比 ReentrantLock，大多数场景性能都相差较大，但是在 Java 6 中对 synchronized 进行了非常多的改进。

主要区别如下：

• ReentrantLock 使用起来比较灵活，但是必须有释放锁的配合动作；
• ReentrantLock 必须手动获取与释放锁，而 synchronized 不需要手动释放和开启锁；
• ReentrantLock 只适用于代码块锁，而 synchronized 可用于修饰方法、代码块等。
• volatile 标记的变量不会被编译器优化；synchronized 标记的变量可以被编译器优化。

atomic 主要利用 CAS (Compare And Wwap) 和 volatile 和 native 方法来保证原子操作，从而避免 synchronized 的高开销，执行效率大为提升。

可以将一个程序（类）在运行的时候获得该程序（类）的信息的机制，也就是获得在编译期不可能获得的类的信息，因为这些信息是保存在Class对象中的，而这个Class对象是在程序运行时动态加载的 

序列化就是把java对象转换为字节序列的方法。把对象的字节序列化到永久的保存到硬盘中；在网络上传递对象的字节序列。

动态代理是运行时动态生成代理类。

• 动态代理指的是可以任意控制任意对象的执行过程
  • 本来应该自己做的事情，因为没有某种原因不能直接做，只能请别人代理做。被请的人就是代理
  • 比如春节买票回家，由于没有时间，只能找票务中介来买，这就是代理模式
• 应用：Spring 的 AOP

JDK动态代理；cglib动态代理。

克隆的对象可能包含一些已经修改过的属性，而 new 出来的对象的属性都还是初始化时候的值，所以当需要一个新的对象来保存当前对象的“状态”就靠克隆方法了。

• 实现 Cloneable 接口并重写 Object 类中的 clone() 方法。
• 实现 Serializable 接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆。

• 浅克隆：当对象被复制时只复制它本身和其中包含的值类型的成员变量，而引用类型的成员对象并没有复制。
• 深克隆：除了对象本身被复制外，对象所包含的所有成员变量也将复制。

• jsp经编译后就成了Servlet（Jsp的本质就是Servlet，JVM只能识别Java类，不能识别Jsp代码，Web容器将Jsp的代码编译成JVM能够识别的java类）
• jsp更擅长表现于页面显示，servlet更擅长于逻辑控制
• Servlet中没有内置对象，Jsp中的内置对象都是必须通过HttpServletRequest对象，HttpServletResponse对象以及HttpServlet对象得到

Jsp共有九种内置的对象：request 用户端请求，此请求会包含来自GET/POST请求的参数；response 网页传回用户端的回应；pageContext 网页的属性是在这里管理；session 与请求有关的会话期；application servlet 正在执行的内容；out 用来传送回应的输出；config servlet的构架部件；page JSP网页本身；exception 针对错误网页，未捕捉的例外；                                      https://www.cnblogs.com/dqh94/p/6062703.html

Web应用中，JSP创建的对象有一定的生命周期，也有可能被其他组件或者对象访问。对象的声明周期和可访问性称为作用域。四种范围对象作用域从小到大顺序如下：pageContext----request----session----application。                             https://blog.csdn.net/qq208617107/article/details/51213745

存储位置不同：session存储在服务器端；cookie存储在浏览器端。安全性不同：cookie安全性一般，在浏览器存储，可以被伪造和修改。容量和个数限制：cookie有容量限制，在每个站点下的cookie也有个数限制。存储多样性：session可以存储在Redis中、数据库中、应用程序中；而cookie只能存储在浏览器中。

session 的工作原理是客户端登录完成之后，服务器会创建对应的 session，session 创建完之后，会把 session 的 id 发送给客户端，客户端再存储到浏览器中。这样客户端每次访问服务器时，都会带着 sessionid，服务器拿到 sessionid 之后，在内存找到与之对应的 session 这样就可以正常工作了。

可以用，session 只是依赖 cookie 存储 sessionid，如果 cookie 被禁用了，可以使用 url 中添加 sessionid 的方式保证 session 能正常使用。

• 拦截级别：struts2 是类级别的拦截；spring mvc 是方法级别的拦截。
• 数据独立性：spring mvc 的方法之间基本上独立的，独享 request 和 response 数据，请求数据通过参数获取，处理结果通过 ModelMap 交回给框架，方法之间不共享变量；而 struts2 虽然方法之间也是独立的，但其所有 action 变量是共享的，这不会影响程序运行，却给我们编码和读程序时带来了一定的麻烦。
• 拦截机制：struts2 有以自己的 interceptor 机制，spring mvc 用的是独立的 aop 方式，这样导致struts2 的配置文件量比 spring mvc 大。
• 对 ajax 的支持：spring mvc 集成了ajax，所有 ajax 使用很方便，只需要一个注解 @ResponseBody 就可以实现了；而 struts2 一般需要安装插件或者自己写代码才行。

使用预处理PreparedStatement。使用正则表达式过滤字符中的特殊字符。

XSS 攻击：即跨站脚本攻击，它是 Web 程序中常见的漏洞。原理是攻击者往 Web 页面里插入恶意的脚本代码（css 代码、Javascript 代码等），当用户浏览该页面时，嵌入其中的脚本代码会被执行，从而达到恶意攻击用户的目的，如盗取用户 cookie、破坏页面结构、重定向到其他网站等。

预防 XSS 的核心是必须对输入的数据做过滤处理。

CSRF：Cross-Site Request Forgery（中文：跨站请求伪造），可以理解为攻击者盗用了你的身份，以你的名义发送恶意请求，比如：以你名义发送邮件、发消息、购买商品，虚拟货币转账等。

防御手段：

• 验证请求来源地址；
• 关键操作添加验证码；
• 在请求地址添加 token 并验证

throw是指抛出的一个具体异常类型；throws是用来声明一个方法可能抛出的所有异常信息。

• final 是用来修饰类、方法、变量
• finally 只能用在 try catch 语法中，表示这段语句最终一定会被执行
• finalize是方法名

try-catch-finally 其中 catch 和 finally 都可以被省略，但是不能同时省略，也就是说有 try 的时候，必须后面跟一个 catch 或者 finally。

一定会， catch 中 return会等finally中的代码执行完之后才会执行。

• NullPointerException 空指针异常
• ClassNotFoundException 指定类不存在
• NumberFormatException 字符串转换为数字异常
• IndexOutOfBoundsException 数组下标越界异常
• ClassCastException 数据类型转换异常
• FileNotFoundException 文件未找到异常
• NoSuchMethodException 方法不存在异常
• IOException IO 异常
• SocketException Socket 异常

• 301表示网页永久性转移到另一个地址
• 302表示临时性转移
• 区别：
  • 301是永久的重定向，搜索引擎在抓取新内容的同时也将旧的网址替换为重定向之后的网址
  • 302重定向是临时的重定向，搜索引擎抓取新的内容而保留旧的网址

• forward 是服务器的内部重定向
• redirect 是服务器收到请求后发送一个状态头给客户，客户将在重新请求一次

tcp 和 udp 是 OSI 模型中的运输层中的协议。tcp 提供可靠的通信传输，而 udp 则常被用于让广播和细节控制交给应用的通信传输。

两者的区别大致如下：

• tcp 面向连接，udp 面向非连接即发送数据前不需要建立链接；
• tcp 提供可靠的服务（数据传输），udp 无法保证；
• tcp 面向字节流，udp 面向报文；
• tcp 数据传输慢，udp 数据传输快。

如果采用两次握手，那么只要服务器发出确认数据包就会建立连接，但由于客户端此时并未响应服务器端的请求，那此时服务器端就会一直在等待客户端，这样服务器端就白白浪费了一定的资源。若采用三次握手，服务器端没有收到来自客户端的再此确认，则就会知道客户端并没有要求建立请求，就不会浪费服务器的资源。

tcp 粘包可能发生在发送端或者接收端，分别来看两端各种产生粘包的原因：

• 发送端粘包：发送端需要等缓冲区满才发送出去，造成粘包；
• 接收方粘包：接收方不及时接收缓冲区的包，造成多个包接收。

• 物理层：利用传输介质为数据链路层提供物理连接，实现比特流的透明传输。
• 数据链路层：负责建立和管理节点间的链路。
• 网络层：通过路由选择算法，为报文或分组通过通信子网选择最适当的路径。
• 传输层：向用户提供可靠的端到端的差错和流量控制，保证报文的正确传输。
• 会话层：向两个实体的表示层提供建立和使用连接的方法。
• 表示层：处理用户信息的表示问题，如编码、数据格式转换和加密解密等。
• 应用层：直接向用户提供服务，完成用户希望在网络上完成的各种工作。

• get请求的参数在URL中，而post 请求在请求body中
• get请求传参有长度限制，post请求没有长度限制
• get请求的参数只能是ASCII码，post请求传参没有这个限制

使用CORS技术；使用JSONP。

jsonp是一种轻量级的数据交换格式。                          jsonp：JSON with Padding，它是利用script标签的 src 连接可以访问不同源的特性，加载远程返回的“JS 函数”来执行的。

• 单例模式：保证被创建一次，节省系统开销。
• 工厂模式（简单工厂、抽象工厂）：解耦代码。
• 观察者模式：定义了对象之间的一对多的依赖，这样一来，当一个对象改变时，它的所有的依赖者都会收到通知并自动更新。
• 外观模式：提供一个统一的接口，用来访问子系统中的一群接口，外观定义了一个高层的接口，让子系统更容易使用。
• 模版方法模式：定义了一个算法的骨架，而将一些步骤延迟到子类中，模版方法使得子类可以在不改变算法结构的情况下，重新定义算法的步骤。
• 状态模式：允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。

• 简单工厂：用来生产同一等级结构中的任意产品，对于增加新的产品，无能为力。
• 工厂方法：用来生产同一等级结构中的固定产品，支持增加任意产品。
• 抽象工厂：用来生产不同产品族的全部产品，对于增加新的产品，无能为力；支持增加产品族

spring是一个开源框架，是个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架

• 方便结构简化开发
• AOP编码的支持
• 声明式事物的支持
• 方便程序的测试
• 方便集成各种优势框架
• 降低Java EE API 的使用难度

AOP即面向切面编程，是OOP编程的有效补充。使用AOP技术，可以将一些系统性相关的编程工作，独立提取出来，独立实现，然后通过切面切入进系统。从而避免了在业务逻辑的代码中混入很多的系统相关的逻辑——比如权限管理，事物管理，日志记录等等。

AOP分为静态AOP和动态AOP：

• 静态AOP是指AspectJ实现的AOP，他是将切面代码直接编译到Java类文件中。
• 动态AOP是指将切面代码进行动态织入实现的AOP，JDK动态代理。

即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。

　　IoC很好的体现了面向对象设计法则之一—— 好莱坞法则：“别找我们，我们找你”；即由IoC容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。

core模块、aop模块、data access模块、web模块、test模块

• spring core：框架的最基础部分，提供 ioc 和依赖注入特性。
• spring context：构建于 core 封装包基础上的 context 封装包，提供了一种框架式的对象访问方法。
• spring dao：Data Access Object 提供了JDBC的抽象层。
• spring aop：提供了面向切面的编程实现，让你可以自定义拦截器、切点等。
• spring Web：提供了针对 Web 开发的集成特性，例如文件上传，利用 servlet listeners 进行 ioc 容器初始化和针对 Web 的 ApplicationContext。
• spring Web mvc：spring 中的 mvc 封装包提供了 Web 应用的 Model-View-Controller（MVC）的实现。

构造方法注入、setter注入、基于注解注入。                  https://blog.csdn.net/a909301740/article/details/78379720

spring 中的 bean 默认是单例模式，spring 框架并没有对单例 bean 进行多线程的封装处理。

实际上大部分时候 spring bean 无状态的（比如 dao 类），所有某种程度上来说 bean 也是安全的，但如果 bean 有状态的话（比如 view model 对象），那就要开发者自己去保证线程安全了，最简单的就是改变 bean 的作用域，把“singleton”变更为“prototype”，这样请求 bean 相当于 new Bean()了，所以就可以保证线程安全了。

• 有状态就是有数据存储功能。
• 无状态就是不会保存数据。

singleton、prototype、request、session、globalSession五中作用域。

• singleton：spring ioc 容器中只存在一个 bean 实例，bean 以单例模式存在，是系统默认值；
• prototype：每次从容器调用 bean 时都会创建一个新的示例，既每次 getBean()相当于执行 new Bean()操作；
• Web 环境下的作用域：
  • request：每次 http 请求都会创建一个 bean；
  • session：同一个 http session 共享一个 bean 实例；
  • global-session：用于 portlet 容器，因为每个 portlet 有单独的 session，globalsession 提供一个全局性的 http session

• byName：按照bean的属性名称来匹配要装配的bean
• byType：按照bean的类型来匹配要装配的bean
• constructor：按照bean的构造器入参的类型来进行匹配 
• autodetect（自动检测）：先使用constructor进行装配，如果不成功就使用byType来装配

• 声明式事务：声明式事务也有两种实现方式，基于 xml 配置文件的方式和注解方式（在类上添加 @Transaction 注解）。
• 编码方式：提供编码的形式管理和维护事务。

spring 有五大隔离级别，默认值为 ISOLATION_DEFAULT（使用数据库的设置），其他四个隔离级别和数据库的隔离级别一致：

• ISOLATION_DEFAULT：用底层数据库的设置隔离级别，数据库设置的是什么我就用什么；
• ISOLATIONREADUNCOMMITTED：未提交读，最低隔离级别、事务未提交前，就可被其他事务读取（会出现幻读、脏读、不可重复读）；
• ISOLATIONREADCOMMITTED：提交读，一个事务提交后才能被其他事务读取到（会造成幻读、不可重复读），SQL server 的默认级别；
• ISOLATIONREPEATABLEREAD：可重复读，保证多次读取同一个数据时，其值都和事务开始时候的内容是一致，禁止读取到别的事务未提交的数据（会造成幻读），MySQL 的默认级别；
• ISOLATION_SERIALIZABLE：序列化，代价最高最可靠的隔离级别，该隔离级别能防止脏读、不可重复读、幻读。
• 脏读 ：表示一个事务能够读取另一个事务中还未提交的数据。比如，某个事务尝试插入记录 A，此时该事务还未提交，然后另一个事务尝试读取到了记录 A。
• 不可重复读 ：是指在一个事务内，多次读同一数据。
• 幻读 ：指同一个事务内多次查询返回的结果集不一样。比如同一个事务 A 第一次查询时候有 n 条记录，但是第二次同等条件下查询却有 n+1 条记录，这就好像产生了幻觉。发生幻读的原因也是另外一个事务新增或者删除或者修改了第一个事务结果集里面的数据，同一个记录的数据内容被修改了，所有数据行的记录就变多或者变少了。

• spring mvc 先将请求发送给 DispatcherServlet。
• DispatcherServlet 查询一个或多个 HandlerMapping，找到处理请求的 Controller。
• DispatcherServlet 再把请求提交到对应的 Controller。
• Controller 进行业务逻辑处理后，会返回一个ModelAndView。
• Dispathcher 查询一个或多个 ViewResolver 视图解析器，找到 ModelAndView 对象指定的视图对象。
• 视图对象负责渲染返回给客户端

• 前置控制器 DispatcherServlet
• 映射控制器 HandlerMapping
• 处理器 Controller
• 模型和视图 ModelAndView
• 视图解析器 ViewResolver

将http请求映射到相应的类/方法上。

@Autowired它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作，通过@Autowired的使用来消除set/get方法。