1.面向对象思想(OOP)

  1.1  什么是面向对象，面向对象的优势

答：概念：

现实世界中，随处可见的一种事物就是对象。对象是事物的实在体，比如：人类、书桌、电脑、高楼大夏等。在 计算机世界中，面向对象程序设计的思想以对象来思考，首先要将现实世界的实体抽象为对象，然后考虑这个对 象具备的属性和行为，对同类对象抽象出其共性，形成类，类中的大多数数据由本类的方法进行处理，类通过一  个简单的外部接口与外界发生关系，对象与对象之间通过消息进行通信，程序流程由用户在使用中决定

优势：可扩展性，可重用性，可管理性

成员变量：可以添加属性，可以是公有和私有的。

局部变量：定义在方法中，{}大括号里面的

  1.2   面向对象的特征， 封装，继承，多态，抽象分别的特点

答：

封装：是面向对象编程的核心思想，将对象的属性封装起来，而将对象的属性和行为封装起来的载体就是类，类  通 常对客户隐藏其实现细节，这就是封装的思想。采用封装的思想保证了类内部数据的完整性，应用该类的用 户不 能轻易直接操纵此数据结构，而只能执行类允许公开的数据。这样避免了外部对的内部数据的影响，提高 程序的  可维护性，代码的复用性。Private 修饰

继承：是对有着共同特性的多类事物，进行再抽象成一个类。这个类就是多类事物的父类。父类的意义在于抽取  多类事物的共性。

多态性：允许以统一风格编写程序，以处理种类繁多的已存在的类以及相关类。该统一风格可以由父类来实现，  根 据父类统一风格的处理，就可以实例化子类的对象。由于整个事件的处理都只依赖父类的方法。所以日后只 要维 护和调整父类的方法即可，这样降低了维护的难度，节省了时间。在提到多态的同时，不得不提到抽象类  好接口，  因为多态的实现并不依赖具体类，而是依赖抽象类和接口。在多态的机制中，比抽象类更为方便的方 式是将抽象 类定义为接口。由抽象方法组成的集合就是接口。

抽象：就是把现实生活中的某一类东西提取出来，用程序代码表示，我们通常叫做类或者接口。抽象包括两个方  面：一个是数据抽象，一个是过程抽象。数据抽象也就是对象的属性。过程抽象是对象的行为特征。

继承的特点：通过继承，在已有类型基础上进行扩充或改造，得到新的数据类型。已有的类型称为父类或超类。得到 的新数据类型，称为子类或派生类。类的继承提高了程序代码的重用性和可扩充性，缩短了软件开发的周期。

封装的特点： 封装是JAVA面向对象的特点的表现，封装是一种信息隐蔽技术它有两个含义，即把对象的全部属性和全部服务结合在一起，形成一个不可分割的独立单位，以及尽可能隐藏对象的内部结构。通过封装，可以实现对属性的数据访问限制，同时增加了程序的可维护性。

由于取 值方法和赋值方法隐藏了实现的变更，因此并不会影响读取或修改该属性的类，避免了大规模的修改，程序的可维护性增强。

多态的特点：允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）。 父类引用指向子类对象(多态)

抽象的特点： 抽象就是从多个事物中将共性的，本质的内容抽取出来。抽象类和抽象方法必须用abstract关键字 来修饰。抽象方法只有方法声明，没有方法体，定义在抽象类中

  1.3  方法重写和重载

答：

override重写：父类与子类之间,方法名 参数 返回类型一致,修饰符权限大于或等于父类 ,异常小于等于父类

overload重载：同类方法之间,方法名一致,参数类型或顺序,个数不一致，不能通过返回值不同来实现重载

  1.4  抽象类和接口的特点

答：(II)区别

1）抽象类中可以包含抽象方法和具体的方法实现，接口只能包含抽象方法。

（2）抽象类中可以有构造方法，接口中不能有构造方法。

（3）抽象类中可以有普通成员变量，接口只能有常量。

（4）抽象类中抽象方法可以使用public，protected，默认类型进行访问控制，接口中所有的方法都必须是public，并且默认是public abstract类型。

（5）抽象类可以包含静态方法，接口中能包含静态方法。

