*Java程序员应该知道这些知识**

Java基础

1. String ，StringBuffer，StringBuilder的区别？

   1. String：字符串常量，String 的值是不可改变的，每次对String操作都会生成新的对象

   2. StringBuffer/StringBuilder对象可被多次修改，不产生新的对象

   3. Buffer和builder的区别？

      • Builder方法不是线程安全的，不能同步访问

   4. 三者的区别：

      • String 是不可变字符串
      • StringBuffer是可变字符串效率高，线程不安全
      • StringBuilder是可变字符串，效率低，线程安全

   5. 初始化的区别：

      1. String 可以空赋值

   6. 使用地方的区别：

      2. String： 适用于少量字符串
      3. StringBuilder单线程字符串缓冲区进行大量操作
      4. StringBuilder多线程字符串缓冲区大量操作

2. 集合List、Set、Map？

   1. 他们的底层实现？

      • List: 元素有序，有索引，可重复

        • ArrayList:可变数组非同步实现，底层数组
        • LinkedList：双向链表非同步实现，底层是双向链表
        • Vector： 底层数组，同步实现

      • Set：元素无序，无索引，不可重复

        • HashSet: 底层哈希表
        • LinkedHashSet：底层链表和哈希表
        • TreeSet：底层是红黑树，实现联动SortedSet，有序容器

      • Map：键值对存储，双列结合，两个key可以引用同一对象，key不能重复

        • HashMap:有序，不同步，线程不安全
          • LinkedHashMap：HashMap的子类，保存了记录顺序，按照访问次序排序
        • TreeMap：无序
        • HashTable：无序，同步，线程安全

   2. List和Set的区别？

      • 都是借口Collection的子接口
      • List存储的元素有序可重复可插入null
      • Set存储的元素无序不可重复，只允许一个null

   3. ArrayList和Vector的区别？

      • 实现了List借口，都是采用数组的方式进行存储数据
      • ArrayList线程不安全，存储空间不足，默认增加原来的50%，不可控
      • Vector：线程不安全，存储空间不足，默认增加原来的一倍，且增加量可控

   4. ArrayList，Vector，LinkedList的存储性能和特性？

      • ArrayList和Vector,数组保存，对象放在连续的位置，允许序号索引元素，查询快，增删慢，数组元素数大于实际的存储空间以便增删操作；
      • Vector：线程是安全的，性能差一些
      • LinkedList：对象在独立空间，每个空间保存下一个链接的索引、、、采用双向链表存储，按需要索引需遍历，插入数据，只需要记录前后项…查询慢，增删快；

   5. Collection和Collections的区别？

      • Collection是一个集合类的接口
      • Collections是一个针对集合类的帮助类

   6. Map的底层，扩展因子是多少，如何解决Hash碰撞？1.7 和1.8

      • 扩展因子： 0.75

      • 底层结构：

        • 1.7以前： 数组+链表
        • 1.8及以后： 数组+链表+红黑树，拉链超过8时，链表转化为红黑树，小于6时又转回数组

      • 如何解决hash碰撞：

        • HashMap使用链表来解决碰撞问题，当发生碰撞了，对象将会存储在链表的下一个节点中；

   7. 如何控制Map集合是线程安全的？

      1. Hashtable：使用了synchronized锁机制，线程公用一把锁，效率低；
      2. CurrentHashMap： 分段锁，对整个桶数组进行分段，每个分段用锁保护，并发性能好；

3. 接口和抽象类的区别？

   1. 接口:默认是public ，方法不能再接口中实现，Java8 开始接口默认实现（static 和final） ，不能直接创建对象，必须引用一个实现该接口的对象，是行为的抽象，是一种行为规范，实例变量默认final
   2. 抽象类： abstract修饰，可以有抽象方法和非抽象方法，对类的抽象，是一个模板设计， 不能直接创建对象，引用变量指向子类；
   3. 一个类可以实现多个接口，只能继承一个抽象类；

