面试指南（所有内容取自网络，侵删）

面试总结

1. Collection集合接口

1.1 Collection接口

是最基本的接口，派生了两个子接口Set和List

1.2 Set接口

无序且不可重复

1.2.1 HashSet接口

基于HashMap实现，所有元素都是保存在HashMap的key中，而value中保存了PRESENT。

1.3 List接口

有序且可重复

1.3.1 ArrayList，LinkedList接口（线程不安全）

总结：

  • ArrayList内部结构是数组（Array），查找高效，修改低效。
  • LinkedList接口内部是链表Linked，查找低效，修改高效
  • ArrayList特点是有序可重复的，实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
  • ArrayList 采用的是数组形式来保存对象的，这种方式将对象放在连续的位置中，所以最大的缺点就是插入删除时非常麻烦
  • LinkedList 采用的将对象存放在独立的空间中，而且在每个空间中还保存下一个链接的索引，但是缺点就是查找非常麻烦 要丛第一个索引开始
  • 对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
  • 对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。
  • 在ArrayList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动。
  • ArrayList更适合读取数据，linkedList更多的时候添加或删除数据。

2. Map接口

Map也是接口，但没有继承Collection接口。该接口描述了从不重复的键到值的映射。Map接口用于维护键/值对

2.1HashMap（线程不同步）（Hashtable为线程安全）

基于哈希表实现，特点就是键值对的映射关系。一个key对应一个Value。HashMap中元素的排列顺序是不固定的。更加适合于对元素进行插入、删除和定位。

2.1.1 HashMap和Hashtable的区别

HashMap和Hashtable都实现了Map接口，但决定用哪一个之前先要弄清楚它们之间的分别。主要的区别有：线程安全性，同步(synchronization)，以及速度。

  • HashMap几乎可以等价于Hashtable，除了HashMap是非synchronized的，并可以接受null(HashMap可以接受为null的键值(key)和值(value)，而Hashtable则不行)。
  • HashMap是非synchronized，而Hashtable是synchronized，这意味着Hashtable是线程安全的，多个线程可以共享一个Hashtable；而如果没有正确的同步的话，多个线程是不能共享HashMap的。Java 5提供了ConcurrentHashMap，它是HashTable的替代，比HashTable的扩展性更好。
  • 另一个区别是HashMap的迭代器(Iterator)是fail-fast迭代器，而Hashtable的enumerator迭代器不是fail-fast的。所以当有其它线程改变了HashMap的结构（增加或者移除元素），将会抛出ConcurrentModificationException，但迭代器本身的remove()方法移除元素则不会抛出ConcurrentModificationException异常。但这并不是一个一定发生的行为，要看JVM。这条同样也是Enumeration和Iterator的区别。
  • 由于Hashtable是线程安全的也是synchronized，所以在单线程环境下它比HashMap要慢。如果你不需要同步，只需要单一线程，那么使用HashMap性能要好过Hashtable。
  • HashMap不能保证随着时间的推移Map中的元素次序是不变的。

2.1.2 让HashMap同步

Map m = Collections.synchronizeMap(hashMap);

2.2 TreeMap（线程不同步）

基于红黑树实现。TreeMap中的元素保持着某种固定的顺序。更加适合于对元素的顺序遍历。

3. 迭代器（Iterator和增强for循环）

迭代器是一种模式，它可以使得对于序列类型的数据结构的遍历行为与被遍历的对象分离

3.1 Iterator

Iterator对集合类中的任何一个实现类，都可以返回这样一个Iterator对象。可以适用于任何一个类。
因为集合类(List和Set等)可以装入的对象的类型是不确定的,从集合中取出时都是Object类型,用时都需要进行强制转化,这样会很麻烦,用上泛型,就是提前告诉集合确定要装入集合的类型,这样就可以直接使用而不用显示类型转换.非常方便.

3.2 foreach

优势在于更加简洁，更不容易出错，不必关心下标的起始值和终止值