（6）抽象类中的静态成员变量的访问类型可以任意，接口必须是public static类型

共同特点：

1、抽象类和接口都不能被实例化。

2、抽象类和接口都包含抽象方法，并由实现接口或继承抽象类的具体实现类来实现抽象方法。

  1.5  集合类  ArrayList 和linkedList  HashMap和HashTable 的区别

答：

ArrayList 和LinkedList 区别

ArrayList 是有序集合，都是使用数组方式存储数据，即存储在这个集合中的元素的位置都是有顺序的，并且  其中的数据是允许重复的，我们以后可以按位置索引号取出某个元素，ArrayList的特点是：查询速度快，但是 插入、删除速度慢

LinkedList 使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本  项的前后项即可，所以LinkedList的特点是：查询速度慢，但是删除，插入快

他们都是线程不安全的

HashMap和HashTable 的区别

HashMap 允许将null作为一个entry的key或者value，hashMap 是线程序不安全的，不是同步的

HashTable 不允许将null作为一个entry的key或者value，Hashtable是线程安全的，也就是说是同步的

hashTable 是基于陈旧的Dictionary类的，hashMap是java1.2引进的map接口的一个实现。

  1.6  String 和StringBuffered 和StringBuild 的区别

答：

String    1，Stirng是对象不是基本数据类型    2，String是final类，不能被继承。是不可变对象，一旦创建，就不能修改它的值。    3，对于已经存在的Stirng对象，修改它的值，就是重新创建一个对象，然后将新值赋予这个对象    StringBuffer    1，一个类似于 String 的字符串缓冲区，对它的修改不会像String那样重创建对象。    2，使用append()方法修改Stringbuffer的值，使用toString()方法转换为字符串。    Stringbuild    是jdk1.5后用来替换stringBuffer的一个类，大多数时候可以替换StringBuffer。和StringBuffer的区别在于  Stringbuild是一个单线程使用的类，不执行线程同步所以比StringBuffer的速度快，效率高。是线程非安全 的，StringBuffer是线程安全的。单线程的时候，使用StringBuild效率高，多线程的时候，使用StringBuffer  安全；

  1.7  String 的特点，String的常用函数

答：String 是一个被final修饰的类，具有不可变性，不可继承性

 String 的常用函数有：

char charAt(int index)------返回指定索引处的 char 值。

int compareTo(String anotherString)------按字典顺序比较两个字符串。

int compareToIgnoreCase(String str)------不考虑大小写，按字典顺序比较两个字符串。

String concat(String str)-----将指定字符串联到此字符串的结尾。

static String copyValueOf(char[] data)-----返回指定数组中表示该字符序列的字符串。

static String copyValueOf(char[] data, int offset, int count)-----返回指定数组中表示该字符序列的字符串。

boolean endsWith(String suffix)------测试此字符串是否以指定的后缀结束。

boolean equals(Object anObject)------比较此字符串与指定的对象。

boolean equalsIgnoreCase(String anotherString)------将此 String 与另一个 String 进行比较，不考虑大小写。

int indexOf(int ch)------返回指定字符在此字符串中第一次出现处的索引。

int indexOf(int ch, int fromIndex)------从指定的索引开始搜索，返回在此字符串中第一次出现指定字符处的索引。

int indexOf(String str)------返回第一次出现的指定子字符串在此字符串中的索引。

int indexOf(String str, int fromIndex)------从指定的索引处开始，返回第一次出现的指定子字符串在此字符串中的 索引。

String intern()------返回字符串对象的规范化表示形式。

int lastIndexOf(int ch)------返回最后一次出现的指定字符在此字符串中的索引。

int lastIndexOf(int ch, int fromIndex)------从指定的索引处开始进行后向搜索，返回最后一次出现的指定字符在此 字符串中的索引。

int lastIndexOf(String str)------返回在此字符串中最右边出现的指定子字符串的索引。

int lastIndexOf(String str, int fromIndex)------从指定的索引处开始向后搜索，返回在此字符串中最后一次出现的 指定子字符串的索引。

int length()------返回此字符串的长度。