4. 重载和重写的区别？构造方法可以重写或重载吗？

   • 从意义上讲：

     • 重载是指同一个类中的多个方法具有相同的名字，但这些方法具有不同的参数列表，即参数的数量或参数类型不能完全相同
     • 重写是存在子父类之间的，子类定义的方法与父类中的方法具有相同的方法名字，相同的参数表和相同的返回类型

   • 构造方法可以重载，不能重写；

5. 面向对象：

   1. 面向对象的三大特征和五大原则？

      • 三大特征是：封装，继承，多态；
      • 五大原则是：单一职责原则，开放封闭原则，里氏替换原则，依赖倒置原则，接口分离原则

   2. 封装：

      • 封装，就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏；
      • 一个类就是封装了数据以及操作这些数据的代码的逻辑实体；
      • 在一个对象内部，有些方法是私有的，不能被外界访问，通过这种方式，对象对内部提供了不同级别的保护，以防止程序中无关的部分意外的改变或者错误的使用了对象的私有部分；提高了程序的安全性；

   3. 继承：

      • 可以让某个类型的对象获得另一个类型的对象的属性的方法；
      • 继承是指这样一种能力，它可以使用现有类的所有功能，并在无需进行重写编写原来的类的情况下对这些功能进行扩展。通过继承创建新类的称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”。
      • 继承的过程，就是从一般到特殊的过程，要实现继承，可以通过继承和组合来实现
      • 继承概念的实现方式有两种： 实现继承与接口接口继承；
      • 实现继承是指直接使用基类的属性和方法而无需额外编码的能力；接口继承是指仅使用属性和方法的名称。但是子类必须提供实现的能力；

   4. 多态：

      • 是指一个类实例的相同方法在不同情形有不同的表现形式。多态机制使不具有内部结构的对象可以共享相同的外部接口。这意味着，虽然针对不同对象的具体属性不同，但通过一个公共的类，它们（那些操作）可以通过相同的方式予以调用；

多线程

1. Java中实现线程的方式： – Runable Thread Callable

   1. 继承Thread重写run方法，调用start开启
   2. 声明一个Runable接口的类，将该类的对象作为target参数传递给Thread作为构造参数
   3. 实现Callable接口，通过FutureTask包装器来创建该实现类，作为Thread的构造参数

2. Callable实现的多线程和Thread的线程有什么区别？

   1. Callable接口，使用了call方法，可以有返回值，可以抛出检查的异常，创建的线程实现了接口还可以继承其他类，多个线程可以共享一个target，访问该线程需要使用Thread.currentThread方法；
   2. Thread： 是一个类只能被继承，不能继承其他类；访问当前线程使用this

3. 如何保证线程同步？ – synchronized和Lock

   1. synchronized:同步代码块的锁是任意对象，同步方法的锁是固定的this
   2. Lock： 是一个接口，使用lock后需要手动释放锁，不然很可能死锁
   • volatile:特殊域变量
     ReenreantLock:重入锁
     ThreadLocal：局部变量

4. ThreadLocal和Volatile的理解

   1. ThreadLocal：线程的局部变量，为每个使用该变量的线程提供独立的脚本，每个线程可以独立改变自己的副本，互不影响；
   2. volatile:被修饰的变量，不能被缓存在线程的内存中，每次使用该变量都是重新计算的，不提供任何原子操作；

5. Sleep()、wait()之间有什么区别？

   1. Sleep:用于程序被暂停指定的时间，自动苏醒，不释放任何锁和监视器。执行时引入暂停；
   2. wait:被调用后，线程不会再自动苏醒，需要被的线程调用唤醒方法，释放锁或监视器，用于线程通信；

6. 如何保证线程有序的执行？

   1. join：让主线程等待子线程运行结束后再继续运行；
   2. CountDownLatch：闭锁
   3. CachedThreadPool：缓存线程池
   4. blockingQueue： 阻塞队列
   5. newSingeleThreadExecutor:使用单个线程