forEach不是关键字,关键字还是for,语句是由iterator实现的，他们最大的不同之处就在于remove()方法上
如果在循环的过程中调用集合的remove()方法，就会导致循环出错，因为循环过程中list.size()的大小变化了，就导致了错误。 所以，如果想在循环语句中删除集合中的某个元素，就要用迭代器iterator的remove()方法，因为它的remove()方法不仅会删除元素，还会维护一个标志，用来记录目前是不是可删除状态，例如，你不能连续两次调用它的remove()方法，调用之前至少有一次next()方法的调用。

3.3 区别

  • 采用ArrayList对随机访问比较快，而for循环中的get()方法，采用的即是随机访问的方法，因此在ArrayList里，for循环较快
  • 采用LinkedList则是顺序访问比较快，iterator中的next()方法，采用的即是顺序访问的方法，因此在LinkedList里，使用iterator较快
  • 从数据结构角度分析,for循环适合访问顺序结构,可以根据下标快速获取指定元素.而Iterator 适合访问链式结构,因为迭代器是通过next()和Pre()来定位的.可以访问没有顺序的集合.
  • 而使用 Iterator 的好处在于可以使用相同方式去遍历集合中元素，而不用考虑集合类的内部实现（只要它实现了 java.lang.Iterable 接口），如果使用 Iterator 来遍历集合中元素，一旦不再使用 List 转而使用 Set 来组织数据，那遍历元素的代码不用做任何修改，如果使用 for 来遍历，那所有遍历此集合的算法都得做相应调整,因为List有序,Set无序,结构不同,他们的访问算法也不一样.
  • map接口没有迭代器，可以Set keySet() :获取到所有的键，存储到一个Set集合中，并返回该集合，因为Set有迭代器，每次迭代出来的是一个键，再根据键来得到值。

4. String与StringBuffer

简单地说，就是一个变量和常量的关系。StringBuffer对象的内容可以修改；而String对象一旦产生后就不可以被修改，重新赋值其实是两个对象

4.1 String

在String类中没有用来改变已有字符串中的某个字符的方法，由于不能改变一个Java字符串中的某个单独字符，所以在JDK文档中称String类的对象是不可改变的。然而，不可改变的字符串具有一个很大的优点:编译器可以把字符串设为共享的。

是对象不是原始类型.
为不可变对象,一旦被创建,就不能修改它的值.
对于已经存在的String对象的修改都是重新创建一个新的对象,然后把新的值保存进去.
String 是final类,即不能被继承.

4.2 StringBuffer

是一个可变对象,当对他进行修改的时候不会像String那样重新建立对象
它只能通过构造函数来建立,
StringBuffer sb = new StringBuffer();
注意:不能通过赋值符号对他进行赋值.
sb = "welcome to here!";//error
对象被建立以后,在内存中就会分配内存空间,并初始保存一个null.向StringBuffer
中赋值的时候可以通过它的append方法.
sb.append("hello");

可预先分配指定长度的内存块建立一个字符串缓冲区。这样使用StringBuffer类的append方法追加字符 比 String使用 + 操作符添加字符 到 一个已经存在的字符串后面有效率得多。因为使用 + 操作符每一次将字符添加到一个字符串中去时，字符串对象都需要寻找一个新的内存空间来容纳更大的字符串，这无凝是一个非常消耗时间的操作。添加多个字符也就意味着要一次又一次的对字符串重新分配内存。使用StringBuffer类就避免了这个问题。

4.3区别

  • 三者在执行速度方面的比较：StringBuilder > StringBuffer > String
  • StringBuilder：线程非安全的；StringBuffer：线程安全的
  • 如果要操作少量的数据用 = String；单线程操作字符串缓冲区 下操作大量数据 = StringBuilder；多线程操作字符串缓冲区 下操作大量数据 = StringBuffer
  • 如果经常需要对一个字符串进行修改，例如插入、删除等操作，使用StringBuffer要更加适合一些。

5. 线程

5.1 进程和线程的区别

  • 进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1--n个线程。

  • 线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。

  • 线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止。

  • 多进程是指操作系统能同时运行多个任务（程序）。

  • 多线程是指在同一程序中有多个顺序流在执行。

线程

5.2 五种状态（生命周期）

  • 新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread();

  • 就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行；

  • 运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就 绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；

  • 阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才 有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种：

  • 1.等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；

  • 2.同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；

  • 3.其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

  • 死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