String replace(char oldChar, char newChar)------返回一个新的字符串，它是通过用 newChar 替换此字符串中出 现的所有 oldChar 而生成的。

。

boolean startsWith(String prefix)------测试此字符串是否以指定的前缀开始。

boolean startsWith(String prefix, int toffset)------测试此字符串是否以指定前缀开始，该前缀以指定索引开始。

String substring(int beginIndex)------返回一个新的字符串，它是此字符串的一个子字符串。

String substring(int beginIndex, int endIndex)------返回一个新字符串，它是此字符串的一个子字符串。

char[] toCharArray()------将此字符串转换为一个新的字符数组。

String toLowerCase()------使用默认语言环境的规则将此 String 中的所有字符都转换为小写。

String toLowerCase(Locale locale)------使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。

String toUpperCase()------使用默认语言环境的规则将此 String 中的所有字符都转换为大写。

String trim()------返回字符串的副本，忽略前导空白和尾部空白。

static String valueOf(boolean b)------返回 boolean 参数的字符串表示形式。

static String valueOf(char c)------返回 char 参数的字符串表示形式。

static String valueOf(char[] data)------返回 char 数组参数的字符串表示形式。

static String valueOf(char[] data, int offset, int count)------返回 char 数组参数的特定子数组的字符串表示形式。

static String valueOf(double d)------返回 double 参数的字符串表示形式。

static String valueOf(float f)------返回 float 参数的字符串表示形式。

static String valueOf(int i)------返回 int 参数的字符串表示形式。

static String valueOf(long l)------返回 long 参数的字符串表示形式。

static String valueOf(Object obj)------返回 Object 参数的字符串表示形式。

  1.8  什么多线程，多线程有什么优点和缺点，线程不安全怎么解决

答：

多线程的概念多线程是为了同步完成多项任务，不是为了提高运行效率，而是为了提高资源使用效率来提高 系统的效率。线程是在同一时间需要完成多项任务的时候实现的。

Java多线程的好处是取消了单线程的主循环和轮流检测机制，一个线程可以暂停而不阻止系统其他部分的执 行，这在Java操作交互的、网络环境下的应用时 显得非常重要（比如说在执行一个耗时很长的任务时，可 以让程序执行其他的任务）。

Java 多线程的缺点是线程之间的同步和加锁控制比较麻烦； 一个线程的崩溃可能影响到整个程序的稳定   性； 安全性不好。

1. 继承 Thread  2. 实现 Runnable

区别：1. 单继承，多实现  2. 实现Runnable资源共享

同步：

  1. Synchronized

  2. wait  notify  notifyAll

Sleep：让线程处于一个睡眠状态，并且让出CPU，它是不会释放对象的锁。

    wait：     使一个线程处于等待状态，并且释放所持有对象的lock

           notify：   唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级

   notifyAll：唤醒所有处于等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争

  1.9  字符流和字节流的区别   写一个读取文件的demo

答： 字节流可用于任何类型的对象，包括二进制对象，而字符流只能处理字符或者字符串，纯文本； 2. 字节流提供了处  理任何类型的IO操作的功能，但它不能直接处理Unicode字符，而字符流就可以。如果是读取文本文件的话， 用字符流就比较好一点，如果是音频文件、图片、歌曲，那就用字节流。

字节流读取文件：

Public TestIo{

Public static void main(String [] args)throws IOException{

  String oldpath = "D:\\注册码.txt";

     File file = new File(oldpath);

     InputStream in = new FileInputStream(file);

     byte[] b = new byte[1024];

     int temp = 0;

     int len = 0;

     while ((temp = in.read()) != -1) {

       b[len] = (byte) temp;

       len++;

     }

     in.close();

     System.out.println(new String(b, 0, len));}

}

字符流读取文件：

Public TestIo2{

Public static void main(String [] args)throws IOException{

String oldpath="D:\\注册码.txt";

     File file=new File(oldpath);

     Reader in=new FileReader(file);

     char[] b=new char[1024];

     int temp=0;

     int len=0;

     while((temp=in.read())!=-1){

     b[len]=(char)temp;

     len++;

     }

     in.close();

     System.out.println(new String(b,0,len));

}

}

  2.0  java的运算符有哪些， &和&& 有什么区别