7. 什么是可重入锁？

   1. 可重复可递归调用的锁，外层使用锁后，内层仍可使用，并不发生死锁，类似synchronized，可以指定公平和非公平锁；

8. 线程start()方法和run()方法简介和区别？

   1. start：启动线程，真正实现多线程运行，开启新的线程
   2. run：普通方法调用，执行线程中的线程体；

9. 什么是乐观锁和悲观锁？

   1. 乐观锁：每次操作数据都不会上锁，但更新数据的时候回根据版本号/CAS等机制判断，此期间是否有人更新该数据
   2. 悲观锁：每次操作数据均会上锁，每次都会判断是否拿到锁才能执行操作；

10. 你了解哪些编程并发编程同步类？

    1. CyclicBarrier:栅栏,可循环使用的屏障，让一组线程达到屏障，直到最后一个线程到达屏障，才会让该租线程释放去执行；
    2. CountDownLatch：闭锁，包括一个计数器，线程内的事件发生，await方法使线程阻塞，待计数器为0，则该事件完成，继续下一个时间
    3. FutureTask：也可以作为闭锁，利用Callable接口，call方法获取计算的结果，无结果则会一直阻塞到计算结束；

11.如何在两个线程间共享数据？利用wait和norify实现数据的同步？
1. 线程执行的代码相同，使用同个Runnable独享，Runnable对象有共享的数据
2. 线程执行的代码不同:
* 将共享的数据封装成另一个对象，然后将这个对象传递给各个Runnable对象，每个线程对共享数据的操作方法分配到这个对象
* 将Runnable对象作为一个类的内部类，共享数据作为这个类的成员变量，每个线程对共享数据的操作方法封装在外部类，实现各个操作的同步互斥；

12. 如何在Java中创建线程安全的Singleton:

    1. 懒汉式：在调用的使用才会去创建这个实力，在创建实例的方法上加synchronized实现线程安全，效率低；
    2. 饿汉式：基于类加载机制，避免了多线程同步问题，类加载就实例化；
    3. 双重检验锁： 双重判断是因为当单例模式使用懒汉式构造对象的时候，一个if语句判断时，可能有多个线程都在进行判断，此时若同时已经在判断，那么可能就会同时创建一个对象，这就不是单例模式了，因为构造了两个对象，所以应该加两个判断；

13. 线程池的实现，使用JDK提供的Executor线程池的框架

    1. newCachedThreadPool：新的任务，则插入SynchronousQueue同步队列中，在池中找可用线程，有则执行，没有则创建，线程空闲超时则销毁；
    2. newFixedThreadPool： 创建可容纳固定数量线程的池，每个线程存活时间是无限的，参数是指定创建的线程数，返回ExecutorService；

Java虚拟机

1. Java内存模型：

   1. 线程共有： 方法区，堆
   2. 线程私有：虚拟机栈，本地方法栈，程序计算器

2. java类初始化流程：

   1. 一个java对象的创建过程包括：类的初始化，类的实例化；
   2. 类加载检查-- 分配内存-- 初始化零值-- 设置对象头-- 执行init

3. java的类的加载机制：

   1. 类加载的过程：

      • 加载：将.class文件中的二进制字节流读入到JVM
        • 使用到了类加载器：启动类加载器（最顶层），扩展类加载器，应用程序类加载器（系统类加载器），类加载器之间的子父关系不是以继承关系实现，而是组合实现，这种层次关系叫双亲委派模型：
          • 当一个类收到了类加载请求，自己不会首先加载，而是委派给父加载器进行加载，只有当父加载返回不能加载时子加载器才会加载；
          • 好处： ；每个类加载都会经过最定层的启动类加载器，保证各个类加载器下都是同一个类；
      • 验证： 确保加载进来的字节流符合JVM规范
      • 准备：静态变量在方法分配内存，并设置默认初始值
      • 解析：虚拟机将常量池的符号引用替换为直接引用
      • 初始化：根据程序的赋值语句主动为类变量赋值

   2. 垃圾回收机制和垃圾回收算法：

      • JVM垃圾回收机制GC，通过对象是否被活动对象

      • 判断对象是否死亡：

        • 引用计数法：引用则计数+1，失败则-1 ，为0则不可再使用
        • 可达性分析算法：GC Roots对象为起始点，从此开始向下搜索，搜索的路径不可达时为不可用

      • 垃圾收集算法：

        • 标记-清除算法，赋值算法，标记-整理算法，分带收集算法
        • 收集器：
          • Serial收集器（复制算法）
          • Serial Old收集器（标记-整理）
          • ParNew收集器（停止-复制算法）
          • Parallel Scavenge(停止-复制算法)
          • Parallel Old收集器（停止-复制算法）
          • CMS收集器（标记-清理），G1（面向服务的垃圾收集器）

   3. java如何手动通知JVM进行垃圾回收，会立即执行吗？

      • System.gc()方法来“通知”垃圾回收器运行，不会立即响应，会立即停止所有响应去检查内存是否有可回收的对象