5.2 实现方法

一种是继承Thread类，另外一种是实现Runable接口

5.2.1 扩展java.lang.Thread类

class MyThread extends Thread { 
         private int i = 0;
         @Override
         public void run() {
             for (i = 0; i < 100; i++) {
                 System.out.println(Thread.currentThread().getName() + " " + i);
            }
        }
    }

public class ThreadTest {
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 30) {
                Thread myThread1 = new MyThread();     // 创建一个新的线程  myThread1  此线程进入新建状态
                Thread myThread2 = new MyThread();     // 创建一个新的线程 myThread2 此线程进入新建状态
                myThread1.start();                     // 调用start()方法使得线程进入就绪状态
                myThread2.start();                     // 调用start()方法使得线程进入就绪状态
            }
        }
    }
}

继承Thread类，通过重写run()方法定义了一个新的线程类MyThread，其中run()方法的方法体代表了线程需要完成的任务，称之为线程执行体。当创建此线程类对象时一个新的线程得以创建，并进入到线程新建状态。通过调用线程对象引用的start()方法，使得该线程进入到就绪状态，此时此线程并不一定会马上得以执行，这取决于CPU调度时机。

5.2.2 实现Runnable接口

class MyRunnable implements Runnable {
    private int i = 0;
    @Override
    public void run() {
        for (i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }
}

public class ThreadTest {

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 30) {
                Runnable myRunnable = new MyRunnable(); // 创建一个Runnable实现类的对象
                Thread thread1 = new Thread(myRunnable); // 将myRunnable作为Thread target创建新的线程
                Thread thread2 = new Thread(myRunnable);
                thread1.start(); // 调用start()方法使得线程进入就绪状态
                thread2.start();
            }
        }
    }
}

5.3 线程控制

5.3.1 join()

让一个线程等待另一个线程完成才继续执行。如A线程线程执行体中调用B线程的join()方法，则A线程被阻塞，知道B线程执行完为止，A才能得以继续执行。

5.3.2 sleep()

让当前的正在执行的线程暂停指定的时间，并进入阻塞状态。在其睡眠的时间段内，该线程由于不是处于就绪状态，因此不会得到执行的机会。即使此时系统中没有任何其他可执行的线程，出于sleep()中的线程也不会执行。因此sleep()方法常用来暂停线程执行。

当调用了新建的线程的start()方法后，线程进入到就绪状态，可能会在接下来的某个时间获取CPU时间片得以执行，如果希望这个新线程必然性的立即执行，直接调用原来线程的sleep(1)即可。

5.3.3 后台线程（Daemon Thread）

后台线程主要是为其他线程（相对可以称之为前台线程）提供服务，或“守护线程”。如JVM中的垃圾回收线程。

生命周期：后台线程的生命周期与前台线程生命周期有一定关联。主要体现在：当所有的前台线程都进入死亡状态时，后台线程会自动死亡

5.3.4改变线程的优先级/setPriority()

每个线程在执行时都具有一定的优先级，优先级高的线程具有较多的执行机会。每个线程默认的优先级都与创建它的线程的优先级相同。main线程默认具有普通优先级。

设置线程优先级：setPriority(int priorityLevel)。参数priorityLevel范围在1-10之间

5.3.5 线程让步：yield()

当某个线程调用yiled()方法从运行状态转换到就绪状态后，CPU从就绪状态线程队列中只会选择与该线程优先级相同或优先级更高的线程去执行。

5.4 线程安全

是指多线程环境下对共享资源的访问可能会引起此共享资源的不一致性。因此，为避免线程安全问题，应该避免多线程环境下对此共享资源的并发访问。

5.4.1 同步方法

对共享资源进行访问的方法定义中加上synchronized关键字修饰，使得此方法称为同步方法。可以简单理解成对此方法进行了加锁，其锁对象为当前方法所在的对象自身。多线程环境下，当执行此方法时，首先都要获得此同步锁（且同时最多只有一个线程能够获得），只有当线程执行完此同步方法后，才会释放锁对象，其他的线程才有可能获取此同步锁，以此类推...

 public synchronized void run() { }