答：运算符主要分为：逻辑运算符、算术运算符、关系运算符。

逻辑运算符主要有&、&&、||、!等常用符；

算术运算符主要有+、-、*、/、++、--、%

关系运算符主要有> 、< 、>= 、<= 、== 、= 、!=等

&和&& 都是表示当运算符两边的表达式的结果都为true时，整个运算结果才为true，否则，只要有一方为false，则结果为false,&&的特点是只要第一个表达式不成立，则不会进入下一个表达式。&则是无论第一个表达式是否成立，都会进入第二个表达式。

2.1 == 和equals的区别

==操作符在八大基本类型比的是值，equals()比的是地址，非八大基本类型 ==操作符比的是内存地址，equals()比的是对象的内容

==操作符专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，只能用==操作符。如果一个变量指向的数据是对象类型的，那么，这时候涉及了两块内存，equals方法是用于比较两个独立对象的内容是否相同，

2.2  你用什么技术解析 xml的，各有什么优缺点

答:有DOM（处理小型文件）,SAX（处理大型文件）,STAX等

DOM:处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文件之前把整个文档装入内存,适合对XML的随机访问SAX:不现于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问

STAX:Streaming API for XML (StAX)

dom (sax) 推式解析   stax(拉式解析)

   1. dom4j  document object model 文档对象模型

   2. sax  simple api for xml   

   3. stax Stream API for XML

   DOM解析： 将xml以树结构的方式一次性加载进内存（功能强大，但不适合大文件），易用，修改方便，但是更占内存。不适应大文件，一般情况下用它即可应付大多数应用

   SAX解析： 基于推模式的事件的方式来解析xml，一个节点触发一个事件，较少占用内存，速度比DOM速度更快，适应大文件（事件触发节点，适应于大文件，但功能没有DOM强大）

   STAX解析：基于拉模式的事件的方式来解析xml,在3种解析方式中速度是最快的，可操作性也是最好的

       * 拉模式与推模式的区别：

         推模式触发事件的名字是固定的，在固定的事件编写我们的代码,不方便控制

         拉模式把触发的事件转化成int类型，根据int类型对应的事件自己编写代码，控制事件比较灵活

2、你在项目中用到了xml技术的哪些方面?如何实现的?

答:用到了数据存贮，信息配置两方面。在做数据交换平台时，将不能数据源的数据组装成XML文件，然后将XML文件压缩打包加密后通过网络传送给接收者，接收解密与解压缩后再同XML文件中还原相关信息进行处理。在做软件配置时，利用XML可以很方便的进行，软件的各种配置参数都存贮在XML文件中。

2.3 XML 和 JSON 数据 各有什么好处  什么情况用xml数据格式，什么情况用json数据格式

JSON 和 XML 优缺点的比较

1.       在可读性方面，JSON和XML的数据可读性基本相同。JSON和XML的可读性可谓不相上下，一边是建议的语法，一边是规范的标签形式，很难分出胜负。

2.       在可扩展性方面，XML天生有很好的扩展性，JSON当然也有，没有什么是XML能扩展，JSON不能的。

3.       在编码难度方面，XML有丰富的编码工具，比如Dom4j、JDom等，JSON也有json.org提供的工具，但是JSON的编码明显比XML容易许多，即使不借助工具也能写出JSON的代码，可是要写好XML就不太容易了。

4.       在解码难度方面，XML的解析得考虑子节点父节点，让人头昏眼花，而JSON的解析难度几乎为0。这一点XML输的真是没话说。

5.       在流行度方面，XML已经被业界广泛的使用，而JSON才刚刚开始，但是在Ajax这个特定的领域，未来的发展一定是XML让位于JSON。到时Ajax应该变成Ajaj(Asynchronous Javascript and JSON)了。

6.       JSON和XML同样拥有丰富的解析手段。

7.       JSON相对于XML来讲，数据的体积小。

8.       JSON与JavaScript的交互更加方便。

9.       JSON对数据的描述性比XML较差。

10.   JSON的速度要远远快于XML。

使用：XML 更适合适合作为配置文件，以及数据存储，存盘文件格式。