4. java堆栈的调整参数？

   1. 单例模式：一个类只有一个实例

      • 饿汉式：加载就去实例化，线程安全，加载较慢
      • 懒汉式（饱汉式）：调用才去实例化，线程不安全

   2. 装饰者模式：

      • 动态地给一个对象添加一些额外的职责，增加功能；

   3. 工厂模式：

      • 定义用于创建对象的接口，让子类决定实例化哪个类，工厂方法使一个类的实例化延迟到其子类

   4. 代理模式：

      • 为其他对象提供一种代理以控制这个对象的访问

5. 排序算法：

   1. 冒泡算法：
      • 时间复杂度是O（N）稳定的排序算法
   2. 快速算法

MySQL数据库

1. Mysql数据库的存储引擎有哪些？

   • mysql中的数据用各种不同的技术存储在文件中
   • MyISAM：不支持事务，不支持外键
   • InnoDB：健壮的事务性存储引擎，支持事务，MySQL中唯一支持外键的引擎；
   • MEMORY：速度极快，采用逻辑存储介质是内存，崩溃，要求存储数据是长度不变的类型，支持索引；
   • MERGE：是MyISAM表的组合，这些MyISAM表结构必须完全相同；
   • ARCHIVE：归档，支持索引，做仓库

2. MyISAM和InnoDB的区别？

   • InnoDB支持事务，而MyISAM不支持事务

   • InnoDB支持行级锁，而MyISAM支持表级锁

   • InnoDB支持MVCC，而MyISAM不支持（MVCC：多版本并发控制技术）

   • InnoDB支持外键，而MyISAM不支持

   • InnoDB不支持全文索引，而MyISAM支持

   • 总的来说，MyISAM适合SELECT密集型的表，而InnoDB适合INSERT和UPDATE密集型的表。

3. mysql索引的数据结构：

   1. 索引： 减少存储引擎需要扫描的数据量，随机IO变为顺序IO

   2. 索引的数据结构：

      • BTREE：二叉树，对半查询
      • HASH： 等值查询

   3. 索引的类型：

      • 主键索引
      • 唯一索引
      • 普通索引
      • 全文索引
      • 空间索引

4. mysql数据库层面的优化：

   1. 单表优化：

      • 字段：

        • 使用正确类型
        • varchar长度只分配真正需要的空间
        • 使用枚举或证书代替字符串类型
        • 字段数控制在20以内
        • 避免null
        • 整型存IP

      • 索引：

        • 根据字段使用情况建索引
        • 避免在where语句中对字段null进行判断，会使引擎放弃索引而使用全表扫描；
        • 字符字段不做索引
        • 不用外键，不用UNIQUE，使用程序保证约束

      • 查询SQL：

        • 不做列计算
        • 少用join
        • 分页查询数据，且分页数量不宜太大

      • 引擎，系统调优参数，升级硬件，缓存，表分区，垂直拆分，水拆分，分片原理，代理架构，客户端架构，兼容MySQL且可谁用扩展的数据库，NoSQL

   2. SQL语句的优化：

      1. 根据字段使用情况合理添加索引
      2. 查询语句之前使用explain查看执行的sql语句是否使用了索引，查询优化器，mysql可以通过EXPLAIN EXTEDED和SHOW WARNINGS来查看mysql优化器改写后的sql语句
      3. 根据sql语句的关键字合理使用索引，sql中有优化器进行sql语句优化去执行
      4. 少用select * ，查询哪些就去取哪些字段
      5. 查找执行慢的sql语句去进行优化，以及未使用索引的sql
      6. 分析慢查询sql，通过mysqldumpslow，第三方工具，实时获取有性能的sql