使用同步方法时，使得整个方法体都成为了同步执行状态，会使得可能出现同步范围过大的情况，于是，针对需要同步的代码可以直接另一种同步方式——同步代码块来解决。

 synchronized (obj) { }

5.5 wait()/notify()/notifyAll()线程通信

这三个方法主要都是用于多线程中，都是Object类中的本地方法。

在实际的多线程编程中，只有同步锁对象调这三个方法，才能完成对多线程间的线程通信。

  • wait()：导致当前线程等待并使其进入到等待阻塞状态。直到其他线程调用该同步锁对象的notify()或notifyAll()方法来唤醒此线程。

  • notify()：唤醒在此同步锁对象上等待的单个线程，如果有多个线程都在此同步锁对象上等待，则会任意选择其中某个线程进行唤醒操作，只有当前线程放弃对同步锁对象的锁定，才可能执行被唤醒的线程。

  • notifyAll()：唤醒在此同步锁对象上等待的所有线程，只有当前线程放弃对同步锁对象的锁定，才可能执行被唤醒的线程。

需要注意的是：

  1. wait()方法执行后，当前线程立即进入到等待阻塞状态，其后面的代码不会执行；

  2. notify()/notifyAll()方法执行后，将唤醒此同步锁对象上的（任意一个-notify()/所有-notifyAll()）线程对象，但是，此时还并没有释放同步锁对象，也就是说，如果notify()/notifyAll()后面还有代码，还会继续进行，知道当前线程执行完毕才会释放同步锁对象；

  3. notify()/notifyAll()执行后，如果右面有sleep()方法，则会使当前线程进入到阻塞状态，但是同步对象锁没有释放，依然自己保留，那么一定时候后还是会继续执行此线程，接下来同2；

  4. wait()/notify()/nitifyAll()完成线程间的通信或协作都是基于不同对象锁的，因此，如果是不同的同步对象锁将失去意义，同时，同步对象锁最好是与共享资源对象保持一一对应关系；

  5. 当wait线程唤醒后并执行时，是接着上次执行到的wait()方法代码后面继续往下执行的。

5.6 currentThread()

作用就是得到当前线程的对象。

通过currentThread()我们可以轻易的就得到当前线程的名称，我们还可以通过线程对象，得到其他的属性。

注意：

currentThread()方法返回的是对当前正在执行的线程对象的引用，this代表的是当前调用它所在函数所属的对象的引用

6 数据库

6.1 存储引擎

MySQL常用存储引擎：InnoDB适用于频繁维护修改插入等数据表，MyISAM适合少改写，少插入的频繁读取的表。常用InnoDB存储引擎

6.2 事务

Innodb才支持事务

主要是为了解决并发情况下保持数据一致性的问题。

以下4个基本特征：

  • Atomic（原子性）：事务中包含的操作被看做一个逻辑单元，这个逻辑单元中的操作要么全部成功，要么全部失败。

  • Consistency（一致性）：只有合法的数据可以被写入数据库，否则事务应该将其回滚到最初状态。

  • Isolation（隔离性）：事务允许多个用户对同一个数据进行并发访问，而不破坏数据的正确性和完整性。同时，并行事务的修改必须与其他并行事务的修改相互独立。

  • Durability（持久性）：事务结束后，事务处理的结果必须能够得到固化。

6.2.1 处理事务

Java事务的类型有三种：JDBC事务、JTA(Java Transaction API)事务、容器事务

处理事务：spring的事务是通过“声明式事务”的方式对事务进行管理，即在配置文件中进行声明，通过AOP将事务切面切入程序，最大的好处是大大减少了代码量，提高了工作效率。

6.3 left join、right join、inner join

百度一下

6.4 数据库优化

  1. 减少查询字段数
  2. 表关联尽量用主键
  3. 查询条件尽量避免模糊查询
  4. 避免使用排序字段，排序字段尽量使用主键
  5. 尽量使用限制查询条件
  6. 查询条件使用有效索引

7 项目相关

7.1 对MVC的理解

MVC是model-view-controler的简称。也就是模型-视图-控制器。mvc是一种设计模式，他强制性的把应用程序的输入、处理和输出分开。mvc中的模型、视图、控制器分别担任着不同的任务。