（它对数据的表达使得这个数据脱离你程序的上下文仍然存在意义并且可以被解读。）

Json更适合数据的传输。

（JSON 对数据的表达并不需要在数据传输的双方以外仍然具有可解读的意义，只要传输的双方能读懂即可。）

2.4 内存堆和栈的联系，

堆：heap  (对象，数组，this)

栈：stack 局部变量(八大基本类型，形参，引用)

代码区：code segment:代码,  

常量区（常量池，数据区），字符串，栈变量

java的内存分为两类，一类是栈内存，一类是堆内存。栈内存是指程序进入一个方法时，会为这个方法单独分配一块私属存储空间，用于存储这个方法

内部的局部变量，当这个方法结束时，分配给这个方法的栈会释放，这个栈中的变量也将随之释放。

堆与栈作用不同的内存，一般用于存放不放在当前方法栈中的那些数据，例如，使用new创建的对象都放在堆里，所以它不会随着方法的结束而消失。

   方法中的局部变量使用final修饰后，放在堆中，而不是栈中。

2.5java有内存泄露吗?

   内存泄露：有一个对象在程序中已经不再使用，但是无法被垃圾回收站(gc)回收，这种现象就是内存泄露。

经常发生在长生命周期的对象

   持有短生命周期对象的引用就很可能发生内存泄露

2.6说说的java的反射机制？

反射其实就是程序能够自检查自身信息。就像程序会照镜子反光看自己。 在程序中可以检查某个类中的方法属性等信息，并且能够动态调用。 这样可以写出很灵活的程序。 比如要把一个对象中的数据copy到另外一个对象中，规则是属性名相同就copy， 就可以用反射来做，不需要指定每个属性的名字，只要动态从类中取得信息， 再判断属性名是否相同即可。当然应用还有很多。 反射可以结合Java的字节码，使用ASM和cglib等库，还能动态生成类。 hibernate的延迟载入，spring的AOP都是这么实现的。 反射给Java带来了一些动态性。不过虽然很好，但毕竟还是有一定局限性的。另外ASM，cglib使用还是不放便。因此一些纯动态语言现在是一个重要发展趋势，比如ruby，python等，程序很容易动态生成。

2.7java中创建对象的三种方式？

New，反射机制，克隆

2.jsp 和servlet

  2.1 jsp的特点， jsp的标签有哪些，各有什么作用，JSP的九大内置对象

答：

特点：

JSP是基于Java技术，用于创建可支持跨平台及跨WEB服务器的动态网页。

因为JSP在编写表示页面时远远比Servlet简单，并且不需要手工编译(由Servlet容器自动编译)

总结特点：

1、将内容的生成和显示进行分离

2、生成可重用的组件

3、采用标识简化页面开发

4、JSP能提供所有的Servlet功能

5、健壮的存储管理和安全性

6、一次编写，随处运行（JAVA之上）

7、JSP的平台适应性更广

8、简单易学，易理解

       常用标签有：

<jsp:include>、<jsp:forward>、<jsp:param>、<jsp:useBean>、<jsp:setProperty>等

       各标签的作用：

1、JSP：forward  执行页面转向，将请求的处理转发到下一个页面。

2、JSP：param  用于传递参数，必须与其他支持参数的标签一起使用

3、JSP：include  用于动态引入一个JSP页面

4、JSP：plugin 用于下载JavaBean或者Applet到客户端执行

5、JSP：useBean 创建一个Javabean实例

6、JSP：setProperty  设置JavaBean实例的属性值

7、JSP：getProperty  获取JavaBean实例的属性值

JSP共有以下9种基本内置组件（可与ASP的6种内部组件相对应）：

     request主要接收用户的请求，此请求会包含来自GET/POST请求的参数

     response主要把结果响应给客户端，网页传回用户端的回应

     pageContext 网页的属性是在这里管理

     session 与请求有关的会话期

     application servlet上下应用文，一般用来作为网站的计数器的，存放在服务器中的

     out 用来传送回应的输出 ，输出响应信息

     config servlet的构架部件

     page JSP网页本身

     exception 针对错误网页，未捕捉的例外

Jquery的插件：ui ligerUI  EasyUI  jqueryUI

  2.2 servlet的特点，生命周期