5. truncate和delete的区别：

   1. truncate：执行效率高，不支持回滚恢复
   2. delete：执行效率低，支持回滚恢复

6. mysql数据库中的悲观锁？ for update

   1. 乐观锁：手动实现，在操作的表加一个版本号，查询得到当前版本号v1，执行更新前获取现在的版本号是否为v1，相同则给v1+1=v2，不同则无法执行，效率高，失败多；
   2. 悲观锁：数据库自动实现，每次操作都需要通过获取锁，效率低；
   3. 共享锁：多个不同的事务，对同个资源共享一个锁
   4. 排它锁：多个不同的事务，对同个资源只有一把锁
   5. 行锁： 给某一行的记录加锁
   6. 表锁： 给表加锁

Java Web

1. cookie和session的区别？

   • cookie：客户端会话技术，将数据保存到客户端，由服务端生成，默认是关闭浏览器后被销毁，可持久化存储，将cookie数据写到硬盘的文件，可指定存活时间；

   • session：服务端会话技术，一次会话多次请求数据，session的实现是依赖于cookie，可以通过设置cookie的持久化，服务器自动完成

     • session钝化：sssion对象序列化到硬盘上，
     • session活化：将session文件转化为内存中的session对象

   • 区别？

     1. session存储数据在服务端，cookie在客户端
     2. session没有数据大小限制，cookie有
     3. session数据安全，cookie相对不安全
     4. session会在一定时间内保存在服务器上，访问多，会比较占用服务器的性能

2. JSP的九大内置对象

   1. pageContext:页面共享数据，可获取其他8个内置对象
   2. page：当前页面对象
   3. response：响应对象
   4. request：请求对象
   5. session：一次会话的多个请求间
   6. application：所有用户间共享数据
   7. exception： 异常对象
   8. out：输出对象
   9. config Servlet： 配置对象

3. jsp四大作用域

   1. pageContext：代表变量只能在当前页面上生效
   2. request：代表变量能在一次请求中生效
   3. session：代表变量能在一次会话中生效
   4. application：代表变量能在一个引用（多个会话），服务器的多个项目之间能够使用

4. servlet的生命周期

   1. init：只会执行一次，servlet在内存中只存在一个对象，单例，用于加载资源，第一次访问，servlet被创建，可通过配置文件设置服务器启动时创建该对象
   2. service：每次访问会执行一次，提供服务
   3. destroy：服务器正常关闭时执行一次，被销毁，用于释放资源
   • doGet/doPost ： 实际的处理业务流程，service根据客户端的请求类型来自动匹配需要执行的方法

5. jsp和servlet的区别：

   1. jsp经编译后变成了Servlet.jsp的本质就是Servlet

   2. jsp擅长于表现页面展示，servelt更擅长于逻辑控制

   3. servelt中没有内置对象，jsp的内置对象必须通过HttpServletRequest/HttpServletReponse/HttpServlet对象得到

   4. 主要区别？

      • servlet的应用逻辑是在java中，并且完全从表现层中的HTML里分离出来
      • jsp是java 和html 可以组合成一个扩展名为.jsp的文件
      • jsp侧重视图，servelt主要用于控制逻辑，servlet更多是类似于controller

6. filter的生命周期：

   1. init：只调用一次
   2. destroy： filter对象销毁，只会执行一次，用于释放资源
   3. dofilter:每次访问请求符合条件被拦截都会执行，可多次调用