视图：视图是用户看到并与之交互的界面。视图向用户显示相关的数据，并接受用户的输入。视图不进行任何业务逻辑处理。

模型：模型表示业务数据和业务处理。相当于javaBean。一个模型能为多个视图提供数据。这提高了应用程序的重用性。

控制器：当用户单击web页面中的提交按钮时，控制器接收请求并调用相应的模型去处理请求。然后根据处理的结果调用相应的视图来显示处理的结构。

MVC的处理过程：首先控制器接收用户的请求，调用相应的模型来进行业务处理，并返回数据给控制器。控制器调用相应的视图来显示处理的结构。并通过视图呈现给用户。如在项目中要对应MVC的话；View对应项目中的jsp，controler对应action，model对应service+dao层的业务逻辑和持久层的操作。

7.2 框架的优点

7.2.1 Hibernate（持久层）

工作原理：

  1. 读取并解析配置文件
  2. 读取并解析映射信息，创建SessionFactory
  3. 打开Session
  4. 创建事务Transaction
  5. 持久化操作
  6. 提交事务
  7. 关闭Session
  8. 关闭SessionFactory

优化：
Hibernate对数据的缓存包括两个级：一级缓存，在Session的级别上进行，主要是对象缓存，以其id为键保存对象，在Session的生命期间存在；二级缓存，在SessionFactory的级别上进行，有对象缓存和查询缓存，查询缓存以查询条件为键保存查询结果，在SessionFactory的生命期间存在，默认地，Hibernate只启用一级缓存

优点：

  1. Hibernate是JDBC的轻量级的对象封装，它是一个独立的对象持久层框架。Hibernate可以用在任何JDBC可以使用的场合，例如Java应用程序的数据库访问代码，DAO接口的实现类，甚至可以是BMP里面的访问数据库的代码。

  2. Hibernate是一个和JDBC密切关联的框架，所以Hibernate的兼容性和JDBC驱动，和数据库都有一定的关系，但是和使用它的Java程序，和App Server没有任何关系，也不存在兼容性问题。

  3. Hibernate不能用来直接和Entity Bean做对比，只有放在整个J2EE项目的框架中才能比较。并且即使是放在软件整体框架中来看，Hibernate也是做为JDBC的替代者出现的，而不是Entity Bean的替代者出现的。

  4. Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操控数据库。

  5. Hibernate可以应用在任何使用JDBC的场合。

  6. Hibernate 使用Java 反射机制而不是字节码增强程序来实现透明性。

  7. Hibernate 的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。

7.2.2 mybatis（持久层）

  1. 易于上手和掌握。

  2. sql写在xml里，便于统一管理和优化。

  3. 解除sql与程序代码的耦合。

  4. 提供映射标签，支持对象与数据库的orm字段关系映射

  5. 提供对象关系映射标签，支持对象关系组建维护

  6. 提供xml标签，支持编写动态sql。

7.2.3 优势对比

  1. Mybatis优势MyBatis可以进行更为细致的SQL优化，可以减少查询字段。

  2. MyBatis容易掌握，而Hibernate门槛较高。

  3. Hibernate优势Hibernate的DAO层开发比MyBatis简单，Mybatis需要维护SQL和结果映射。

  4. Hibernate对对象的维护和缓存要比MyBatis好，对增删改查的对象的维护要方便。

  5. Hibernate数据库移植性很好，MyBatis的数据库移植性不好，不同的数据库需要写不同SQL。

  6. Hibernate有更好的二级缓存机制，可以使用第三方缓存。MyBatis本身提供的缓存机制不佳。

7.2.4 Spring（控制层+业务层）

它基于IoC（Inversion of Control，反向控制）和AOP的构架多层j2ee系统的框架，但它不强迫你必须在每一层中必须使用Spring，因为它模块化的很好，允许你根据自己的需要选择使用它的某一个模块；它实现了很优雅的MVC，对不同的数据访问技术提供了统一的接口，采用IoC使得可以很容易的实现bean的装配，提供了简洁的AOP并据此实现Transcation Managment，等等

  • 在项目中利用spring的ioc（控制反转或依赖注入），明确的定义组件接口（如UserDao），开发者可以独立开发各个组件，然后根据组件间的依赖关系组装（UserAction依赖于UserService，UserService依赖于Userdao）运行，很好的把struts（Action）和hibernate（dao的实现）结合起来；
  • spring的事务管理把hibernate对数据库的操作进行了事务配置