答：

特点：servlet是用Java编写的Server端程序，它与协议和平台无关。Servlet运行于Java－enabled Web Server中。    Java Servlet可以动态地扩展Server的能力，并采用请求－响应模式提供Web服务。 Servlet程序在服务器       端运行，  动态地生成Web页面。与传统的CGI和许多其他类似CGI的技术相比，Java Servlet具有更高的     效率，更容易使用，功能更强大，具有更好的可移植性，更节省投资。

生命周期：Servlet的生命周期可以分为四个阶段，即装载类及创建实例阶段、初始化阶段、服务阶段和实例销    毁阶段。

1、装载Servlet：这项操作一般是动态执行的。有些服务器提供了相应的管理功能，可以在启动的时候就装载Servlet并能够初始化特定的Servlet。

2、创建一个Servlet实例。

3、调用Servlet的init()方法。

4、服务：如果容器接收到对此Servlet的请求，那么它调用Servlet的service（）方法。

5、业务：根据页面method请求的类型，进行对doGet或doPost的方法调用，并处理后台业务。

6、销毁：实例被销毁，通过调用Servlet的destory（）方法来销毁Servlet

SERVLET API中forward() 与redirect()的区别？

1.地址栏：

转发：显示的是请求的url

重定向:不是请求的url，是重定向指向的url

2.浏览器发送的请求次数:

转发：1次

重定向：2次

3.能否实现request的数据共享

转发:可以

重定向：不可以

4用法不一样

response.sendRedirect("/web应用/资源 URI");

request.getRequestDispatcher("/资源 URI").forward(request,response);

5当在同一个服务器跳转，尽量使用forward()，更加高效；

当要跳转到另一个服务器上的资源时，必须使用sendRedirect()方法

  2.3 jsp和Servlet有什么联系  Servlet的流程

答：

Jsp和servlet的联系:

JSP是Servlet技术的扩展，本质上是Servlet的简易方式，更强调应用的外表表达。JSP编译后是"类servlet"。 Servlet和JSP最主要的不同点在于，Servlet的应用逻辑是在Java文件中，并且完全从表示层中的HTML里  分离开来。而JSP的情况是Java和HTML可以组合成一个扩展名为.jsp的文件。JSP侧重于视图，Servlet 主要用于控制逻辑。

servlet流程：

 1、客户端发送请求至服务器端。

2、服务器将请求信息发送至Servlet。

3、Servlet生成响应内容并将其传给Server。响应内容动态生成，通常取决于客户端的请求。

　4、服务器将响应返回给客户端。

2.4 request 和 response  后端是如何响应的？

Web服务器接收到客户端的http请求，会针对每一次请求，分别创建一个用于代表请求的request对象、

和代表响应的response对象。

HttpServletRequest封装客户端相关信息，服务器Servlet程序可以通过request对象操作客户端信息

HttpServletResponse封装服务器向客户端发送响应数据信息，Servlet程序通过response对象向客户端发送响应。

request通过post 或者get请求发送http的url进行请求后 台然后台拿到请求进行响应，返回response，（包含转发和重定向）

2.5拦截器和过滤器的使用 有什么不一样？

过滤器是一个程序，它先于与之相关的servlet或JSP页面运行在服务器上。过滤器可附加到一个或多个servlet或JSP页面上，并且可以检查进入这些资源的请求信息。

拦截器是动态拦截Action调用的对象。它提供了一种机制可以使开发者可以定义在一个action执行的前后执行的代码，也可以在一个action执行前阻止其执行。同时也是提供了一种可以提取action中可重用的部分的方式。 

原理：拦截器方法都是通过代理的方式来调用的。

拦截器与过滤器的区别 ：  1. 拦截器是基于java的反射机制的，而过滤器是基于函数回调。 2. 拦截器不依赖与servlet容器，过滤器依赖与servlet容器。  3. 拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用。 4. 拦截器可以访问action上下文、值栈里的对象，而过滤器不能访问。  5. 在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次

2.6过滤器与AOP的区别？

Aop相当于拦截器，它主要是拦截action。