7. 监听器有哪些？简单说几种都可以：

   1. ServletContextListener监听器 -----监听ServeltContext对象
   2. HttpSessionListener监听器 -------监听Session对象
   3. ServeltRequestListener监听器 -------监听Request对象

框架

1. MyBatis：

   1. 概述： Mybatis是基于java持久化框架，封装了jdbc，ORM思想（对象关系映射：数据库表和实体类及实体类的属性对应起来），使用构建者模式创建工厂，使用工厂模式生成SqlSession对象，使用JDK动态代理模式创建Dao对象

   2. #{}和${} 的区别？

      • 前者是预编译等同于？ ，后者是字符串替换，#{}防止SQL注入

   3. Dao接口工作原理：JDK动态代理，运行时使用JDK动态代理生成代理对象Proxy，代理对象proxy拦截接口方法，执行sql，将sql结果返回，Dao接口的工作原理是不能重载的，因为是全限定名+方法名的保存和寻找策略；

   4. Mybatis如何分页：

      1. 使用RowwBounds对象进行分页，是针对结果集进行内存分页，也可使用sql语句或者分页插件完成物理分页
      2. 分页插件的原理：
         • 使用mybatis提供的插件接口，实现自定义插件，在插件的拦截方法内拦截待执行的sql
         • 添加对应的物理分页语句和物理参数重写sql；

   5. 如何sql封装执行结果为目标对象返回？

      1. ,逐一定义列名和对象属性名之间的映射关系
      2. 使用sql列取别名
         • 有了列名和属性名的映射关系后，Mybatis通过反射创建对象，同时使用反射给对象的属性逐一赋值并返回；

   6. 映射文件常用标签：

      • select/insert/update/delete/trim/where/set/foreach/if/choose/when/otherwise/bind

   7. 事务的特性： – 一致性，院子性，隔离性，持久性

   8. 事务的安全：

      1. 脏读:一个事务读取到另一个事务中没有提交的数据
      2. 不可重复读（虚读）：在同一个事务中，两次读取到的数据不一样
      3. 幻读： 一个事务操作（DML）数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改；

   9. 事务的隔离级别：

      1. 读未提交： read-uncommited
      2. 读已提交（解决脏读） read-commited
      3. 可重复读（解决脏读和不可重复读） repeatable-read
      4. 串行化： seroalizable

   10. 事物的传播机制：

       1. required（默认）：支持使用当前事务，当前事务不存在，创建一个新的事务
       2. Supporrts:支持使用当前事务，事务不存在则不使用事务
       3. Mandatory：强制支持当前事务，不存在则抛出异常
       4. Requires_new:创建新的事务，当前事务不出在则事务挂起
       5. Not_supported:无事务执行，当前事务不存在则挂起
       6. Never:无事务执行，有事务则抛异常
       7. Nested:嵌套事务，事务存在则在嵌套的事务中执行

   11. 一，二级缓存：

       1. 一级缓存:指的是Mybatis中SqlSession对象的缓存，基于PerpetualCache的hashMap本地缓存，存储作用域为Mapper（Namespace），实现二级缓存的前提是该类需要实现序列化接口

       2. 二级缓存：指的是Mybatis中SqlSessionFactory对象的缓存，存储作用域为Mapper（Namespace），实现二级缓存的前提是该类需要实现序列化接口

       3. 对于缓存的更新机制，当某个作用域进行增删改之后，默认该域之下的select中的缓存被clear

       4. 数据一开始进来首先去查二级缓存，二级缓存没有去找一级缓存，一级缓存没有去找数据库。 二级缓存–>一级缓存–>数据库

   12. 缓存的更新机制：

       1. 当某个作用域进行增删改之后，默认该域下的select中的缓存被clear

   13. Mybatis的延迟加载：

       1. 仅支持association关联对象和collection关联集合对象的延迟加载，延迟加载只针对对象的属性，不管是管理对象，一般一对多/多对多：延迟加载 多对一，一对一： 立即加载