事务控制：

  • spring事务包括编程事务和声明式事务。在系统中使用了声明式的事务管理是用spring的AOP来实现的；配置了只读事务和回滚事务（传播行为为REQUIRED）当出现错误后进行事务回滚操作。在项目中通过aop切入事务到service层，这样做能使一次业务逻辑操作如果包括几个数据库操作都控制在一个事务中。

  1. 低侵入式设计，代码污染极低

  2. 独立于各种应用服务器，基于Spring框架的应用，可以真正实现Write Once,Run Anywhere的承诺

  3. Spring的DI机制降低了业务对象替换的复杂性，提高了组件之间的解耦

  4. Spring的AOP支持允许将一些通用任务如安全、事务、日志等进行集中式管理，从而提供了更好的复用

  5. Spring的ORM和DAO提供了与第三方持久层框架的良好整合，并简化了底层的数据库访问

  6. Spring并不强制应用完全依赖于Spring，开发者可自由选用Spring框架的部分或全部

7.2.5 struts2

工作原理：

  • 发送http请求
  • web服务器（tomcat、weblogic）
  • 执行struts核心过滤器StrutsprepareAndExecuteFilter
  • 加载struts配置文件中配置信息，找到对应的Action类并实例化
  • 执行各类拦截器和action中对应方法
  • 配置文件中找到返回结果
  • 转发到具体页面或其他操作

  1. 实现了MVC模式，层次结构清晰，使程序员只需关注业务逻辑的实现。

  2. 丰富的标签库，大大提高了开发的效率。

  3. Struts2提供丰富的拦截器实现。

  4. 通过配置文件，就可以掌握整个系统各个部分之间的关系。

  5. 异常处理机制，只需在配置文件中配置异常的映射，即可对异常做相应的处理。

  6. Struts2的可扩展性高。

  7. 面向切面编程的思想在Strut2中也有了很好的体现。最重要的体现就是拦截器的使用

7.2.6 springMVC

第一步：发起请求到前端控制器(DispatcherServlet)

第二步：前端控制器请求HandlerMapping查找 Handler，可以根据xml配置、注解进行查找

第三步：处理器映射器HandlerMapping向前端控制器返回Handler

第四步：前端控制器调用处理器适配器去执行Handler

第五步：处理器适配器去执行Handler

第六步：Handler执行完成给适配器返回ModelAndView

第七步：处理器适配器向前端控制器返回ModelAndView，ModelAndView是springmvc框架的一个底层对象，包括Model和view

第八步：前端控制器请求视图解析器去进行视图解析，根据逻辑视图名解析成真正的视图(jsp)

第九步：视图解析器向前端控制器返回View

第十步：前端控制器进行视图渲染，视图渲染将模型数据(在ModelAndView对象中)填充到request域

第十一步：前端控制器向用户响应结果工作流程：

优点：

  1. 进行更简洁的Web层的开发
  2. 天生与Spring框架集成（如IoC容器、AOP等）
  3. 提供强大的约定大于配置的契约式编程支持
  4. 非常灵活的数据验证、格式化和数据绑定机制
  5. 支持Restful风格

7.3 框架应用

  1. 在表示层中，首先通过jsp页面实现交互界面，负责传送请求（request）和接收响应（response），然后struts根据配置文件（struts。xml）将actionServlet接收到的request委派给响应的action处理。
  2. 在业务层中，管理服务组件的spring ioc容器负责向action提供业务模型（model）组件和组件的协作对象数据处理（dao）组件完成业务逻辑，并提供事务处理、缓冲池等容器组件以提升系统性能和保证数据的完整性。
  3. 在持久层中，则依赖于hibernate的对象化映射和数据库交互，处理dao组件请求的数据，并返回处理结果。
posted on 2017-07-23 15:41  theLazarus  阅读(362)  评论(0)  编辑  收藏  举报

Powered by: 博客园 Copyright © 2024 theLazarus
Powered by .NET 8.0 on Kubernetes