3. Struts1 和Struts2

   3.1 Struts1和Struts2的执行流程，各怎么配置

答：

struts2的执行流程：

Struts2：浏览器—>服务器—>FilterDispathcer（核心控制器）—>Interceptor,实现功能拦截—>调用相应的action—>service—>查询struts.xml文件result相应的jsp—>以http相应方式返回给浏览器

客户端浏览器发出HTTP请求。 

根据web.xml配置，该请求被FilterDispatcher接收。 

根据struts.xml配置，找到需要调用的Action类和方法，并通过IoC方式，将值注入给Aciton。 

Action调用业务逻辑组件处理业务逻辑，这一步包含表单验证。 

Action执行完毕，根据struts.xml中的配置找到对应的返回结果result，并跳转到相应页面。 

返回HTTP响应到客户端浏览器。

Struts1的执行流程：

Struts：浏览器—>服务器—>ActionServlet（总控制器）—>填充ActionForm表单—>调用相应的action—> service—>查询struts-config.xml文件forward相应的jsp—>以http相应方式返回给浏览器

在web应用启动时就会加载初始化ActionServlet,ActionServlet从  struts-config.xml文件中读取配置信息,把它们存 放到各种配置对象  当ActionServlet接收到一个客户请求时,将执行如下流程.  

1、检索和用户请求匹配的ActionMapping实例,如果不存在,就返回请求路径无效信息。

2、如果ActionForm实例存在,就创建一个ActionForm对象,把客户提交的表单数据保存到ActionForm对象中。

3、根据配置信息决定是否需要表单验证.如果需要验证,就调用ActionForm的validate()方法。

4、如果ActionForm的validate()方法返回null或返回一个不包含ActionMessage的ActuibErrors对象, 就表示表单 验证成功。

5、ActionServlet根据ActionMapping所包含的映射信息决定将请求转发给哪个Action,如果相应的 Action实例不 存在,就先创建这个实例,然后调用Action的execute()方法。

6、Action的execute()方法返回一个ActionForward对象,ActionServlet在把客户请求转发给 ActionForward对象指 向的JSP组件。

7、ActionForward对象指向JSP组件生成动态网页,返回给客户。

Struts2的简单配置：

Struts.xml:

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE struts PUBLIC

  "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"

  "/WEB-INF/struts-2.0.dtd">

<struts>

  <!-- 默认Struts基础配置信息 , 也可按模块基础配置信息 ，使用include引入-->

  <include file="struts-default.xml"></include>

<package name="default" extends="struts-default" namespace="">

      <action name="hello_*" class="com.struts.HelloAction" method="{1}">

       <result name="success">/hello.jsp</result>

       <result name="error">/error.jsp</result>

</package>

        </struts>

Web.xml:

<filter>

     <filter-name>struts2</filter-name>

     <filter-class>

       org.apache.struts2.dispatcher.FilterDispatcher

     </filter-class>

  </filter>

  <filter-mapping>

     <filter-name>struts2</filter-name>

     <url-pattern>/*</url-pattern>

</filter-mapping>

Struts1的配置：

struts-config.xml:

 <struts-config>

    <!-- 配置所有表单Form类 -->

    <form-beans >

       <form-bean name="RegisterForm" type="com.ts.struts.form.RegisterForm"/>

       <form-bean name="LogonForm" type="com.ts.struts.form.LogonForm" />

    </form-beans>

    <!-- 配置所有页面请求Action类 -->

    <action-mappings>

     <!-- Action 处理业务 -->

       <action

          attribute="userForm"  input="/WEB-INF/register.jsp" path="/register" scope="request"

         type="com.ts.struts.action.RegisterAction" name="UserForm" validate="false">

          <forward name="registerok" path="/WEB-INF/registerok.jsp"></forward>

          <forward name="registerfail" path="/WEB-INF/registerfail.jsp"></forward>       

       </action>

       <!-- DispatchAction 处理业务 -->

       <action path="/register" type="com.ts.struts.action.MenusAction" name="RegisterForm"                parameter="method">

          <forward name="success" path="/success.jsp"></forward>

          <forward name="failure" path="/failure.jsp"></forward>

          <forward name="success2" path="/success2.jsp">nullnull