Spring

1. Spring的核心模块：Spring上下文，Spring AOP，Spring DAO，Spring ORM SPring Web ，Spring MVC

2. 耦合：

   1. 程序之间的依赖关系：分为内容，公共，外部，控制，标记，数据，非直接耦合；
      • 解决思路：反射来创建对象，避免new/通过读取配置文件获取要创建的对象的全限定类名/工厂模式解耦合

3. 核心：

   1. 两大核心：
      • IOC：反转控制
      • AOP：面向切面编程

4. 优势：

   1. 方便解耦
   2. AOP的支持
   3. 声明式事务的支持
   4. 方便程序的测试
   5. 方便集成各种优秀框架

5. IOC： 是一种设计思想，DI（依赖注入），是实现IOC的一种方法

6. 负载均衡：工作任务分摊到多个操作单元上进行执行；

7. 增强类的方式：

   1. 继承
   2. 装饰者模式（被增强类必须实现接口）
   3. 动态代理
   • 装饰者模式是建立在原有类上对原有类进行改变
   • 而动态代理则是创建一个中间对象，对原有类的一个增强，实际上没有对原有类造成侵害

8. AOP底层：

   1. JDK动态代理（被增强类的必须实现接口）
   2. cglib:ASM实现（被代理类不能是最终类）

9. 什么是Spring IOC：Spring的核心是spring容器，容器创建对象，将它们装配在一起，配置它们并管理他们完整的生命周期，Spring容器使用依赖注入来管理组成的应用程序的组件

10. 依赖注入：

    1. 不用创建对象，只是描述如何创建对象，不是直接在代码中将组件和服务连接一起，由ioc容器将它们装配一起；

11. 依赖注入的方式：

    1. 构造函数注入
    2. setter注入
    3. 接口注入

12. spring有多少种ioc容器：beanFactory,applicationContext

13. spring配置方式：xml注解，基于javaAPI配置

14. Spring支持集中bean scope方式：singleton,prototype,request,session,global-seeion

15. Spring的自动装配方式：no（显示bean），byName，byType，构造函数和，autodetect

16. spring支持的事务管理模型：

    1. 程序化事务管理
    2. 声明式事务管理

17. AOP实现方式：

    1. 静态代理
    2. 动态代理
    3. 编译时编织
    4. 类加载时编织

SpringMVC基于java实现MVC设计模型的请求驱动类型的轻量Web框架

1. SpringMVC执行流程：

   1. 客户端发送请求
   2. 前端控制器接收请求
   3. 请求查找处理器，通过处理器映射器找到控制器和其中的方法并将该类和方法返回给前端控制器
   4. 前端控制器请求适配器得到一个合适的适配器去执行处理器（控制类）所适配对应的方法，返回结果视图模型（即返回的页面）给适配器
   5. 适配器将视图模型返回给前端控制器
   6. 前端控制器请求执行视图解析器
   7. 视图解析器根据视图视图模型进行解析并显示返回给视图给前端控制器
   8. 前端控制器将返回的视图放入请求域中
   9. 响应到客户端

2. SpringMVC：三大组件：处理器映射器，处理器适配器，视图解析器

JPA 等其他内容

SpringData：简化构建基于Spring框架应用的数据访问技术
- ORM思想：操作实体类就相当于操作数据库表
- 建立两个映射关系：实体类和表的映射实体类中的属性和表的字段

JPA规范：本职就是ORM规范，底层使用hibernate操作数据库
1. 编写方式：
- 符合SpringDataJpa的dao层接口
- 只需要编写dao的接口，不需要编写dao接口的实现类
2. 规范：
1. 需要继承2个接口（JpaRepository,JpaSpecificationExecutor）
2. 需要提供相应的泛型：
* JpaRepository<实体类，主键类型>：封装了基本的CURD；
* JpaSpecificationExecutor<实体类>：封装了复杂查询（分页）

SpringBoot：习惯优于配置；