Java初级程序员面试必备的基础知识总结

admin

java基础

• 简述Java的基本历史
  

java起源于SUN公司的一个GREEN的项目，其原先目的是：为家用消费电子产品发送一个信息的分布式代码系统，通过发送信息控制电视机、冰箱等

' O+ g( D$ n, d" N

• 简单写出Java特点，写出5个以上，越多越好
  + ]6 i7 ^6 ^& P. \8 d6 \; s! X

简单的、面向对象的、分布式的、安全的、稳定的、与平台无关的、可解释的、多线的、动态的语言。

7 G5 L$ p, C( C5 g# p

• 什么是Java?
  7 M3 s% G& t' w& q% B# `

JAVA：一种编程语言

一种开发环境

一种应用环境

一种部署环境

8 N: P4 w7 u. Q2 |0 t

• 请写出Java的版本分类，以及每种版本的应用方向
  

三种版本：

JME：是面向内存有限的移动终端. 为消费性产品设计的；

JSE： 是SUN公司针对桌面开发和低端商务计算方案开发的版本。为笔记本电脑、PC机设计的；

JEE： 是一种利用JAVA 2平台来简化企业解决方案的开发、部署和管理相关的复杂问题的体系结构。 为企业级的、服务器端的高端应用而设计的；

• 描述Java技术的主要特性
  

java虚拟机

垃圾回收

代码安全性

2 g( q- g' }% `; |! E! z/ r

• 描述 Java虚拟机的功能
  - b' V# y0 B9 O  A+ R, N) o

（1）通过 ClassLoader 寻找和装载 class 文件

（2）解释字节码成为指令并执行，提供 class 文件的运行环境

（3）进行运行期间垃圾回收

（4）提供与硬件交互的平台

+ Y" {7 G- \1 W# U- Y" {& x9 H

• 简述Java代码安全性
  ; k, a; @1 Y0 W

（1）编译时的错误检验

（2）类装载检查，把本机上的类和网络资源类相分离，在调入类的时候进行检查，因而可以限制任何“特洛伊木马“的应用
% A8 [- f) t- m" A* ^

（3）字节码校验

（4）沙箱机制，限定访问权限

• 描述Java垃圾回收机制
  + v! c4 V" i$ {1 \1 K( U5 U

Java 编程语言解除了程序员释放内存的责任。它可提供一种系统级线程以跟踪每一次内存的分配情况。在 Java 虚拟机的空闲周期，垃圾收集线程检查并释放那些可被释放的内存。垃圾收集在 Java 技术程序的生命周期中自动进行，它解除了释放内存的要求，这样能够有效避免内存漏洞和内存泄露（内存泄露就是程序运行期间，所占用的内存一直往上涨， 很容易造成系统资源耗尽而降低性能或崩溃 。
8 Q: X9 B7 Q4 t' a: a) g/ K

垃圾回收有以下特点：

（1）垃圾回收是一个自动的系统行为，程序员不能控制垃圾回收的功能和行为。

（2）有一些跟垃圾回收相关的方法，比如：System.gc( ) ,调用这些方法，仅仅是在通知垃圾回收程序，至于垃圾回收程序运不运行，什么时候运行，都是无法控制的。

（3）程序员可以通过设置对象为 null，来标示某个对象不再被需要了， 这只是表示这个对象可以被回收了，并不是马上被回收。

• 简述Java代码的运行过程
  6 Q0 {' w: G- e+ u0 e# P$ B6 B

（1）加载代码 通过类装载器装载CLASS文件

（2）校验代码 由字节码校验

（3）执行代码 由解释器将字节码转换成机器码

• 简述如何搭建Java开发环境
  0 R: C; u, k4 \6 Q2 ?

首先下载安装JDK 然后配置环境

（1）配置PATH，

（2）配置CLASSPATH

（3）配置JAVA_HOME

' S7 P* N3 u- V; P+ |' h

• 简述classpath，path，JAVA_HOME的意义和配置方法
  

path 操作系统运行环境的路径

classpath JAVA运行应用程序时所需要的类包的路径

JAVA_HOME 供需要运行JAVA的程序使用

* H4 ~) V% L2 b# ^4 |1 w+ P4 B5 n' `

• 请描述：一个完整的Java文件的代码分几个部分，每部分都起什么作用，大致的写法
  

package 当前类所在位置

import 当前类运行时所需要的包或类

public class 类名 {

属性定义;

方法定义:

构造方法定义;

public static void main(String args []) 例外{ 程序入口

语句;

}

}

//注释

• Java代码的注释有几种？分别举例说明
  

（1） // 单行注解

（2） /* */ 块注释

（3） /* *

* 文档注释

*/

5 _% c5 S  E" t' E

• 什么是Java代码的语句，什么是Java代码的块，举例说明
  # b# a0 X& z* S- i, ^+ E5 j9 L

语句 是一行以分号终止的代码,例：int a;

块 是以{ }为边界的一些语句的集合 例：public void tt( ){}

• 什么是标示符？
  标识符：是赋予变量、类、方法的名称。
  

• 标示符定义的规则？
  9 \  o2 u8 k, a1 T7 P
  • 首字母只能以字母、下划线、$开头,其后可以跟字母’下划线、$和数字配置CLASSPATH
  • 首字母小写中间用大写字母隔开
  • 标识符具有一定的含义
    * X. v* M- c; t9 d: i' V! A' t4 l
• 什么是关键字？
  关键字就是编程语言与机器语言的编码约定
  

• true、false、null、sizeof、goto、const那些是Java关键字
  " V4 {* a1 \& ~true 、false 、null 为JAVA的关键字
• Java的基本数据类型有几种？分别是？
  short int long boolean float double char byte
  9 U- o: w8 Q6 y2 N& T* D$ a

• 请写出每种基本类型的默认值？取值范围？分别给出一个定义的例子
  ( h1 s8 A9 M: b* k: k2 ^' e0 \* \9 k
  默认值         取值范围 示例
  
  4 W5 f! N0 e! _+ J$ L$ q) [

字节型 ： 0 -2^7—-2^7-1 byte b=10;

字符型 ： ‘ ′ 0—-2^16-1         char c=’c’ ;

short : 0 -2^15—-2^15-1 short s=10;

int : 0 -2^31—-2^31-1 int i=10;

long : 0 -2^63—-2^63-1     long o=10L;

float : 0.0f -2^31—-2^31-1 float f=10.0F

double : 0.0d -2^63—-2^63-1 double d=10.0;

boolean: false truealse boolean flag=true;

3 C: A" T& h2 j9 n5 P

• 在基本类型中，如果不明确指定，整数型的默认是什么类型？带小数的默认是什么类型？
  

整数类型 默认为 int

带小数的默认为 double

• 如何定义float类型和long型
  & Y  y' W$ z4 Q% [7 h

float f = 1.2f

long l = 1.2L

• 什么是变量？
  

变量是用来引用一块内存区域或一个值，用标识符来表示，可以通过操作变量来操作变量所对应的内存区域或值块的值。

' T: F7 j3 e: P

• 变量的定义规则？
  
  • 以字母、$、下划线开头，其后可以跟字母、下划线、$和数字；
  • 首字母小写，中间单词用大写字母隔开；
  • 名称具有一定含义；
    1 ^7 I# x/ ?5 t, v, o6 j+ g

% y) M# P; b" f4 N! Q9 d* i

• 请写出Java编码约定中对下列部分的要求：类、属性、方法、包、文件名、变量、常量、控制结构、语句行、注释
  % l2 g" {- x8 _- n# K' U. v

类： 一个类文件中类名要和文件名相同，类名一定要以大写字母开头，单词之间用大写字母分隔

属性： 属性名首字母小写，中间用大写字母隔开。

方法： 方法名首字母小写，中间用大写字母隔开。

包： 引用包必须写在类文件的开头,有且只能有一个包，全部用小写字母。

控制结构：当语句是控制结构的一部分时，即使是单个语句，也应使用大括号将语句封闭。

语句行：每行只写一个语句，并使用四个缩进的空格，使代码更易读，注意用分号结束。

注释： 用注释来说明那些不明显代码的段落。

常量： 常量名一般用大写字母，单词之间用下划线分隔，一旦赋值不允许修改。

8 @* W% I; [, o3 `- r* ]! H. G

• 什么是Javadoc?
  

按照一定格式生成程序的文档的工具。

• 什么是引用类型？
  用户定义类型, 它可引用类和数组。
  

除去基本数据类型的其他类型都是引用数据类型。

• 什么是按值传递？什么是按引用传递？
  ; g5 j0 M8 U3 C1 u/ D$ U( H

按值传递：就是将该值的副本传过去（基本数据类型+String类型的传递，就是按值传递）

按引用传递：就是将值的内存地址传过去（除基本数据类型+String以外类型的传递，就是引用传递）

1 C  {! o8 Z' @4 L- X3 ?/ i

• 如何创建一个新对象？如何使用对象中的属性和方法？
  * c$ w1 x+ X2 c7 i% Q$ A

使用new 关键字来创建一个新的对象；

通过对象的实例用”.“(点)来调用对象中的属性和方法；

静态的方法和属性，也可以直接用类名”.“（点）来调用；

• 简述new关键字所做的工作
  new 创建一个对象，并为对象分配一块内存。
  

, X+ h/ j7 o$ a7 F6 c" p

• 简述”=” 和”= =”的功能和区别
  3 V. W) _# U; N- U2 ^

“=” 赋值,

“= =”当比较基本数据类型的时候，判断前后两个值是否相等；

当比较引用数据类型的时候，判断= =前后两个值的内存地址是否相等；

区别：

= ：为赋值表达式

= = ：为逻辑表达式

• 什么是实例变量？什么是局部变量？什么是类变量？什么是final变量？
  & X" i4 h: X/ v' F2 `0 u! X. j/ M

实例变量：     类中定义的变量，即类成员变量，如果没有初始化，会有默认值；

局部变量：     在方法中定义的变量，必须初始化；

类变量：     用static修饰的属性；

final变量：     用final 修饰的变量，

• 简述上述各种变量的定义规则和使用规则？
  

实例变量：    不需要static关键字来声明，需要类的实例（对象）调用（用”.“）；

类变量：        用static修饰，可以用类名调用，也可以用类的实例调用；

局部变量：    在方法内任意定义变量即为局部变量；

final变量：    一旦赋值，不可以再修改的变量；

final属性只允许赋值一次，且只能通过构造方法赋值，定义后也就是一个常量；

final修饰的变量，只允许赋值一次

9 f! z$ o: o' n* Q! Z- @

• a++和++a的区别？
  ! z" E5 F& \/ p! i3 W

a++ ： 先使用，后加1

++a ： 先加1，后使用

  O( L3 W) }9 D

• 请描述instanceof、?:、&、&&各自的功能
  ; E! [% f6 n' Q4 V7 M
  instanceof ：用来判断某个实例变量是否属于某种类的类型。
  
  - Y$ a+ _, M( o/ @0 {& U- B. r

? : 三目运算符：

表达式1?表达式2:表达式3

如果表达式1为true，执行表达式2，否则执行表达式3

&： 位运算：按位与 |

&&： 逻辑运算：逻辑与

• 请描述>>、<<、>>>的功能
  ; R/ o! m5 o  T' `

10>>4 ：算术或符号右移位运算符

<< ：算术或符号左移位运算符

>>> ：逻辑或无符号右移位运算符

• 请描述什么是强制类型转换？什么是自动类型转换？什么是向上造型？并分别举例说明
  
  强制类型转换：在一个类型前面加( )，来强制转换
  
  

long l = 9L;

int i = (int)l;

自动类型转换：

int i = 5;

String str = “”+i;

向上造型：把范围小的造型为范围大的类型：

int i = 2;

long l = i;

, J: D% Z& R' I, ?" r; n

• 请写出完整的if条件控制语句的结构
  

if(布尔表达式){

语句

}else{

语句

}

. x+ L9 W3 ^- W6 R; G: t2 [

• 请写出完整的switch语句的结构
  
  switch(字符){
  
  

case 字符: 语句

break;

case 字符: 语句

break;

default:语句

}

• 请写出完整的for语句的结构
  

for(初始语句;条件语句;步长){

}

• 请写出完整的while语句的结构
  

while(boolean语句){

}

% z' y! [/ _3 s) L6 j

• 请写出完整的do while语句的结构
  7 T$ V1 s. q5 ]  G

do{

}while(boolean语句);

( ], |  |7 j5 m' b

• 请描述break 和 continue的功能和用法
  6 G& R+ l* S  S6 C  M& t9 T6 w

break：终止（跳出）最近的循环

continue：跳出本次循环，执行下一次循环

• 定义一个一维的int数组，先创建它，并初始化它，给它赋值，然后输出其中的一个值
  

public class Arr{

public static void main(String args[]){

int a[] = new int[5];

a={1,2,3,4,5};//错误 , 只能在初始化时这样做

a[0]=1;

a[1]=2;

System.out.println(a[0]);

}

}

• 定义一个一维的A类型数组，直接定义并赋值，然后输出其中的一个值
  ! }- K# S& S  a+ X4 r4 {8 F8 |4 b

public class A{

public static int i;

public static void main(String args[]){

A aa = new A( );

A bb = new A( );

A a[] = {aa,bb};

a[0].i=2;

System.out.println(a[0]);

}

}

• 把上面的数组改成2维的数组
  ; Y% F$ v/ q: M7 a6 h. ^

public class A{

public static int i;

public static void main(String args[]){

A a[ ][ ] = new A[5][5];

a[0][0].i=2;

System.out.println(a[0][0]);

}

}

• 举例说明数组拷贝方法的使用：arraycopy方法
  
  public class A{
  
  

public static void main(String args[]){

int a[] = new int[5];

int b[] = new int[5];

System.arraycopy(a[5],0,b[5],0,a.length)

System.out.println(b[0][0]);

}

}

• 什么是构造和析构方法？功能是？
  5 Z0 {% M' G  n2 m' Q* [; B* L3 H

构造方法：每个类至少有一个构造方法，类初始化时调用的方法

1．方法名和类名相同

2．无返回值类型

格式：访问权限 类名(参数列表) {}；

1．自己定义构造后，就没有默认的构造方法

2．无构造方法时，默认为空参的构造方法(无参数,方法体为空)
+ l& u: b9 Q- z. R! V4 F析构方法：finalize

类销毁时，自动调用方法

当对象在内存中被删除时,自动调用该方法

在此方法中可以写回收对象内部的动态空间的代码

• 简述Java的访问修饰符类型？分别有什么功能？
  + ?9 w+ c- I0 ^2 ~9 m' a

public 公开的，任何一个类都有可以访问

protected 同包同类,只可被它的子类访问

default 只能被同一个包中类访问

private 私有的，只能在本类中被访问

0 d1 h% [8 g5 y0 d; U5 Y

# C' R5 C9 Y2 ~" O$ U




( m% Y; H: `/ k

1 ]/ T) r% P1 y. M0 s, a1 `

• 分别说明：在类上、在属性上、在方法上能使用哪些访问修饰符
  

在类上：public default final

在方法上： 访问权限：public protected private default

方法修饰符：static

final

返回类型：void

在属性上：public protected private default

static

final

• 简述什么是包？包的功能
  

包：对所定义的多个JAVA类进行分组，将多个功能相关的类定义到一个包(文件)中。

功能：1.易于查找和使用适当的类

2.包不止包含类和接口,还可以包含其它包,形成层次的包空间

3.有助于避免命名冲突

8 u: @" d0 G5 \" Q

• 请写出5个以上的JDK中的包，以及他们的基本功能
  

java.awt： 包含构成抽象窗口工具集的多个类，用来构建和管理应用程序的图形用户界面

java.lang： 提供java编成语言的程序设计的基础类

java.io：　 包含提供多种输出输入功能的类，

java.net：　 包含执行与网络有关的类，如URL，SCOKET，SEVERSOCKET，

java.applet： 包含java小应用程序的类

java.util：　 包含一些实用性的类

4 G, M: u5 Z& B* z7 C& E

• 什么是包装类？Java中都有哪些包装类
  在JDK中针对各种基本类型分别定义相应的引用类型 ————–称为封装类
  ; H6 E/ I0 t% J

Boolean Byte Short Integer Long Float Double Character

• OOP（面向对象）语言的三大特征是？
  ; }, p; _/ A$ A) ]1 e: @/ ~封装性，继承性，多态性
  / j: p$ q# P- r- _: X. d

( J( ?0 K9 i8 v4 u

• 分别表述类的三大特性及其他们的功能
  

封装：隐藏类的实现细节、迫使用户去使用一个接口去访问数据、使代码更好维护

继承：子类可以直接继承使用父类的方法，程序员只需要做的是定义额外特征或规定将适用的变化

多态性：同一个行为具有多个不同表现形式或形态的能力

• 如何实现继承？继承的规则？
  

public class A extends B{

}

• 单继承性
• 构造方法不能继承
• super引用父类，调用父类的属性，方法
• 当子类中出现与父类的方法名，返回类型，参数列表相同的方法时要覆盖此方法
  0 [' M8 X2 Z8 f) t- x

• 简述this和super的功能和用法
  

this ：

• 能访问除构造方法以外所有的属性、方法，通过this.　来调用方法和属性
• 不可以在静态方法中使用，
• 在调用其它构造方法时，必须放在该构造方法的第一行
• 在构造方法中使用this(参数列表)，相当于调用本类的其它构造方法，它必须作为构造方法的第一句
  

) D7 U' }+ X3 s' P* _! V/ ^$ Z

super ：访问父类

• super. 点取父类中被子类隐藏的方法和属性，
• 通过 super(参数列表) 来调用父类的属性和方法，在调用父类的构造方法时必须放在子类构造方法里的第一行；
  

• 如何确定在多态的调用中，究竟是调用的那个方法？
  new的是哪一个类就是调用的哪个类的方法。
  / z! N' U  p7 ^7 ~1 U, `; N$ o: y; j

; X& B: ]/ y) Q0 O

• 请描述方法定义的完整的语法结构
  , i- g! Z0 `6 Y' P; [  e6 x# ]

权限修饰符 修饰符 返回类型 方法名(参数) 例外{

方法体;

}

7 \7 m) N/ L4 O  H9 R' a

• 什么是重载？
  在一个类中出现方法名相同，但参数列表不同时，这种情况就是重载。
  9 u0 c' G8 A! {) x9 Q. l1 v

) p% h2 n! y; m/ K" l1 r" w

• 简述重载的规则
  ) P% u' b2 L! e: S+ P8 q
  • 方法名称必须相同；
  • 参数列表必须不同（个数不同，或类型不同，或参数排列顺序不同）；
  • 与返回类型无关；
    
• 什么是方法的覆盖？什么情况下出现？
  ; m" d7 k; k  i& n

方法覆盖：

子类可以修改从父类继承过来的行为,也就是说子类可以创建一个与父类方法有不同功能的方法，但具有相同的：名称、返回类型名和参数列表。

在父子类的情况下出现时。

• 方法覆盖的规则？
  
  • 方法名要和父类中被覆盖的方法名相同,返回类型相同，参数列表相同。
  • 访问权限要大于等于被覆盖方法的权限。
  • 例外列表要小于等于被覆盖方法的例外列表。
    5 _- ]+ N; f  U, g: p# P, Z! E) ~

• static修饰符的功能是？可以用在什么地方？怎么访问？
  ; x/ l, ~. J% K
  static 修饰符功能:
  
  
  • 共用一块内存区域，也就是用static修饰的变量或成员方法对所有类的实例都是相同的
  • 静态成员方法和静态变量的优点在于他们能在没有创建类的任何一个实例的情况下被引用。
  • 可以用在方法或属性上
    * K% ~8 k8 ?  f0 C4 R, |; {

访问方式：

• 直接使用类名调用
• new 一个实例，用实例调用
  6 z2 h9 o5 [! w7 V+ M

• static的基本规则
  
  • 类中的静态方法只可以调用静态的属性和方法，不允许调用非静态的属性和方法。
  • 静态变量为类变量，可以用类名直接调用静态的属性和方法。
  • 静态方法中不允许出现this和super
  • 构造方法不允许声明static
  • 非静态变量为实例变量，通过实例调用
  • 静态方法不能被非静态方法覆盖
    + e% ~" ~. U( C' c

: a% [1 X% K; P! o, n9 @6 z

• final修饰符的功能是？可以用在什么地方？
  6 Z" d; l% h0 t, w. \

功能：final标记所有通用的功能,不能随意更改

可以用在类、属性和方法上

1 C8 G" X0 C# j9 [8 T2 L9 ^5 G

• final的基本规则
  
  • final修饰的类不能被继承
  • final修饰的成员变量只允许赋值一次，且只能通过构造方法里赋值。
  • final修饰的局部变量即为常量，只能赋值一次。
  • final修饰的方法不允许被子类覆盖。
    

, y# e$ l7 K0 i! l# p. o
5 B  c% u, }1 q! Z* _, b
7 V+ p6 ], N4 f8 d, Y" n

• 什么是抽象方法，什么是抽象类
  ) X' z# L6 J% m! J8 r+ ?# Y5 _3 _

用abstract修饰的方法，只有方法的声明，而没有方法的实现，就叫抽象方法。

用abstract修饰的类，就叫抽象类。

9 x3 f+ e- Y& V

• 抽象类的规则
  
  • 抽象类内部可以没有抽象方法
  • 必须用abstract修饰
  • 不能够直接使用抽象类，必须通过子类继承并且实现
  • 抽象方法不允许被private修饰
    

8 c( ?6 C6 h  \5 s* v) h  W( j

• 什么情况下使用抽象类
  . Z& @0 C% `8 u3 H( z
  • 当一个类的一个或多个方法是抽象方法时；
  • 当类是一个抽象类的子类，并且不能为任何抽象方法提供任何实现细节或方法体时；
  • 当一个类实现一个接口，并且不能为任何抽象方法提供实现细节或方法体时；
      `* E& r) c' A4 e1 w1 C. G6 w' a

# G. o. R; D3 c3 w% p1 Y: [

• equals方法和”= =”的功能和区别
  ' O- z* Q# B  r2 G

功能：判断对象是否相等

区别：

equals方法比较的是对象的值

= =:比较的是对象值的内存地址，对基本数据类型来说= =比较的是数值

9 e/ X# Q5 U/ Q+ I1 b* D( h# i

• toString方法的功能和基本写法
  5 @$ D# ?4 l1 D3 z

返回一个String类型

public String toString(){

return “”;

}

• String的方法的功能和基本使用方法，请描述5个以上
  

substring(参数1,参数2); 功能:取字符串中参数1到参数2的的所有字符; “String”.subString(0,1);

replace(参数1,参数2); 功能:用参数1中的值替换字符串中所有参数2的值 “String”.replace(ing,tt);

equals( ); 功能:判断两个字符串是否相等 “String”.equals(“tt”);

trim( ); 　 功能:去掉字符串两边的空格 “String”.trim();

indexof( ); 功能:查找字符串中参数所在位置,并返回字符串第一个出该参数的下标

“String”.indexOf(“ing”);

split( ); 功能:根据参数分割该字符串 “String”.split(“-”);

% X& ^. ~% A$ v. D! ?4 e9 K

• 为什么使用StringBuffer类？有什么功能和优点？
  
  –只创建一个对象
  
  

–StringBuffer 对象的内容是可以被修改的

–除了字符的长度之外，还有容量的概念

–通过动态改变容量的大小，加速字符管理

6 S# I  T$ g+ ?* C; c9 C
8 E; Q+ F! n% w! y

• 举例说明如何使用StringBuffer
  ' d. w4 s8 P4 B

StringBuffer sb = new StringBuffer();

sb.append(“aaa”);

* K6 q- r& M0 Y% l9 r! C0 m

• 如何使用Java读写系统属性？
  8 S& m9 J4 g3 v: \读：
  
  8 X6 p8 c3 g! P5 M* A

Properties props = System.getProperties();
, b  e, T4 B& a! x+ p4 }2 O

Enumeration prop_names = props.propertyNames();

while (prop_names.hasMoreElements()) {

String prop_name = (String) prop_names.nextElement();
+ }' y( M+ K, x$ C( W

String property = props.getProperty(prop_name);

System.out.println(“Property ‘” + prop_name + “‘ is ‘”+ property + “‘”);

}

    写：

System.setProperties(props);
7 r& f$ }+ C. |) e+ N& a

& D6 u* ^% C, L; P3 j* q* T9 i; Q

• 简述properties文件的结构和基本用法
  
  结构：扩展名为properties的文件，内容为key、value的映射，例如”a=2″
  
  

用法：

public class Test {

public static void main(String args[]) {
# _% k: C3 \: K  b' x

try {

String name = “test.properties”;
8 D; a0 i. S$ r0 v  s! a8 j

InputStream in = new BufferedInputStream(new FileInputStream(name));
$ I# r1 A' E% {2 H% S8 _

Properties p = new Properties();

p.load(in);

System.out.println(“a的值==” + p.getProperty(“a”));

} catch (Exception err) {

err.printStackTrace();

}

}

}

• 什么是接口？接口的定义规则？
  

接口是抽象方法和常量值的定义的集合。从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。
7 O! e7 i8 C6 {' W3 ?, m$ b8 C. o7 A

public interface Tt {

public void outPut( );

public int tt( );

}

+ v9 D$ m  y$ n4 Q8 h! O: g

• 接口的作用？为什么使用接口？
  ; M+ T( J9 M7 f2 E
  多重继承
  
  $ Y  q7 x2 Y. l/ Z3 H

封装、隔离

功能,实现的分离

多态

便于后期维护

接口是可插入性的保证。

1 M  o) ^5 x) ^7 l9 e: ^5 e

• 什么是多重接口
  就是一个类实现多个接口
  

$ S' u* C7 ?  B0 }1 s

• 描述接口的基本思想？
  

封装　隔离

接口及相关机制的最基本作用在于：通过接口可以实现不相关类的相同行为，

而不需考虑这些类之间的层次关系。

    根据接口可以了解对象的交互界面，而不需了解对象所属的类。

面向对象程序设计讲究”提高内聚，降低耦合”。

• 如何在代码中使用接口？
  ' F/ Z3 U0 U' o& F; e- w8 s

public class MyCast implements Tt{

public void outPut( ){}

public int tt( ){

return 0;

}

}

• 举例说明如何把接口当作类型使用
  

public interface Animal(){

public void tt( );

}

public class Dog implements Animal{

public void tt ( ){}

}

& o: ?* _4 t  E5 Z$ E6 O

Animal ani = new Dog();

• 如何选择接口和抽象类？为什么？
  2 Z. g) ]% W: [, |' p# k# M# @- ~优先选用接口，尽量少用抽象类
  

在下列情况下选择抽象类：需要定义子类的行为，又要为子类提供共性的功能。

0 n2 t2 D8 w$ \6 Q

• 什么是异常，异常的分类？
  程序中导致程序中断的一些情况叫做异常，一般程序员可以处理。
  , {6 b3 B- z2 K( @异常分为运行时异常和非运行时异常（一般异常）
  / U* ]0 h. e+ b# H3 A# `运行时异常是指因设计或实现方式不当导致的问题。也可以说，是程序员的原因导致的，本来可以避免发生的情况。例如：BufferOverflowException, ClassCastException，IndexOutOfBoundsException，ArithmeticException。出现这些异常的代码不需要try块包围。
  非运行时异常是指除运行时异常以外所有的异常，出现这些异常的代码必须用try块包围。例如：FileNotFoundException,EOFException,
  

• 简述处理异常的两种方式？
  抛出（throws）和catch语句处理
    l8 ^8 @% o( w" S+ Q% G3 Z' F

• 简述try块的功能和规则
  

try块内部一般写一些编程人员认为可能会出现异常的代码,使程序运行时不会因为出现异常而中断。

/ {0 `/ l7 @9 c$ v  n

• 简述catch块的功能和规则
  

功能：可以截获所声明的异常，并在语句块内对其进行处理

规则：catch(Exeption e){

e.printStackTrace( );

     }

  J8 j  R  ], w  ]3 K' K( A

• 简述finally块的功能和规则
  

finally块一般写一些不论是否发生异常都必须执行一次的代码

例如关闭与数据库的连接等

8 {$ M# O: C% U$ Y) \

• 简述throw和throws的功能和使用方法
  6 N( s7 j$ f( p; r$ z

throw 指编程人员主动抛出一个异常

throw new NullPointerExeption( );

throws指程序遇到异常情况自动的被动抛出一个异常

    public void test( ) throws Exeption{}

7 n. ?6 p" t% f4 _3 A% F: z* O) m- R. \5 C. g

• 异常的分类？
  ( X' F  j! x6 G" c% z* J1 R# z: G/ r

错误（Error）： JVM 系统内部错误、资源耗尽等严重情况，程序员不可控制

例外（Exception）：其它因编程错误或偶然的外在因素导致的一般性问题，程序可以控制

• 什么是预定义异常
  

java程序中预先定义好的异常叫做预定义异常

• 简述自定义异常的规则
  % M) E* J) P/ L8 F  D+ U4 g4 H

写一个类继承Exception

用户自定义异常通常属Exception范畴，依据惯例，应以Exception结尾，应该由人工创建并抛出。

• 什么是断言？
  8 @/ z( r- s" C! d% Z

用来证明和测试程序的假设。

• 如何使用断言？举例说明
  - x- t: C; d8 N* ~" h

一种是assert<<布尔表达式>>；另一种是assert<<布尔表达式>>：<<细节描述>>。

assert a= =10 : “这里a等于10″;

6 N+ S& P- |0 t* Z8 @

admin

其他开发工具和技术
Ant
Ant是基于java的批处理工具
! ^8 s* R/ Y- ^8 G6 }) ]
% h$ c0 X0 D$ w% v& d/ j8 W一、配置ant的运行环境
* s2 v" X2 @9 V, z1 j* L
. ^8 K9 G& R! t( a* @+ R: \( G1.将ant的bin目录添加到path中

2.配置JAVA_HOME
  H$ o3 ~7 g$ f4 ]; y
# B& O0 Y0 y' {% Y9 D2 J) W3.配置ANT_HOME

3 j" Z' z4 W3 [2 ~二、配制build.xml文件，该文件放在应用程序的根目录下
) z2 A, T$ T3 n
% `& n' Y1 q' _( y编译java文件
' m! ?) O7 k' ?3 A& R
执行java文件

/ W' M2 u  ~1 e' j6 ]% {copy

1 q% x! M) N( J0 k删除

2 U% m, r3 m  y2 N# g1 h& r! W# A* m8 S打jar包

# a+ O, x! c' B$ g2 _# z根据注解生成配置文件

Xdoclet
9 P) \! H, _3 M4 Y通过注释生成一系列文件的工具（txt、xml、java、html等）

xdoclet本质是摸板技术+字符串的替换
6 \. j6 a/ I+ N% C. P) m6 h
9 \# ~1 I" H" k- y1.在java文件中写符合要求的注释（将hbm.xml文件的内容搬到java文件中去写）
4 m) v5 P  D; x- q, p
  J3 S+ O5 N! n! H- ^5 y1.1 在类的上面 写与表的对应

1.2 将每一个属性的注释都写到get方法的上面
& u' e+ ~5 U' N# r4 r9 I: p; V- }7 a
2.在ant中引入相应的task来驱动xdoclet

# }3 Q9 s4 J# e- N3 O5 z
1 l- `. G8 U- y# B/ @8 Q
log4j日志管理
# s6 {2 e, I, E3 x+ j1、是什么？

在开发期间用来测试、对整个日志信息进行管理的工具
5 x: j$ H$ f/ m! P6 h
2、功能

( h6 M/ b4 u& U5 l& n9 v+ E1.控制输出的目的地

2. 控制输出的格式

  b; O2 Z; [4 H% f% J3. 控制输出的级别
4 Q% A" A: E" s, P
/ [- ?+ X5 @% S5 m" b' n" L3、日志的级别
( D# o5 c3 G; C3 H- x+ G2 ?) N
% W* q9 ^6 ~# W5 S& ~% h1. debug 调试

( Q. y3 K1 O. E; M: Y3 A2. info 给用户的提示信息
  Y8 \4 B: Z( u- r, b
2 R# G- @7 m( `' R' \3. warn 给用户的警告信息
5 c) E( ~5 j  F: g2 S* G
. R3 [( g4 {# N4 T/ G4.error 给程序员用来调试
4 O/ Y) M$ X6 D' G/ X- P" O
Debug—-〉info—-〉warn——–〉error

6 ^0 `7 T; Z* V, W+ S4、配置
) l; p9 P8 e* U0 ]) b
1.配置级别

2.输入源 （控制台和文件）

3.可以进行分包控制

1 Y; W4 `' A0 W: X: v0 KLog4f.logger.包结构 = 级别
/ N9 w5 M* c* h
5、使用
6 Y1 Z, A0 x! F' Y( Z) z* _
Logger log=Logger.getLogger(Test.class);

  ]4 A5 m6 u) ]) v6 F& P( g    public
void t3(){
* @# _/ I( R7 o0 c- j
        log.debug(“this is debug”);
; ]2 O0 l6 o3 s- f7 M# X; M& q
4 x0 b" z7 P$ G; k9 A+ s( x        log.info(“this is info”);

        log.warn(“this is warn “);

        log.error(“this is error”);

2 ]4 }# L. S- y! F    }

Junit
6 W2 d% \  M5 C) T' v8 n1.是什么？

单元测试的框架

+ n7 [; W  N# ^- A/ |$ Q( a1 h2.怎么做？

1 `9 {3 L. V1 v% A/ r6 y写一个类继承TestCase
4 w- n1 u6 N9 a- V, A5 o1 ~9 Y7 M& q
测试的方法一般都以test开头并且没有参数
3 q( x8 q6 i7 K4 d
在测试方法前执行的方法public void setUp( )
7 `% b9 F; S. ?; ~& g: D/ {9 P
5 L6 ?8 _3 }0 Q0 ?9 n) e% m4 d在测试方法后执行的方法public void tearDown( )
3 b2 `8 w0 n: L! b
error和故障的区别
. q: `/ F5 i* k" @9 I7 a( D
; ^0 o% J8 t/ t2 terror ：代码有问题

) u2 x" {) L3 ~& a故障 ：逻辑有问题与祈望的值不相符合
- v6 g' I, C! k$ p8 s9 K, y* U
生命周期

0 U) q- Z: s; t( f测试—〉SetUp（）—〉testXX（）—〉tearDown（）—〉结束；
/ Y) g. H5 i" ^1 U5 l2 I
TestCase套件
0 h- Q6 |, D; p/ l% W- @
public class MyTest{
% a! ?8 g! J$ b! S2 F
        Public static Test suite(){

TestSuite suite = new TestSuite();

1 }/ O/ F" l' m9 U  t( R) Dsuite.addTestCase(Test1.class);
. }5 f8 T' o& {& j2 C7 V! |1 e8 C
suite.addTestCase(Test2.class);
5 W9 n, W# x% g+ }. L: K$ n7 U
8 H; |0 Y" x/ ?* E* G; b( R}
. u0 H0 c* y! D+ e6 G
: \+ O1 X+ l) v. O/ m}
# Q, D2 Q6 [) p. r
4 E2 f' v' \2 F7 d, W% ]! v  `
# X5 O: I) x1 o1 v
9 E- |, L  `9 ZAjax
是什么？
AJAX即“Asynchronous JavaScript and XML”（异步JavaScript和XML)。是一种创建交互式网页应用的网页开发技术。
) t6 K/ Q5 q4 i! Q  ]- T2 ]
2 e5 L6 _0 O3 }  H6 n8 ]无刷新页面。

3 W6 k+ [0 ?, U: e0 c3 R有什么？
AJAX是多种技术的综合，包括JavaScript、XHTML和CSS、DOM、XML 和 XSLT、XMLHttpRequest。
1 j1 [/ n! Y! I4 x7 y
1 s& I9 I3 i6 N: H: Q0 ^* _能干什么？
使用XHTML+CSS标准化呈现；
- {4 a( A. f7 e8 v, l0 M& Y使用DOM进行动态显示及交互；
使用 XML 和 XSLT 进行数据交换及相关操作；
! l* Y% T6 d+ `; e: T0 S) r$ p7 x5 u使用 XMLHttpRequest 进行异步数据查询、检索；
使用JavaScript绑定和处理有所得数据；
7 j* o2 b$ o  C: q2 X- e
6 _2 G/ n. W$ \: H9 H1 c# j) A传统的web应用允许用户填写表单(form)，当提交表单时就向web服务器发送一个请求。服务器接收并处理传来的表单，然後返回一个新的网页。这个做法浪费了许多带宽，因为在前後两个页面中的大部分HTML代码往往是相同的。由于每次应用的交互都需要向服务器发送请求，应用的响应时间就依赖于服务器的响应时间。这导致了用户界面的响应比本地应用慢得多。
) d& p9 R( U0 |; R- R
, M; R2 t5 D& ]# H/ a与此不同，AJAX应用可以仅向服务器发送并取回必需的数据，它使用SOAP或其它一些基于XML的web service接口，并在客户端采用JavaScript处理来自服务器的响应。因为在服务器和浏览器之间交换的数据大量减少，结果我们就能看到响应更快的应用。同时很多的处理工作可以在发出请求的客户端机器上完成，所以Web服务器的处理时间也减少了。
& [1 K* G1 J6 v0 n  i0 K
! c$ |& W" j# a8 i, n使用Ajax的最大优点，就是能在不更新整个页面的前提下维护数据。这使得Web应用程序更为迅捷地回应用户动作，并避免了在网络上发送那些没有改变过的信息。
7 F8 {7 i1 A$ @& B
对应用Ajax最主要的批评就是：
/ \) W: i3 V0 ?) y" O  f! ~1 它破坏了浏览器后退按钮的正常行为，就是用户点击后退按钮后不能看到之前的数据；
8 i. P1 e* W7 I: W4 C- Y6 o4 y2 一些手持设备（如手机、PDA等）现在还不能很好的支持Ajax；
, O+ v2 ]$ Y4 o; O; j3 用JavaScript作的Ajax引擎，JavaScript的兼容性和DeBug都是让人头痛的事；
& k% o) w* |2 u$ j! R2 i9 j4 Ajax的无刷新重载，由于页面的变化没有刷新重载那么明显，所以容易给用户带来困扰――用户不太清楚现在的数据是新的还是已经更新过的；现有的解决有：在相关位置提示、数据更新的区域设计得比较明显、数据更新后给用户提示等;

怎么做？
<script language=”javascript”>

# c) t( \' ^$ `& Nvar req;

function add(){

9 D. I/ B- A5 j//1:创建用于传输的对象
  s8 E  C$ I+ u9 N$ U
req=new ActiveXObject(“Microsoft.XMLHTTP”);

// 声明返回后，处理数据的方法
) P8 M1 d" {8 X1 n+ y4 p6 R
req.onreadystatechange=manage;
6 B! c7 e4 i% `7 {+ h' R( i
//2:准备传输的内容
8 V# S6 v& W" r7 s6 ?' r
0 z) }7 b" o/ Y7 \var str=”test1111″;
/ I: T7 m5 n3 H, V/ v( L
) E0 e. Q' L9 r: K//3:发出请求

/ r- `; T3 h+ H6 f/ V, Q- o; rreq.open(“GET” ,”/others/ajax/test/t2.jsp?str=”+str);
0 s: `5 g! ^) q+ G& v& `% M5 |' U
req.send(null);
9 ~' s9 K& Q% F2 H* w* n  U- v
9 {1 Z+ }: N. _) N  F}
' @4 d) C- Z- W+ `" A, R" l0 h* n+ b
/ E% i. {4 x' j. `//4:接受返回并处理

function manage(){

if(req.readyState==4){
& i7 u5 @7 S2 f  R9 U: w' a8 w
alert(“r==”+req.responseText);

}
5 y. [, B7 M& s4 z( m
% E( }; j8 e7 o}

) U5 z( [6 E) |4 W, h% k! G/ i</script>
' P/ I& G6 W' x5 I  l
readyState的取值如下：

　　0 (未初始化)

5 g+ s2 {. U& C; L　　1 (正在装载)
% O" G2 Y8 {0 A" H% w$ V) _
8 T& m1 p) \3 \. V0 `+ b; l1 ]　　2 (装载完毕)

　　3 (交互中)

+ D3 F8 C4 R- q" G; ^　　4 (完成)
& H9 o9 K7 F. s+ q/ C


" ^1 X! b9 X* p$ g原理
Ajax的原理简单来说通过XmlHttpRequest对象来向服务器发异步请求，从服务器获得数据，可以是xml格式，也可以是一个字符串，然后用javascript来操作DOM而更新页面。
9 F$ g, b: q3 @' t3 i
4 I4 O1 G: y5 G# Z8 X0 \Dwr
/ t8 P# q: @( E% _是什么？
$ F$ P( Z: E2 O0 oDWR（Direct Web Remoting）是一个开源的类库，可以帮助开发人员开发包含AJAX技术的页面。它可以允许在页面中使用运行在WEB服务器上的JAVA函数,被调用的JAVA函数就像是在页面中JavaScript方法一样。
" ]  g* O; U; i0 T% z
有什么？
它包含两个主要的部分：允许JavaScript从WEB服务器上一个遵循了AJAX原则的Servlet中获取数据；另外一方面提供了一个JavaScript库可以帮助web开发人员轻松地利用获取的数据来动态改变网页的内容。


1 @2 F  s+ a- e0 G
能干什么？
+ P; ^- z( d9 T, v( C3 a% G动态地把java类生成为JavaScript，感觉调用就像发生在浏览器端，实际上代码调用发生在服务器端，Dwr负责数据的传递和转换。这种从Java到JavaScript的远程调用功能的方式使DWR用起来有种非常像RMI或者SOAP的常规RPC机制。
- j( T) `: e7 `
; L! y& U6 e: I- B! X+ o

怎么做？
① 编写配置文件
  j  ^' `. g* |' ^6 ~0 S
web.xml
8 `7 c1 x0 c2 U1 w2 i
0 Q. P6 |' n. J: m, H% E<servlet>
$ r) y; G9 X7 j" C# w
<servlet-name>dwr-invoker</servlet-name>
+ v' r% B7 s' S0 ~* Z! E8 \
0 B' E6 T' i" b<servlet-class>
5 E% P0 z; T( s" B% d' H
org.directwebremoting.servlet.DwrServlet

</servlet-class>
  v! }3 x7 K. X# Z+ |
<init-param>
: X( [7 d: O: L( a
6 P* @8 }6 A* A% ?6 F; r<param-name>debug</param-name>

<param-value>true</param-value>
& r2 B& k& H1 x) h( Z
( p& H7 Y0 t, F) R9 r, X0 u" A</init-param>

( J$ O+ M6 t! A( h</servlet>

<servlet-mapping>

<servlet-name>dwr-invoker</servlet-name>

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

- B2 y2 o4 {( r) w: j8 o0 \</servlet-mapping>

dwr.xml
. z7 X( D( W4 s- g% {$ |% l
<allow>
) y  Z) f+ S' R7 n$ z, D
$ C7 N- N2 S5 H; O. U' t<create creator=”new” javascript=”kc2″>
5 \" R6 e- p) y8 `" F3 C1 T
& F! u9 {% m" [3 ?4 g<param name=”class” value=”dwr.Service” />
3 H" S1 O/ ]2 H9 x
</create>
3 \# R% A7 {* e/ [
$ [# A+ M1 a. P3 @0 {</allow>
' S5 V" Q; Q7 s4 J* G, i1 ]
7 Y. K9 J! O: ^% W% Z; ]- J' p) O②编写service
/ I# J  |1 i* q5 o9 r
public class Service {
) m3 U+ J7 a; }8 t% G2 N9 p) {
1 r; s3 P( d5 s7 Epublic String sayHello(String yourName) {

//可以是访问数据库的复杂代码

! m9 F8 r% H7 greturn “Hello World ” + yourName;

- p- r! |8 e0 e( p/ [}
7 |* K* m6 N- Y1 j: ~
9 E) L3 X( k) f+ \7 {9 D2 l9 ~}
$ C* w* N8 W6 r( y& F
- Q1 M: ~7 {# f' h' [, ^; H: [+ \③测试DWR
! {1 m' ?+ f8 v5 |
& U4 G* r: L, w6 O- D0 m) o2 K将代码放入应用服务器（比如Tomcat），启动。

+ f" g3 E. f6 C  G然后在地址栏输入http://localhost:8080/你的工程/dwr
* k+ H" h* M: |- Q4 v! h6 X% M0 `
$ O) q( S) V+ v- J  {+ f④编写jsp页面

1） 要引用3个dwr的js，其中engine.js必须要，如果需要用到dwr提供的一些方便的工具要引用util.js

2） 然后还要引用dwr自动生成的js，dwr/interface/service.js，注意js名字要和dwr.xml配置的一样

4 A% x2 o  V7 L' f) U/ C3） js里的service.sayHello和java类的那个有一点区别，多了一个参数，用来得到返回的数据

admin

事务
ACID
% h3 G' ?8 S0 ?, C, }（1）原子性（A）：一系列的操作具有不可分割性，要么成功，要么失败

8 g( b. c6 x# y5 w, j9 g（2）一致性 ：操作的前后满足同样的规则，保持平衡。
' h- t8 B& V2 T: X! z
（3）隔离性 ：在事务运行的过程中。事务内的数据对外的可见性和可操作性（必需由数据库的支持）
7 Y* r' ?4 x' Y1 M
% C' g0 {5 K! Z2 m3 L' C（4）稳定性 ：保证数据在事务的操作的过程中不会遭到破坏，而且是永久性存储的
# C3 e# u/ s2 c/ J7 A" y
5 \" b/ u  _6 P7 D3 I$ X" m7 i* y
% ], e" |4 d2 [$ ]5 e# N  q
3 n/ [* n: K$ G事务模型
（1）经典事务模型又叫平面事务模型（JDBC） 事务不允许嵌套

3 `7 Y# J0 u' ]# b（2）嵌套事务模型



事务的两种方式
- B5 B" Z/ P. Q  }（1）声明式
2 R& J! ~: `3 L- l. P, N% X$ s
/ D4 m+ ?9 J: b" o在配置文件中设置以下6项
' B- t& k' S/ h7 b) K  h# Q
  d" y1 B* e" t! m# v  o（１）.required

如果客户端没有事务　在bean中新起一个事务

如果客户端有事务bean 中就加进去

$ C1 f" X3 J$ `! ]! }(2)、 requiresNew
) O, R' t5 z/ Z$ ]1 ~1 i* p
不管客户端有没有事务服务器段都新起一个事务
! N" g, _) ?0 q9 z
如果客户端有事务就将事务挂起
3 m' p# t' }8 z3 z
$ S; O5 y+ j5 u(3)、supports

, x# F9 |; \* M3 `如果客户端没有事务服务端也没有事务
7 p1 E0 M5 q' Q, K
如果客户端有事务服务端就加一个事务
, p' c$ J: I) w* Z/ g( G
# Q5 n. E& H2 E8 O(4)、mandatcry

0 }: }" s) j! o2 s如果客户端没有事务服务端就会报错

如果客户端有事务服务端就加事务
3 |' U! Z2 ~, c; v; l- z
(5)、notSupported
* [* @0 _8 ^0 `- [' i. s1 x
不管客户端有没有事务服务端都没有事务
+ `, T! n6 a6 J# g# y0 B! _& J
如果客户端有事务服务端就挂起
# Y% ]9 K4 L" F7 X# r
(6)、never

- m: I1 e( Q+ v5 x- q) c' j0 D( W不管客户端有没有事务服务端都没有事务
3 I" `( o' b5 J2 [8 r& c& _# o
如果客户端有事务就报错
9 T. g6 B# J9 U# r3 W
8 q0 k7 B# a. @. e( r1 ]$ v2 W（2）编程式事务

  J" G7 I3 J, m) p" a# ^' H$ ?$ WJavax.transaction.UserTranscation

5 W2 M2 r. m$ nJTA 事务可以精确到事务的开始和结束

2 v7 E# ?; c; {4 F7 c

) |4 e6 O# i: n5 \事务的隔离性
+ o# f* S. K7 T5 T  TRead-uncommited

读取未提交的数据（基本上没有锁）脏读，存在不当读取的问题。

Read-commited

5 m1 ]) C1 p! z: G" I读取已提交的数据（行级锁）

无法读取已经写入，但没有被提交的数据。
/ O# d6 E' T; O5 h  Q! \( C( g3 i
+ v8 t) |! g1 O# R$ ERepeatable_read
" ~& |8 {/ P- ]: F7 n, U
读取的数据不允许修改或删除

不可重复读（行级锁+不允许修改/删除）
& _& i* ~& Z, h$ I) |2 R
+ m' r; n/ o2 n9 z6 `* o  kSerializable
1 k% Q0 R  `* ]0 t
+ v9 _2 \0 |2 N- K幻影读（表级锁）


5 A% c8 y" `( ~8 r
3 ^( G: k6 Q3 N/ ?: L/ gstruts
; _! J/ d% o1 r$ N/ e! f" l开发流程
9 I" T  V$ w! c; I5 c7 b; ]3 J
2 O( a3 U& j% W1、创建表单

2、从表单中获得输入
+ Y! d+ @1 `7 w- \
* E) I' C4 {% s& k; _3、处理输入（业务逻辑）

4、根据动态输入改变输入流
9 p- M9 N) J% y9 X# O! e' \
* n( S. J# o, k要完成上述四步，我们需要创建
& G* y+ |" l: _# T0 {8 o+ D
1、一个ActionForm
- a# t1 C. n! O" ?: t9 p  B
2 K! ^2 e( @, `2、一个action

4 l! O7 l& }/ N6 T6 f7 A( D- T# @3、一个配置文件struts-config.xml

2 a% N3 V# ?; j1 p* w+ x4、创建页面

/ t' `. V6 b( Q7 O. E" F创建ActionForm
  S4 G) n9 V& n) K
! F: l0 e7 z7 t- Q% M1、写一个类继承ActionForm

2 `7 t9 p6 W. }) ^- B( p' M2、私有的属性

3、相应的get、set方法
5 i9 S9 |0 s' @
4、重写tostring、equals、hashcode三个方法
& a; Y% L& Y, \& A
创建action

1、写一个类继承Action

2 h, ]8 f+ _4 ^1 y* `  j2、实现一个公有的方法（回调方法）

public ActionForward execute(ActionMapping mapping,

ActionForm form,

HttpServletRequest request,
0 ]0 M, h- Y6 y8 ?5 P! |: T
HttpServletResponse response)

' i/ u/ ~* E* ^& I( e+ p; P; p{
0 s# }( O8 B  ~1 c5 Q
//1.收集参数

/ l' I5 _) I1 j4 AMyActionForm myForm = (MyActionForm)form;
( F6 q6 ]  r) h/ ^  H/ R4 e0 D, p1 ~
//2.组织参数
: G, o3 ~; ~- X$ Q* \( m! ~

$ x6 K) m4 F( h' L, v
! H7 j) I0 i1 X9 |3 V8 G//3.调用逻辑层

boolean flag = true;
/ ~) P% M8 ~+ e$ j5 y" k5 n" W
' u4 }3 J) n& |: _2 k//4.根据返回值来跳转到相应的页面
# D7 l( y4 q+ Z# |7 c
6 a' p2 ]+ m  e* Q- ^$ aActionForward af = new ActionForward();

/ g1 e/ r1 ^) cif(flag){
% a9 f% ^) L. @4 u4 [3 E4 C3 z& J4 A
( b3 f9 N4 |7 ^( \+ N; K" \  i6 y/ Eaf = mapping.findForward(“1″);
- F! t7 H' W4 ^
}else{

# ]5 V% `# E! j+ e/ p% o9 h( naf = mapping.findForward(“2″);

}

& B( T6 S7 d! Y, Y5 ~8 Ireturn af;

}

* o! P$ Y( P8 g4 @配置struts-config.xml文件
7 s. n( d! O- }" P/ @2 c
1.<form-beans>

<form-bean name=”myActionForm” type=”全路径.MyActionForm”/>

<form-bean />

8 ~, {/ F4 H) f$ B5 N4 U6 i0 F</form-beans>
% O+ @: m! i$ f; G/ P' k" G  @
/ `$ H$ R, D" A1 z# s2.<action-mappings>

<action path=”/sll”

, N# _0 \, B" z/ m$ y' X8 S6 [name=”myActionForm”
# k7 e: d; g2 }* t
! @, P8 S; ^. i" m; D! }$ wtype=”全路径.MyAction”

7 ?+ _! C# t3 x: {9 ~: U+ P  hscope=”session”
8 U6 V1 i) F* T
input=”错误返回的页面”>
3 k) l6 C! D# H) ~3 g/ p1 a/ _$ A
9 r% [9 ^" ~  V0 a<forward name=”1″ path=”/1.jsp”>

<forward name=”2″ path=”/2.jsp”>
' j& t7 N5 W0 T- Y2 E! }" }  x
; Y5 r" B! k4 l1 ]* \0 t5 N</action>
. ~+ s9 D& ]/ [# @
</action-mappings>

步骤:
) P' \7 N+ S# ^( q
  E' J1 |9 ^% F9 N1.创建一个空的web应用

$ z  [" ~' k" `- f0 k9 \2.将struts的包放到lib文件夹下
3 o( n! R) N6 i+ ~+ N! o5 E
3.将.tld文件文件和struts-config.xml、web.xml放到WEB-INF的跟目录下
; }: d4 F) K4 Z& f/ m
$ I; D7 K. C3 A' B! g/ S& D& e( B4.配置struts-config.xml文件和web.xml文件
2 ?8 {' v2 r) C( M; b
4 v5 \+ D2 F9 L8 ]5.在页面引入tag文件uri

5 ]9 a: [: Y, Q7 D; [9 \STRUTS运行机制

& n# e4 o% b7 Q1、界面点击产生请求
5 o+ t) ~1 v; g2 B, J  b
' i1 k- A8 t4 v0 x4 \/ K$ ]( m2、容器接到请求
7 }: k  u( q) I* U: ]2 k/ \% ^
; C$ ~7 A4 C2 z) H4 B  c3、匹配web.xml文件中的*.do来调用ActionServlet
! H# @) B/ k* n4 t0 m
4、ActionServlet的处理
2 q1 @( @1 x1 D8 W: f2 h
0 E5 r/ ~3 |( I1 [. O4.1 读struts-congfig.xml文件形成ActionMapping

7 o& _5 a$ h  Z1 |) l4.2 通过path 来匹配Action类，通过Action的name属性来匹配ActionForm类

4.3 通过反射机制来给Form添数据

1 U! W% I# {3 N4 a9 B! |4.4 由ActionServlet转调Action的execute方法

4.5 得到execute方法的返回值，跳转页面
7 |  q& K# R( t3 r9 b+ N
4.5.1 RequestDispatcher

8 r3 w5 c; B! V( y4.5.2 response.sendRedirect(“list.jsp”);


; |  [- ?( o, ?) g; w8 z
进入execute方法

1 收集参数
5 O6 P4 l" J" ^& L" D
! R2 D( d' T' g7 |2 组织参数

$ p! S- V" p! g! G3 X3 调用，逻辑层

4 返回值

$ S  t2 M7 ?' ^+ z6 H! |5 S5 _4.1 选择下一个页面 （ActionForward）

4.2 把值传给下一个页面
; v; Y5 O2 ]& P* Q7 P3 Z


比较struts和struts2的不同
' V' F3 v  T% v0 F$ V
Struts

Struts2
8 @0 k* ]8 y; C
组成        五个部分：ActionServlet，ActionMapping，AtcionForward，ActionForm，Action        十个部分：AcionContext，FilterDispatcher，ActionMapper，ActionProxy，Configuration Manager，Action Invocation，Interceptot，Action，Result，Taglib
* f  ^; X$ z6 [  c5 k8 ?url        .do        .action
9 E9 Z  m3 ]# ^) Y, U/ v分发控制        AtcionServlet        FilterDispatcher
收集参数        利用JavaBean技术，将数据封装到ActionForm的子类中；
一个Action对应一个ActionForm的子类
2 i1 E" Y, e& p1 p0 F1 y* Q
7 ?3 N# G3 l" `4 M# i6 F% X! w使用拦截器将数据封装到值栈中。
. v3 q4 E/ ^8 h/ @5 R7 H( R使用域模型，一个Action对应多个值栈中的Model

读取配置文件        ActionMapping        Configuration Manager
拦截器        无拦截器        执行Action前后有拦截器
返回页面        将字符串封装到AtcionForward，进行跳转页面        Action中直接返回字符串，通过Result跳转页面
页面跳转方式        两种：dispatch，redirect        三种：dispatch，redirect，chain
% v7 }; E& x& O1 [' V6 h值栈        无值栈，Action通过在request范围内设置属性，向jsp页面传递数据        有值栈，Action和jsp页面通过值栈传递数据，jsp页面通过OGNL取得值栈中的数据
" T8 d5 E5 f3 n( [+ k配置文件        struts-config.xml        struts.xml
中文问题        不能解决（需要使用filter）        可以解决中文问题：
* `  C9 V; W5 m! o% x1、在jsp页面添加Meta；

2、修改struts.properties中的设置。

admin

Spring

• 是什么？
  
  - M8 @4 Y/ X. X& {! m! s

Spring是基于JEE的轻量级的应用框架

( _* `4 i& K7 h# p" k

• 有什么？
  + _& c; D  F, \7 {" g
  - V. [, m; w/ f( E/ T6 [- t: _

& E0 {: u$ }$ n, T$ C0 d2 B$ U

每个包的功能：

Spring MVC：spring 本身提供的web 框架

WEB：集成其他的web 应用的框架，或者说是对其他web应用框架的支持。如struts，webwork

JEE ：集成一系列的jee的技术（对JEE技术的支持）

DAO：封装了JDBC；（对JDBC的支持）

ORM：提供了对ＯＲＭ工具的集成（支持）

AOP ：面向切面编成

CORE：spring的核心包，提供bean的工厂和IOC容器

/ M+ E7 z2 i9 r8 E2 p

• 能干什么？
  
  

把一系列的jee的技术有效的组合在一起形成以良好的系统

• 怎么用？
  
  
  • 搭建web工程，引入spring的jar包
    
  • 在web.xml中添加如下配置
    ( J" l+ I2 S; f0 C7 r+ L8 ]  _. P# M/ J
    
  
  2 E6 h8 E. Q4 m; c9 l# B- `- o& s
  1 q/ S, G, x: L* n2 F8 j: S: _* O5 \

            contextConfigLocation

            classpath*:applicationContext*.xml

   
( _( c+ @" u2 W, M

        

            struts2

            
9 N  k1 [% S+ J& y! n3 T" h4 l

                org.apache.struts2.dispatcher.FilterDispatcher

            

        

        
( X2 d9 M- ^1 }% ^- c9 X* h9 d

            struts2
0 c  \3 x* z( A% c! I0 g% }

            /*

; f% X/ ^" ^& c

            

                org.springframework.web.context.ContextLoaderListener

            

        

• 部署
  
  1 F) f6 L& S4 \

6 [3 Q3 u; R* }& G; y' `

" I* b, X- {$ m( v6 e- H+ w

• 容器和bean
  

Bean ：是指受spring的ioc管理的对象称为bean

容器 ：（与jee的容器类比）

Jee ：提供组件的运行环境和管理组件的生命周期（不能单独存在）

Spring ：提供bean的运行环境和管理bean的生命周期（可以单独存在）

• IOC控制反转
  " V2 g( t0 S* G* R* ^8 i
  ' r2 [5 \9 H- H# K+ v
  
  - b& y1 b2 X5 M' a' ^4 s2 q& L$ U
  ! c9 |5 H* Q* x0 {: h; H4 t
  从前的应用程序想要得到A的实例他会直接主动的去拿，当用了sping后，应用程序由主动的去取变成被动的等待，由spring来控制应用程序所需要的对象
  
  
  • IOC的优点
    
  1.可以通过IOC来获得实例
  2.可以通过DI来获取注入的资源
  • 配置IOC的原则
    
    • 一定是可变的资源才采用依赖注入
    • 一定是层间的接口或者是模块之间的相互调用才采用依赖注入
      

! A8 s- b4 b- Z" G3 P' `6 U

• DI依赖注入
  

1. 应用程序依赖spring注入所需要的对象

IOC和DI是对同一种事情的不同描述

2.setter注入： 在配置文件中将接口的实现配置为bean在应用程序中注入bean

例如：

在配置文件中

! n# o1 j+ Q* Y4 G( I1 U& l
7 x. _4 j# F8 V8 M! |" k7 |% K
! e+ L9 L8 l: k9 ^$ T6 h6 A

在应用程序中

Public DBDAO dao ;

Public void setDao(DBDAO dao){

This.dao = dao;

}

3．构造器注入

4．ref 表示参照其它的bean

在参照的过程中一定要注意死循环

5.自动装配———–〉no

自动装配根据名字来匹配相应的bean 尽量不要去自动装配

6.lookup注入

7.singleton

1.单例模式是整个的jvm中只有一个实例

2.spring的singleton是指在spring的容器中只有一个实例

一个生命周期中只有一个实例

8.DI的优点：

1.程序被动等待，强化面向接口编成

2.切断了对象或组件之间的联系，使程序的结构更加松散，运行和维护更加简单

4 s+ x- L3 q% I- w  I8 p5 g

• Aop面向切面编程
  * o* ?( C$ O7 {( i: j9 L
  ( U2 v# ?0 L$ i, ~& W9 z

1.AOP面向切面编程 一些较好的模式或者是示例—-范式

切面：一个切面代表我们所关注的一系列的共同的功能点（模块之间的共同的功能点）

2.AOP的思想： 主动—->被动（追加功能）

3.AOP 的概念

1.切面 ：我们所关注的功能点

2.连接点 ：事件的触发点（方法的执行）

3.通知 ：连接点触发时执行的动作（方法）

4.切入点 ：一系列的连接点的集合 （连接点的模块化）

5.引入 ：扩展的功能

6.目标对象 ：包含连接点的对象

7.aop代理 ：实现机制

8.织入 ：把advice和目标对象连接起来

4.AOP的事件机制
8 g! h9 Z/ G/ V, |- l

1.通过切面找出一系列共同的功能点

2.找到目标对象(在标准的spring 中 接口的实现类为target)

3.找到切入点

4.确定连接点

5.通知spring AOP，查询xml文件，通过代理找到advice。

6.由aop代理来实现动态织入

$ Q% z, \: y! I+ J( r
$ z/ W( u' P9 M% a# E


( E( ?) g' s6 M- C. @8 }5 X9 v& x3 L
8 P0 u# t, y* t0 Y7 U+ S% _
% B' W) j9 `2 W, ?8 P$ Q" l

5. AspectJ

5.1.在xml中配置比较烦琐

所有的入口必须从一个代理（ProxyFactoryBean）开始
+ k6 {( Y7 H  L' |! u

7 l; h; H/ g' b+ E, J
2 ?1 m( ~* L; ^* T5 ^

         

5 l/ z+ J% y1 y; F7 [5 Q9 K
9 l4 V0 I% {% e; R4 S( `, _6 O* i% K         

        

        

9 u; I6 @9 [% ?* Q7 C/ dexpression=“execution(* com.javakc.aop.MyTarget.t*())”/>

        

        

   
% O  K. s6 k% m$ |% l8 R

6 R  L, l7 K$ [! ^+ E7 o

5.3.使用注解的方法相对简单
% V2 H) R3 p4 U

@AspectJ的基本语法

1.@Aspect声明一个切面，将一系列的共同的功能定义成一个切面

直接在类上定义@Aspect

2.@Pointcut声明切入点
2 n' E% u( P7 ~0 V! a; W4 f

2.1、用一个专门的类来定义pointcut，类中的方法名就是该pointcut的名字
: x) T5 Q" i  p3 T8 Q9 s

2.2、可以使用匿名的pointcut
4 X1 E$ L$ ]5 Z" U; |) f3 D

2.3、执行切点的几种方法

2.3.1 execute（public * 包结构.*.*.（..）） 可以指定到具体的方法

2.3.2 within 指定到包，不能指定到类

within（”com.javakc.spring..*”）

2.3.3 this 指定到实现接口的所有的实现类
' j% M$ J7 T. ?/ t- A: U

2.3.4 target 指定具体的实现类
% m0 P) r% N- l3 q+ m) Y; ]; H

5.4.advice的五种类型的示例

　　　 客户端必须从接口走才能得到监控，实现想要追加的功能
0 a8 k: C/ e( i: h1 ^: ]

5.4.1.@AfterReturning(pointcut=”” returning=”retVal”)
; w, \) X  E9 {- R2 S1 D

追加的方法的参数名字一定要与retrning的名字相同
9 U. I0 c8 `4 n

在注解@AfterReturning中必须加上pointcut和returning两个参数
) A9 W* \1 X; M2 ^! Y

pointcut指所要监控的目标对象的方法

得到目标对象的方法的返回值，来作为参数，进行下一步的处理,参数没有顺序，按参数的名字进行匹配
. B$ q+ q5 }5 B# {' j

完成追加的功能

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用

(1).@AfterReturning(“com.javakc.spring.schemaaop.TestPointcut.t4()”)

(2).

     2.直接引用匿名的pointcut

     (1).@AfterReturning(“execution(

* com.javakc.spring.schemaaop.Api.test4())”)

     (2).@AfterReturning(pointcut=

“com.javakc.spring.schemaaop.TestPointcut.t4() &&

args(str)”, returning=”retVal”)
1 r9 S$ x& V1 k% X8 c! G5 @

@AfterReturning (pointcut=”com.javakc.spring.schemaaop.TestPointcut.t4() && args(str)”,returning=”retVal”)

public void testAfterReturning(String str,Object retVal){

    System.out.println(“afterReturning1=>”+retVal+”=>”+str);

    }
  x& o' W% e5 F" g5 a7 C: h

5.4.2.@Aronud

     注解@Around环绕追加功能；

     在执行目标对象的方法的前、后追加功能；
4 r' z$ `8 i. D) @! G  w; {

     必须有参数；第一个参数的类型必须为ProceedingJoinPoint；
) r  y2 a. M& \1 u/ ?: W% F1 b2 a

     通过ProceedingJoinPoint的实例的proceed来调用所监控的

目标对象的方法

     1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
, z0 f4 B; f' \7 a

     (1).@Around(“com.javakc.spring.schemaaop.TestPointcut.t1()”)

     (2).@Around(“com.javakc.spring.schemaaop.TestPointcut.t2()
. q% w! h. {# g6 p

&& args(str)”)

2.直接引用匿名的pointcut
( r  V: n& e7 i! y7 a

     (1).@Around(“execution(
1 L" d- O7 i2 T5 l  @5 W% e

* com.javakc.spring.schemaaop.Api.test1())”)
1 o% z* d% H: \) X; i# g

     (2).@Around(“execution(

* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)

// @Around(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
% \1 E5 |. \* I" l- U) |

     @Around(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)

public void testAround(ProceedingJoinPoint prj,String str) throws Throwable{
# z$ h7 M  p+ R% t' ?

    System.out.println(“around1==========before1pointcut==>”+str)

        Object obj = prj.proceed();

        System.out.println(“around1==========after1pointcut==>”+str);

    }
) U( H" n) D1 ]

5.4.3.@Before
, L/ [, G# Q" n9 f! E+ t# P

注解@Before在执行目标对象的方法前追加相应的功能

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用

(1).@Before(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
$ _& _; I+ _* q! x! l, v

(2).@Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
* T% Z; F( y8 c3 k3 \

注意args后的名称与参数名相同

2.直接引用匿名的pointcut
4 x3 f. M) M& e' B: C& p" ~4 @+ T1 y

(1).@Before(“execution(* com.javakc.spring.schemaaop.Api.test1())”)

(2).@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)

注意args后的名称与参数名相同
* [: V9 m& ?, m4 Q

// @Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)

@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)

public void testBeforeParam(String str){
5 v. [1 b6 ~3 I, R! N# M. F

    System.out.println(“before1=param=>”+str);

}
% p6 {. z1 p9 k8 x  W0 f5 H

( X% C5 _, B+ k! F5 I

5.4.4.@After
9 v% o5 ]% I# h$ H& I

注解@After在执行目标对象的方法后追加相应的功能
9 U  g+ |; @) q& y! Q

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
* Z2 c9 |3 Q" k, d$ ~1 J/ u

     (1).@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
' \( H1 A& A* H2 V

     2.直接引用匿名的pointcut

     (1).@After(“execution(* com.javakc.spring.schemaaop.Api.test1())”)

@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)

    public void testAfter(){
, d; t# C; `' b5 U% o

    System.out.println(“after1== >pointcut”);
7 y3 A; x( E3 n. q$ f

    }
+ d- b+ J, t0 {0 ?% C5 i4 u# X

5.4.5.@AfterThorwing
/ d/ _. M/ C& }' R( A* n$ t% ]5 ~: d

• 描述一下spring中BeanFactory和ApplicationContext的差别
  - c3 L* P  h/ R7 K! J, g* E, Q2 ~
  

BeanFactory是一个Interface,这是Spring的核心。它仅仅只是提供的一些基本功能。ApplicaionContext 也是一个interface,这是从BeanFactory继承过来的所以它具备了BeanFactory的所有功能。但它也从其它的类或interface得到了一些特性。比如提供国际化的消息访问，资源访问，事件传播。

但其主要区别在于BeanFactory是延迟加载,如果Bean的某一个属性没有注入，BeanFactory加载后，直至第一次使用getBean方法调用此Bean时才会抛出异常；而ApplicationContext则在初始化自身时检验，这样有利于检查所依赖属性是否注入；所以通常情况下我们选择使用ApplicationContext.

代码示例：

BeanFactory beanFactory = new XmlBeanFactory(new FileSystemResource(“beans.xml”));

ApplicationContext cxt = new ClassPathXmlApplicationContext(“beans.xml”);

! N* n# q% h& H) O/ O' f

• 谈谈spring对DAO的支持
  
  

Spring提供的DAO(数据访问对象)支持主要的目的是便于以标准的方式使用不同的数据访问技术。
0 J: n# {. i, ^7 k# V8 P6 j

简化 DAO 组件的开发。
' P" ]3 J8 f; p! RSpring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法，用来简化代码开发。
' ~$ a4 Y) Z9 u$ P1 K

IoC 容器的使用，提供了 DAO 组件与业务逻辑组件之间的解耦。所有的 DAO 组件，都由容器负责注入到业务逻辑组件中，其业务组件无须关心 DAO 组件的实现。
$ \* S! c: f& [* |$ }, ?) w2 D. T

面向接口编程及 DAO 模式的使用，提高了系统组件之间的解耦，降低了系统重构的成本。

方便的事务管理: Spring的声明式事务管理力度是方法级。
4 T7 R; S9 Z' }5 M) l* i

异常包装:Spring能够包装Hibernate异常，把它们从CheckedException变为RuntimeException; 开发者可选择在恰当的层处理数据中不可恢复的异常，从而避免烦琐的 catch/throw 及异常声明。
% {1 ?) W" u5 P$ D  B, H, b, S

& s* I7 [" u2 H( P

• 谈谈spring对hibernate的支持
  
  0 W7 f( P! @$ ~+ s) R

在所有的 ORM 框架中， Sping 对 Hibernate 的支持最好。如 SessionFactory 的注入、HibernateTemplate 的简化操作及 DAO 支持等。另外， Spring 还提供了统一的异常体系及声明式事务管理等。
/ U6 P% U- i2 y5 P

一旦 Hibernate 处于 Spring 的管理下， Hibernate 所需要的基础资源，都由 Spring 提供注入。Hibernate 创建 SessionFactory 必需的 DataSource ，执行持久化必需的 Session 及持久层访问必需的事务控制等，这些原本必须通过代码控制的逻辑，都将由Spring 接管ataSource, SessionFactory, TransactionManager等，都将作为 Spring 容器中的 bean。将这些bean 放在配置文件中管理。

1、通用的资源管理: Spring 的 ApplicationContext 能管理 SessionFactory，使得配置值很容易被管理和修改，无须使用Hibernate 的配置文件。详细配置如下：

# j; H2 k- b) q/ y+ \/ {

        class=“org.apache.commons.dbcp.BasicDataSource”>
7 y! `; F- X# v! [

        
! v3 H" j; C" ~( R

            oracle.jdbc.driver.OracleDriver

        
3 ^3 e- \' l3 O) k# s

        
4 j$ D% @+ ~% T0 P- w: b5 j

            jdbcracle:thinlocalhost:1521rcl
, M# [8 b4 E1 u

        
! e2 Y7 _# _: \: ~6 i6 A8 k

        
0 _7 C! G9 U( q; k  i+ G+ J, p

            javakc2
* D9 e! Q9 n2 K. H; v8 J' k

        

        

            javakc2

        
% X* y3 D' u% X& p- C) \# L" @

   
- `% y! a* |; o" v

   

        class=“org.springframework.orm.hibernate3.LocalSessionFactoryBean”>

        

        

            

                com/javakc/spring/h3/UserModel.hbm.xml
; s- c, f- C! V4 s

            
" M5 a6 `: g7 |# E) Z$ `

        
0 r* t3 M3 ~7 p) t

        
! E/ H3 k( F9 [1 x

            

                hibernate.dialect=org.hibernate.dialect.OracleDialect

            

        
: ?4 Y* H2 `/ L! n

   
/ I5 {$ Z# f% N% e* T6 H3 j& b; Z

   

        

   

如果需要使用容器管理的数据源，则无须提供数据驱动等信息，只需要提供数据源的JNDI 即可。对上文的SessionFactory只需将dataSource的配置替换成 JNDI 数据源，并将原有的 myDataSource Bean 替换成如下所示:

   

        class=“org.springframework.jndi.JndiObjectFactoryBean”>
7 h, x! e4 L/ N

        
) G1 S8 W( O$ O: m3 w5 L

            java:comp/env/jdbc/myds

        
+ J' P* r4 ~' _. v. m: b

   

2、有效的 Session 管理: Dao类继承HibernateDaoSurport后，Spring 提供了 HibernateTemplate，用于持久层访问，该模板类无须显示打开 Session及关闭 Session。它只要获得 SessionFactory 的引用，将可以智能打开 Session，并在持久化访问结束后关闭 Session ，程序开发只需完成持久层逻辑，通用的操作则由HibernateTemplate 完成。

3、统一的事务管理。无论是编程式事务，还是声明式事务， Spring 都提供一致的编程模型，无须烦琐的开始事务、显式提交及回滚。

建议使用声明式事务管理，Spring 的声明式事务以 Spring 的 AOP 为基础。可将事务管理逻辑与代码分离。代码中无须实现任何事务逻辑，程序开发者可以更专注于业务逻辑的实现。声明式事务不与任何事务策略藕合，采用声明式事务可以方便地在全局事务和局部事务之间切换。

Spring声明性事务有两种配置方法，一种是xml配置：

   
0 x8 ], z7 z, T3 \7 `6 N# S

        
. o2 \4 X7 I( m5 N# |# Q

   

   

        

            

        

   

   
9 L- E- v+ `+ Q0 z& D8 I9 F

        
: f+ l* a, G* I5 Q9 V

        
  ^4 R4 u2 r. {6 C+ b

   
% w! n# u' j1 Y( M, @$ P

另一种是通过注解，在需要添加事务的类上注明 @Transactional

Spring2.0之前事务的写法 * }, s# {7 A# @- I ) c6 V" c0 O7 n9 L6 l3 N" P6 u! W 3 E9 t: ?6 v+ Q        class=”org.springframework.transaction.interceptor.TransactionProxyFactoryBean” 3 h+ R! v, W8 `# `8 _ 3 w1 p: d: F7 l: w* q9 D        abstract=”true”> ) C. S' y0 y* B                 PROPAGATION_REQUIRED,readOnly                 PROPAGATION_REQUIRED ; M$ _" X* @8 d& q

" P' ~- M- R* ~) @
' m* S. C- N* }2 O/ l8 o0 t

• 谈谈Spring对事务的支持
  
  

1、声明式事务管理：

1.流程：由客户端访问—-aop监控—-调用advice来追加事务

2.做法：

2.1 在配置文件的头中引入xmlns：tx 和schema的文件

2.2

2.3 注入数据源

1 Q0 E6 h9 V$ @# d; j( O

% @% Z4 K! B4 r6 ^

2.4 由spring实现的事务管理，但需要注入数据源

1 H- ^9 g  ^3 z1 B8 [1 Q
. J( X8 w! S0 q2 d
/ {/ D# R  ]+ W$ ?

2.5 事务监控所有的方法（事务加强）

/ n7 p# b! |- \% O: s8 W+ m; y* x

2.6 定义切入点

" ^+ b7 h8 i- [+ S

* P6 {  {7 y6 l1 j; r3 W% Z
/ G- o8 l) D: i5 G

2、使用注解实现事务管理：

1.注解@Transcational

（可以在类上，也可以在方法上）

2.在配置文件中同样需要注入dataSource和spring的事务管理

3.使用注解的方法来追加事务 注解驱动

/ t1 G. s1 o3 i+ J& U$ v8 H

如何在Spring中使用Hibernate的事务：

如何在Spring中使用JTA的事务：

admin

ORM对象关系型数据库映射
1 O; s! b$ J! h) I8 J' J(Object Relation Mapping)

一、映射的特点
" G( g7 r/ o& N' W2 f; H9 g: V
/ K4 [2 ?* }+ T* o+ Q7 c0 r3 k1.一个对象可以对应多个表

# k* N; g: P3 S7 T2.一个表可以对应多个对象
1 k# j0 T# r8 X( U7 }- f4 N
3.对象和表的关系不用完全对应
5 i& o2 D: d' v, L( _- F2 \% c
( e7 x# C) N- K, e( D0 f4.对象的属性的名称和表字段的名称可以不同

5.类型可以不同，但数据类型之间可以转换
5 Y- X& w4 ?9 |6 a2 g# i+ S) i
6.对象中必须有主键，数据库的表对主键无所谓

# _! z% P6 Y- l8 u/ o0 r7.数据库中有主外键关系时，对象中可以有，也可以没有
7 P) T; q+ C! ?5 P' x
% j1 U- s( v. p+ D
0 D1 I5 a+ e: x! b- @
二 、有一个映射的描述文件————>xml
/ n/ j; d- H, i; |2 A
三 、怎样实现描述文件————>一段程序

对象 映射（mapping） 数据库

/ A' M9 G* L* yuser
$ @8 k6 D3 v* m5 c
* X  _& _- b4 O/ x$ vid=11
! z3 A, q+ c8 b  Q
) c" K8 o/ N' u: fname=”张三”———— > (1) —————> tbl_user(id,name,age,tel,address)
, B. J2 u3 q* V" p# W
age=25 <————(2) <————
. \# {5 b. L3 R2 N1 x) V
! {1 |# K# a0 L* \1 [

1 ~: R8 |9 [+ D/ ?4 z2 t% g0 S; i/ j(1)从对象映射到数据库
) F8 M  e# B/ w; c( O, V* ]2 `
1.JDBC
: W9 j- b/ Q8 q- |8 d! Q
' f6 w8 y, Z7 O; f2.根据描述文件来动态拼接sql
$ \: Z6 Y! ~/ A$ W3 Q( e9 f
+ s! O  b) ^2 W3.执行，添加到数据库中

% H% L, K- B0 p) S
! x2 H; F1 g, P  o
' _# Q. v; M& R# d/ u/ u/ t(2)从数据库中映射到对象

1.JDBC
2 R0 n5 B7 {% x2 g5 ^
2.拼接查询sql

: R0 v" r& U$ J) }( _% T3.ResultSet
% Y! N3 f/ @; p% V) T2 y# o
  M8 ^* G2 ~2 T3 h% B5 h) B" h4.Model
1 d5 q) s3 E( L' q, P. ~6 I
" N5 X) i: f) G( @- H7 p
# n% g8 B6 H# T
1 w" \! O5 F2 W0 F8 Q. Z$ B( {hibernate
# q0 U: p8 w$ C# C开发流程：

是什么？
" K/ I4 o  m9 ]/ u4 I- _7 g0 [hibernate是一种基于orm 的轻量级的框架


( \* F, p$ i5 F. b5 S0 |" [' X
- M3 m3 o- l4 [  c$ ~有什么？
1. session 保持连接状态（依赖事务和连接池）

2. Transaction事务
; B9 d! z0 d6 I7 O: M& c. ?, v
3.
Connection Provider 连接池
; \! f4 w/ t0 z6 v0 m6 e

4 E! s$ F. J' H5 g& r
能干什么？
$ j* S  ~, ?! S$ J- H1.orm
+ ?0 l; Z" K( d3 R) \; |8 H. @
2.提供操作数据库的接口，简化数据持久化的编程任务
& M8 s8 ^* n. N1 y8 `


怎么做？
1.搭建hibernate的运行环境，将hibernate的包和hibernate所需要的包拷贝到lib 文件夹下
! ]  E2 n7 m/ _- I
. y, S  j0 G0 ~) f5 K* Q2.O（vo）

3.R （关系型数据库中的表）

4.配置文件

4.1 cfg.xml 放在classes根目录下，默认名字为hibernate.cfg.xml
2 B9 f9 W1 g) S
: u( K5 ?5 Y$ N, {2 d$ Oa.与数据库的连接
! `) v" q2 G6 p* s' C, l
b.可选配置

8 e& z8 q! U) `! xc.映射资源的注册
; ~  P+ i4 q' w
4.2 hbm.xml文件 名字与类名相同 并且与类放在一起

& u' t+ F/ D, @8 ]6 {6 n, @3 Da. 对象与数据库表之间的映射

5 ~0 K4 x( p& W2 S+ P4 Bb. 对象的属性与数据库表的字段之间的映射

c.组件之间的映射
1 y" ~( Z5 M; }5 C! u- ^
d.对象与对象之间的关系映射
' u0 ~1 o( L- A4 I5 ~" v
5、客户端
, R; Z2 M. ^# n9 O9 t
1 e( l; a/ `7 W; l9 G* s1.得到SessionFactory
( R& D( o' H4 R; f3 V$ [0 `
: }0 O7 ~: v* u! ~' @1 {2.通过SessionFactory 工厂来创建Session实例
) e3 X; i1 K8 z2 r7 w# T
% U% L1 o$ i0 G( G3.打开事务

1 G" f" \& i; I* T" J. m, A4 a4 x2 V4.操作数据库

5.事务提交
: H9 }/ ~7 d' C& S# W9 I' t
6.关闭连接
3 h! u7 H( ~% b: t% s- W
运行流程：
- L  Y* S2 g0 Q: U. G. }
整体流程
1.通过configuration来读cfg.xml文件
7 P2 I1 ?& Z5 `* l0 I4 }
: f. I" h: Y2 j7 {( J) y' Y9 W2.得到SessionFactory 工厂（根据数据库的连接来创建sessionfactory）
1 G! c4 d6 R* O9 g, R
2 t' x5 o5 m3 v- b3.通过SessionFactory 工厂来创建Session实例

) Z. Y. j8 v* d1 ]* ^# D( W% w4.打开事务
! a+ ]+ t* {- M
2 U3 @' k5 \& c0 Y# V5.通过session的api操作数据库
+ q( i: P7 R5 R+ i, ]$ y3 x
6.事务提交

' s: J. g4 B6 \! q9 P7.关闭连接

. n9 X* M2 l; ^. R+ b% w

save
$ ~8 D+ d& l9 S, G( X4 h, _1.to—>po

. T* `0 f! r' |0 o+ e2.根据model和cfg.xml中映射文件的注册来找到hbm.xml文件

9 f' n5 T( f& O/ t3.根据hbm.xml文件和model来动态的拼sql

4.客户端提交或者刷新内存
$ {3 d: g9 N- w! m1 V
; \6 L& L: G* Y% B7 Z' c; p- [5.执行sql，值放到数据库



+ X# C7 f' }4 T8 d2 ?2 zupdate、delete
1.根据model 的id在内存hibernate的缓存中查找该对象

+ p! k% _3 \' `' `: v如果内存中没有就到数据库中查找来保证对象的存在

" L5 O# L9 A; d4 w9 Q2.根据model和cfg.xml文件中映射文件的注册来找到hbm.xml文件
/ e; m/ a$ ]  N
3.根据model和hbm.xml 文件来动态拼sql

) ~, a% s, R/ K4.客户端提交或者刷新内存
: |$ m' w& K  u+ O" q
5.执行sql

- M" N$ F2 N  ^0 S' k: k' O$ x: t, |
2 R' G) \. ]% ^) C4 V3 ]
Query
- \( m! f0 `! qload
$ O5 k3 W# u4 q9 c
1.根据model的类型来找到hbm.xml文件
- r0 W: n0 @, Z! k7 H; d* Z8 p
+ a5 k$ `: y7 T) Q$ _) C( c$ X1 O/ h2.判断id对应的对象在缓存中是否存在，如果存在，就直接使用，如果不存在就进行下一步。

3.用id做为查询条件来动态拼sql
9 G9 m/ d" s8 I) K* u! R6 G# _6 a
: Z0 t, L1 y! D5 [4.执行sql 查询（先在内存中查找，如果没有找到（会抛出例外），就去数据库中查找）
, y, s7 Q% F/ q) P  u7 F7 }" ~
5.返回一个model类型的对象

% D' ]: {1 q4 z: V$ i0 s& i1 }get
7 h$ q8 \. k! G! |; N
    1.根据model的类型来找到hbm.xml文件
0 O+ O  U6 w* l. Z
& |- ~) e) t/ w2.用id做为查询条件来动态拼sql

; ?5 I# E( R) q( x  I( k3.执行sql 直接在数据库中查找，如果没有查到就会返回null
8 G; ^4 Z- u; Y9 |' |1 N: V
query

9 E" ]/ n. [/ R  |0 o" ]$ Z6 Z1.分析hql语句，得到model的类型

. X" ^. e5 H! _' |2 t2.根据moedel和cfg.xml文件中映射文件的注册找到hbm.xml文件
! M! V$ I  U+ V! D% u" ~- ~
3.根据model和hbm.xml文件来动态拼sql
$ P9 g* n2 [/ t  `- A) c
% Q2 t  g$ ?: J4.执行sql查询数据库

5.返回一个resultset

6.循环resultset的值，放到model中在放到集合（List）中
$ @5 W  P0 V; O0 W& ?# T
" Q+ n# V3 o! C* L6 B
7 J& l* ]) w6 p" D+ ?9 w7 G
谈谈hibernate缓存机制

& a8 u# b0 Y) a缓存其实很直观的理解为放到内存或者硬盘上的一块区域，缓存就是一个缓冲的作用，有很多时候，我们的数据需要经常访问，如果放到数据库中，不是不可，只是效率上低，如果有了中间产物来代替数据库，就省很多事情了。打个比方，去买酱油，不一定一定要去酱油的生产工厂去买。代码中需要数据的时候，可以先到缓存中查找，如果存在，就直接拿数据，不存在就去数据库中取，也省了很多事。
0 ~. h8 y/ w9 v7 s# g- I+ n

: H3 Z, w8 G: F
hibernate使用的是二级缓存，有两个级别，分别是Session，SessionFactroy级别，一级缓存是Session级别的缓存，Hiberante来管理的，这个我们一般不用管，二级缓存是SessionFactory级别的，可以进行配置和更改，加载卸载，就是我们平时用的hibernate配置文件中的配置SessionFactory的属性。
6 w0 \% o9 |6 m
' N: E* {2 O* d
2 A( F$ o# T$ H4 H2 C/ A( ^/ R
" G1 H, w4 G3 ?$ L9 r对一级缓存中的session事务进行数据的预存取，数据在各个session的上下文中存在（单例），当session关闭时，就是session.close( )，整个所有session范围内的数据全部清空；二级缓存默认的情况下是不开启的，如果开启，数据库汇总的所有数据都先copy到二级缓存中，这里要注意的是，一级缓存是每个线程下创建的session缓存区域，可以是多个，二级缓存只有一个区域 ，画个图比较容易理解。
0 X. R; `. l  X# Q, n

0 C4 ]; U9 J/ J
  a4 ?0 o# r" D% |0 D+ G+ \| 一级session缓存| | 一级session缓存| |一级session缓存| |一级session缓存|
8 a& \; E( g2 A$ i: r
| | | |

| | | |

—————————————————————————————————
2 ^, `  q; C5 G2 H5 ~
1 L; F6 F" _$ M3 n5 l$ YsessionFactroy级别的二级缓存

# ^8 i5 W5 w% J——————————————————————————————————————-
7 O2 \1 v7 v6 J
# T  T8 }) I2 g/ m) X1 n- X|
9 ^( b4 _, `2 L5 f! C6 L
8 J7 v7 C5 U; m0 c! X  H|
* g% r$ E" K$ l2 i
: ^. M' |, p1 G, P6 A& R. v|

——————————————————————————————————————

" W, \1 H. h4 H. J* Z7 n2 ~/ _DB
1 c' ^$ E1 G* p7 C- V8 \
+ @8 c# {3 \7 O! D% {% b' {) h—————————————————————————————————————–

admin

在tomcat下配置数据源
1、服务器与数据库的连接

- ^3 x4 S, c( P: R配置server.xml文件
1 @/ O. ~. E" W: H
1.oracle

<Resource name=”jdbc/company” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”

                        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”

: o% _' {; k% Z7 e% O: t3 x# _url=”jdbcracle:thin127.0.0.1:1521rcl”
3 [3 ?$ C& |3 W
driverClassName=”oracle.jdbc.driver.OracleDriver”
8 F. c5 g: W6 R. X
2 }% W+ G, D& ]username=”aa”

; M. D: U3 [) l* {  E, Tpassword=”aa”

maxActive=”50″
, Y  A. q  |* v4 A$ g8 t
6 a$ G+ J$ v8 o/ OmaxIdle=”10″

maxWait=”-1″
  m  c) E- g) c' v) q
, i  D& M! C: n. x9 [$ f/>
" |& B7 @( ], s' N
% [! o; ^- K$ m. b) T2 K! ^2.sqlserver
9 K% k% |& k+ s. J& G9 x2 `$ }
9 f. h" h3 }) a2 p- w+ T<Resource name=”jdbc/webpage” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”
; |7 j! I5 A8 x, A# l3 K2 q1 X
        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”

' q3 V: m- n" u. j8 Nurl=”jdbc:jtds:sqlserver://localhost:1433;SelectMethod=cursor;

DatabaseName=webpagetest”
, F' j- m& k) O
2 Q7 c- w3 j( U- b9 W( z8 \driverClassName=”net.sourceforge.jtds.jdbc.Driver”
3 z1 d  G- ?( l7 E" l$ s8 {
0 ^; Z" {- w! `. `& S* l6 Musername=”aa”
, R4 y9 A; P. D* Q$ M/ e, T
password=”aa”
( t$ _. `; d' F6 ^  B
maxActive=”50″
* Z4 C8 E6 Z5 W. T, t# ?% S
maxIdle=”10″
: t9 i2 n6 Y( ?* r
3 X' x+ v" K2 R9 r" qmaxWait=”-1″

9 H5 g# [- w1 u; G0 g9 Z' A5 `- I7 _/>

2、配置自己的web应用的xml文件



; O+ d' k" T! `/ x: c8 w2 P# ]9 T<Context path=”/eb03web” docBase=”F:/workweb/eb03web”
2 D, ]3 Z% }5 _5 E; U2 c  s+ k
, h- \4 w8 c, h, y( N9 @privileged=”true” antiResourceLocking=”false” antiJARLocking=”false”>

<ResourceLink global=”jdbc/company” name=”jdbc/company” type=”javax.sql.DataSource”/>

</Context>
5 V( R! E/ b3 t" T# ~. ?
- C9 {4 r. q8 w( D# }* B

3、配置web.xml文件

4 C* s" a# s' U4 O! R与服务器建立连接

, N& S- c, N0 ?! N<resource-ref>

<res-ref-name>jdbc/company</res-ref-name>

; e5 c: \3 L1 \8 `<res-type>javax.sql.DataSource</res-type>

3 E& _! {' V& k2 q, a9 {* ~5 t<res-auth>Container</res-auth>
) a  g/ V4 m. Y9 P0 ^  T
4 V# c% n% ]" y1 w+ e6 x) K: [</resource-ref>
. e3 P+ d% d7 E& |# n
7 P* q9 m/ t( p  m- Y5 l1 _4、在应用程序中不直接与数据库连接，通过DataSource连接池建立连接

. _5 p/ f( [( X- ?3 Y//1.在程序单独用时设置系统的属性，在tomcat下可以不用配置，
; z. X9 F2 H- S( L' d; W, Q
* }* N- x- e/ {7 Q3 mSystem.setProperty(Context.PROVIDER_URL,””);
4 k2 R( }7 G0 x3 s$ B
( b5 y6 o7 e( U% f" XSystem.setProperty(Context.INITIAL_CONTEXT_FACTORY,””);

//2.创建一个上下文对象
1 y$ T5 S% Q! a; @0 l
* X- [2 V& N. E2 j+ b; U. X' ZInitialContext context = new InitialContext();
8 `+ \* }& P! u" O
//3.通过上下文对象在连接池中查找DataSource
7 f4 |, C$ u6 p6 r- N: l
# v$ y7 g1 [1 u) {4 EDataSource ds = (DataSource)context.lookUp(“java:comp/env/jdbc/company”);
+ k, `+ K( _  n+ I  @" J- }. D. ~( u
//4.通过数据源建立连接

ds.getConnection();

admin

Jsp
  c" T6 ?; J% g8 K什么是Jsp?
Java Server Page    结合java和html在服务端动态生成web页面的技术

- D1 j  B8 B% e( H4 }& ^; X( i' w' K
- n& C  C( n1 _
描述Jsp页面的运行过程？
6 m, ^0 r9 |! E+ F  j) K第一步：
% i- O1 }# x" K: w- `
请求进入Web容器，将JSP页面翻译成Servlet代码

4 h! ~9 z* l) G6 Z8 i* b2 R第二步：

编译Servlet代码，并将编译过的类文件装入Web容器（JVM）环境

4 z) X" U- @6 S  G- y第三步：
5 O7 d& r9 x, {
Web容器为JSP页面创建一个Servlet类实例，并执行jspInit方法

第四步：

Web容器为该JSP页面调用Servlet实例的_jspService方法；将结果发送给用户



6 @2 d* H4 v, d. c& ?! q' W& N描述Jsp页面的五类脚本元素的功能、写法、并示例
3 o' D% o4 V4 N3 A注释 <%– –%>

3 m, S+ A9 z2 ^) ?! b. m5 ~<HTML>

<%– scripting element –%>

# ^6 a! G( J) k2 ?</HTML>

指令标记 <%@ %> 指令标记影响JSP页面的翻译阶段
9 V/ n; V7 A: F, V; b: ^# }! r
3 v2 x5 k5 y# Y; \" w<%@ page session=”false” %>
% c. h  H+ l' P9 b# P6 t( m& f
3 }6 @- I( Y9 V7 ^# w声明标记 <%! %> 声明标记允许JSP页面开发人员包含类级声明
4 G8 N# J9 a4 d, p/ @( h1 B
) W& F) E4 k. ~* o) G+ V<%! public static final String DEFAULT_NAME = “World”; %>

. ?6 _: g# I/ w0 S  h2 y+ `( [    脚本标记 <% %> 脚本标记允许JSP页面开发人员在_jspService方法中包含任意的Java代码
. ^5 c1 I# q1 P1 a; E
8 B6 e' D3 {' ^9 F* `/ R* M    <% int i = 0; %>
: m: M; K2 o3 H! `" @8 u. U
表达式标记 <%= %> 表达式标记封装Java运行时的表达式，其值被送至HTTP响应流 <B>Ten is <%= (2 * 5) %></B>

1 N$ r  T# m% [
/ T( X7 Q! Y8 B* q
描述Jsp页面中的注释种类和写法
HTML注释

4 p7 _# L+ O, G# @; f* p" @<!– HTML注释显示在响应中 –>
  f+ M( V3 X5 u4 _1 U" n1 K5 W
JSP页面注释

<%– JSP注释只在JSP代码中可见，不显示在servlet代码或响应中。–%>

: c6 r2 v. i0 I! G: jJava注释
! u: {' C8 F1 s% ]# I
  n) e4 i. F  \4 ]: ?<%
: u5 U5 r  N+ C  @
" w) I# }1 I( r/ {/* Java注释显示在servlet代码中，不显示在响应中

*/
# {1 f$ Y0 @( F3 K1 S' N7 B: R! a
%>


' ]! O6 H; p+ ]7 o
描述Jsp页面的指令标记的功能、写法、并示例
指令标记影响JSP页面的翻译阶段

! c, p2 I) `% C' \, d9 Y& h<%@ page session=”false” %>
7 c0 j, ^- [$ t$ f* m
<%@ include file=”incl/copyright.html” %>

<%@ taglib %>
7 H% e  Q7 E1 w3 K$ |
( H+ p$ i8 J4 s5 y; l. N

描述Jsp页面的声明标记的功能、写法、并示例
. _2 c+ \9 l3 e! w声明标记允许JSP页面开发人员包含类级声明
8 V' i9 Q* K! w, \8 |' w
0 F* H& s& N* P5 Q写法：
  R; w' k) z3 d! Q' z
$ F% r5 _2 Y( o) c# k<%! JavaClassDeclaration %>

, [& Q- @  [5 G; ^2 x0 P% d例：

<%! public static final String DEFAULT_NAME = “World”; %>
  e+ T( M1 w, u4 k* z; e1 _
<%! public String getName(HttpServletRequest request) {
& G5 t: X6 X* W# x# ^0 {
# W0 I& J0 U& N* treturn request.getParameter(“name”);
- O  }1 T5 G5 @) K- A
0 K1 z! E( G) V3 p}

%>

3 f6 d+ i1 w6 u4 I1 i) m* C6 t<%! int counter = 0; %>

: D- A: C9 r. x* p

描述Jsp页面翻译成Servlet的规则
$ X4 s% p( F7 h' M; r6 ^jsp中的注释标记被翻译成Servlet类中的注释
" I$ t( c. {7 l% t0 b/ Q
jsp中的指令标记被翻译成Servlet类中的import语句等

* B: \8 h$ o. tjsp中的声明标记被翻译成Servlet类中的属性

jsp中的脚本标记被转移到Servlet类中service方法中的代码

jsp中的表达式标记被翻译成Serlvet类中的write()或者print()方法括号中的代码



+ a  e+ y3 q: ]4 l3 h2 ?7 y8 z描述Jsp页面的九个预定义变量的功能、用法、并示例
request 与请求相关的HttpServletRequest对象

4 a/ k/ @; {( G( T* M6 m0 @response 与送回浏览器的响应相关的HttpServletResponse对象
! a  L. p% ?) n8 u
out 与响应的输出流相关的JspWriter对象
6 V4 p9 ]! {4 T% Y8 _
5 G5 F& e5 E& A) C( R    session 与给定用户请求会话相关的HttpSession对象，该变量只在JSP页面参
/ G, X! O( \/ w! Q2 e( U
1 E9 V* r4 o# @! n- f与一个HTTP会话时有意义
! [* ?. T5 u0 s' \  `1 ^
- u& ^! o7 K* @5 h  Q5 [    application 用于Web应用的ServletContext对象
1 |( {/ q! M  ^  n' T1 @
config 与该JSP页面的servlet相关的ServletConfig对象
) X+ n) n! }7 X  a- i1 S! X
pageContext 该对象封装了一个JSP页面请求的环境
8 L$ {0 U+ z; ^7 [3 T  T
page 该变量与Java编程语言中的this变量等价

    exception 由其它JSP页面抛出的Throwable对象，该变量只在”JSP错误页面”中可用
, j6 Y2 P# K  o; H


# y! f5 F+ {9 ]2 G" _$ zpage指令的功能，写法、并示例，并描述它的如下属性的功能和用法：import、session、buffer、errorPage、isErrorPage、ContentType、pageEncoding
. d6 b, q0 t7 U5 i* {/ C6 yimport import 定义了一组servlet类定义必须导入的类和包，值是一个由

逗号分隔的完全类名或包的列表。
0 b, [( e7 [' u
session session 定义JSP页面是否参与HTTP会话，值可以为true（缺省）

或false。

8 K1 j& N  @, V( }% |5 R; Sbuffer buffer 定义用于输出流（JspWriter对象）的缓冲区大小，值可以为
" Z  U. i/ |: ~5 j
none或Nkb，缺省为8KB或更大。

8 F/ a* d0 V0 r' r- L) q  }" h$ VerrorPage 用来指定由另一个jsp页面来处理所有该页面抛出的异常

isErrorPage 定义JSP页面为其它JSP页面errorPage属性的目标，值为true或

false（缺省）。

9 |- \; h  Y6 @# T7 b% m3 NContentType 定义输出流的MIME类型，缺省为text/html。
$ k- M5 {7 L4 H) B
pageEncoding 定义输出流的字符编码，缺省为ISO-8859-1
! j; L: o! F9 J+ R+ J& I9 Q
0 L7 G6 d" K% g& i, @% [9 Y

& |+ z$ b: Y; Y4 u( D  U描述MVC各部分的功能？MVC的优点？MVC的缺点？
& |/ w5 [3 F% T6 I" ]2 J% m9 JMVC各部分的功能：

Model（模型表示企业数据和业务逻辑）
3 L+ f  J- ?6 |: k$ m
封装应用状态

/ j2 O; _1 ~7 M( n# @7 F响应状态查询

: I# a( m# |2 b- h暴露应用的功能
( ]1 T" O! O! B+ m
8 u, l5 I6 \/ z( `* i4 `9 d4 a: z8 MController（控制器接受用户的输入并调用模型和视图去完成用户的需求）

验证HTTP请求的数据

- _8 [6 U" U: }8 G' E8 O将用户数据与模型的更新相映射

选择用于响应的视图

View（视图是用户看到并与之交互的界面）
! x$ v# T; U1 R" Y# k$ `
产生HTML响应

7 w. r# u1 p% k请求模型的更新

9 ?& N6 ?2 E" U1 e8 _  j* c提供HTML form用于用户请求
/ I( R  F1 l; Z" t* d5 C% J) ]
4 x. K1 {* ]; L3 [/ m2 O8 j/ s: u9 YMVC的优点：

1 k7 }$ {1 U, H  q        低耦合性：视图层和业务层分离

高重用性和可适用性
. \6 S$ g& T8 x
, G+ z/ n; Q0 d. d9 e较低的生命周期成本

快速的部署

" T. O2 k# j- I6 _+ S可维护性

, i1 [6 y' S/ _4 O! P有利于软件工程化管理

9 d2 T2 J+ H" R. y5 Y* ~提高软件的健壮性
- G) e( Z" ~! u$ {
2 b5 \" S1 q9 }4 B+ o) B, }MVC的缺点：
% [1 r, z& W3 Z& m: Y2 u- b1 @1 \
        工作量大，增加工作的复杂性，MVC不适合小型甚至中等规模的应用程序
- ^# M4 T! z1 v5 i, h
  P. t0 q1 J0 A% o9 Y

什么是Model 1结构，以及结构中各部分的功能
结构：jsp+javabean

Model1中使用jsp来处理web应用中的视图控制部分
6 L/ j9 h! b0 k  H
! X5 ^! ]( |" I& @5 t5 r( ]  v+ _7 aJavabean收集参数
; T1 i. W4 C2 [3 b9 ^


什么是JavaBean?
用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。
0 R' A% f- M7 K. s# ?

$ r5 J3 \! \# f* P4 O+ Y
JavaBean的规则？
3 A4 G& g% T' @- V, t  Q使用get和set方法定义属性

2 W  k9 G& E' a" F+ I) q* s一个无参构造方法
9 Z, ~4 r/ y7 t  S% b+ M' d; E0 t
无public实例变量( 所有属性私有化)



9 b. j( z- M0 \# l9 _% e什么是jsp标准动作？包含那些？分别都是什么功能？如何使用？
' e9 L5 x6 \! [' `1 O6 q- jJSP页面中使用类似于XML的标记表示运行时的动作
, z& h0 b; a/ ~- j/ B* V& Q
1 M7 [$ N; W: [2 s- Njsp:useBean

4 C; F4 z- X  y+ |jsp:setProperty

+ ^6 `/ E5 W" H+ V" R% s5 |jsp:getProperty

- W5 k6 T3 p% [/ {jsp:param

5 d4 w9 I1 i8 O5 djsp:include

& k5 v, ~5 ?) Y2 Wjsp:forward
& Y8 }  l/ x7 Q, E' a  b( J- O

$ _& A- e4 Z* }) U. a7 K! ~
用代码示例如下标准动作的使用：useBean、getProperty、setProperty
  i' q' x8 N9 ]4 I( g<jsp:useBean

id=”myForms”
" _- ?  H3 K  M; X3 d, l
class=”com.base.mystruts.forms.MyActionForm” scope=”session” />

! E  p9 {0 j: h+ |& J    <jsp:setProperty name=”myForms” property=”name” />

: L) l% Q, ^7 O# Y2 Z  ?2 z<jsp:getProperty name=”myForms” property=”id” />

# u2 O5 S) q/ y

" A) U0 Z0 R. ]3 s9 q" r: }: ~描述说明Bean的四种scope
page

request

9 c6 I# L$ J! Q1 x5 f7 W& j8 vsession

application

7 y3 V( r) V4 y" w5 h" T
% }% ]  x; a- n& t3 I$ O+ o3 Y
1 \( f* k! R" ^7 x2 u描述说明页面上的字段和Bean中属性的对应规则
- f$ R  U! }2 S1 `1 d4 B$ mid 指javabean的变量名
6 E3 {. S  y% {
class指javabean类的全路径

, {2 `2 g* N) [4 B6 Z; Nscope指javabean的应用范围
( }4 x$ ~7 n2 l& H( p
name指所用到的javabean的变量名
2 T* i9 [# X6 v- z
    property指javabean中的属性

' O. M$ f" I) Q0 m& N' L# i

1 l9 f/ ^1 @0 p描述useBean动作的处理过程
* U9 @# N( r( r1 W& I# O使用id声明变量

试图在指定的范围内查找对象
; l4 M: c3 Q( K  i9 g+ U# n
4 p0 c% o5 [3 E9 M如果没找到

% d% N& W& O1 E, A3 n创建一个类的实例

0 i: ]& f! ^" l4 d6 j" `执行useBean标记体初始化对象
4 @3 Y0 x; W; o. J8 Z7 M
如果找到

     将对象转换为类指定的类型



描述forward动作的功能
% E: z8 L2 D' S; L) S使用脚本代码处理请求时，可用jsp:forward 动作产生一个不同的视图，
% X, B' \1 R5 Y& j3 a6 {( `
使用同一个request：
2 Q; a' \2 o& K

* v+ i5 C  p2 n
- l, P  B% u( M" F0 V! R什么是Model 2结构，以及结构中各部分的功能
* K; X9 j) F' }  F1 V# djsp+model+servlet
" F$ A# A, ?) J0 N' e1 `( A
3 x! a$ T9 w: \2 q  p( G# HModel 2架构使用MVC模式，JSP页面充当视图，Servlet充当控制器
* g0 ^; b8 d+ _+ F1 R
Servlet控制器：

) c4 R- L. A# i验证HTML form数据

调用模型中的业务服务
# X8 q, f- |3 K* r
4 x, S5 q& v& s. r8 L6 q* Y# y存储请求（或会话）范围内的域对象
/ ^8 _/ v" c6 Z* L( X
9 Q9 ?/ h& ?7 F4 C* i) }选择下一个用户的视图

( X7 F/ Y; Z9 V# }8 oJSP页面视图：

( _" c, c6 H* ^+ p5 p使用用户界面（在HTML中）
) X# I4 }9 b6 t" s9 u  r  ?1 ~
        访问域对象



) p* {4 g- m1 s- b, K3 I- F如何获得分发器？分发器的功能？
上下文对象中的分发器：

4 u) r' w* ]& r2 O  q& `ServletContext context = this.getServletContext();

RequestDispatcher servlet = context.getNamedDispatcher(“MyServlet”);
" Y/ @9 [/ R- K* n: s; J
servlet.forward(request, response);

请求对象中的分发器：
/ s4 w& @1 e& f4 j6 P( B
) l" N3 R6 r6 h  xRequestDispatcher view = request.getRequestDispatcher(“tools/nails.jsp”);

' ]4 H: }! c. ]- E+ Lview.forward(request, response);

可以将请求转发到另一个jsp页面，并保持请求的传递性

5 C3 w" E# m0 p

3 B' ]4 A$ i4 @9 N9 S7 NJsp中页面跳转的两种方式？
使用分发器跳转页面
: M0 {$ Y) _& gRequestDispatcher dispatcher = request.getRequestDispatcher(“url”);

dispatcher.forword(request);
1 w0 V9 ^6 a4 }3 ?: u
- |: `* C& u9 p5 D    特点：保持请求的传递（上一次请求中的数据，在下一个请求中仍然可以得到）；
' w8 S( [! N2 S7 b& [* }
        转发的页面只能是同一个Web应用程序的其他Web组件

使用重定向跳转页面
7 `" h! n& J# Z8 H2 y, Yresponse.sendRedirect(“url”);

    特点：产生全新的请求，（上一次请求中的数据，在下一个请求中不能得到）；

' H' Q7 g, f2 i! c6 C        重新定向的页面可以是任意的URL
( m) B# M6 k- y% k, ^/ \; i


描述Jsp中引入另外页面的两种方法，并比较两种方法的特点？
$ \/ C( \( ~" d2 Z7 ~8 F5 l<%@ include file=””%> 在编译期间把另一个页面完全嵌入这个页面,可以说是一个页面
. ]! f0 A4 ]3 f; D' a
8 y9 I3 M9 z- K在这里可以共享变量
: F0 s/ F7 |. c7 C/ v3 R6 Y6 y
<jsp:include page=””> 动态的再运行期间把另一个页面加入这个页面,可以说是两个
! d- _. r1 `6 j$ r
' ?" K" z, {0 n6 q$ U页面，不可以共享变量
! m9 o8 z. X6 V, O) _

4 ?. U# [; U. ?6 }2 }0 C1 g
什么是自定义标记
自定义标记库是一个Web组件，
6 \' \# T# k6 m. }
& G  o- b* X/ i+ k包括：

一个标记库描述符文件（*.tld）
3 q3 {$ G/ @! g+ s
所有相关的标记处理器类(*.jar)
0 f6 C  u2 R/ n- O/ z
8 t/ C- b) q$ u: C

描述使用自定义标记的步骤，以及每步详细的工作
使用自定义标记前，要拿到.tld和.jar两类文件

4 i# U8 @3 L$ X" r把.jar文件放到WEB-INF的lib里面。
/ a9 Q. D+ w& Z- \6 R% |8 ]  I+ T把.tld文件放到WEB-INF根目录下。
在web.xml中配置。
/ ~, X* I# V! n<taglib>

<taglib-uri>http://java.sun.com/jsp/jstl/core</taglib-uri>
% K* A- P4 S# d4 w0 ^1 V
3 {+ y$ v' U( R; [     <taglib-location>/WEB-INF/c.tld</taglib-location>
  b( G7 `  x6 X
/ a4 w  e, e2 I7 c</taglib>

' E* @* q6 \: F5 G8 N1 K( }8 x在页面中引用。
, O) E: \/ \9 F% d. `4 [8 F<%@ taglib uri=“http://java.sun.com/jsp/jstl/core” prefix=“s”%>

uri必须与web.xml中的uri对应

prefix是前缀，用来区分是哪一个taglib
6 L1 D9 ~+ _% O4 H2 V% d; a
使用标记
4 p" f. ^  o, O7 m: N. T' r格式：<prefix:tag名称 属性>

9 @* z' F% f  e  c<s:forEach >

admin

Servlet
4 H: [" G+ ^: P' h% ^

•     描述war包、jar包、ear包的结构
  1 n; C" ~1 X" |" w+ B/ f
  
  

war-                            web文档压缩包

—WEB-INF

—-web.xml            web应用部署文件

—-lib                本web应用需要的jar包（可选）

—-classes            本web应用需要的类文件（可选）

jar-                             java文件压缩包

—META-INF

—-*.MF java包的启动和描述文件

0 z) Z; T+ \8 d& b% {) K) W4 }

ear-                            企业资源包/企业应用包

–META-INF

—Application.xml 配置文件

–*.war

–*.jar

• 什么是servlet？servlet主要做什么？
  
  
    E+ D$ r8 O9 p5 L

Servlet是运行在服务器端的小应用程序，是接收网络服务的请求和产生响应的一种方式。

servlet的功能：接受http请求，产生动态http响应。

• servlet 与cgi相比的优点？servlet的缺点
  # T7 t& R& H* Q7 U7 _( W' A7 }2 W6 l
  ; K' N; w3 x8 I$ k0 H4 s# c4 H
  ' V/ O3 I$ o( a- o4 [: S9 d

优点：

性能（线程比进程更快）

可伸缩

Java强健且面向对象

Java平台独立

缺点：

处理代码（业务逻辑）与HTML（表现逻辑）混合在一起

• 常用的servlet包的名称是？
  ! {$ D, ~! J- M6 n3 m$ F
  * i! X7 O0 h$ U* z
  0 x6 k4 t& \' `( O, V& s7 d8 b

javax.servlet

javax.servlet.http

• 描述servlet接口的层次结构？
  6 g6 h- n& t" y
  ' p, E6 i% Q& e! O. J" X
  

Servlet

–GenericServlet

–HttpServlet

–自己的servlet

ServletRequest

–HttpServletRequest

ServletResponse

–HttpServletResponse

+ i3 A3 X2 i$ i$ e% J) n) Q( u

• 对比get方法和post方法？
  
  
  

get方法： 请求对服务器没有负面影响，Form数据量小，提交的数据在url中可见；

明文传输，安全度低，不可以传输中文。

post方法：请求的数据过程改变服务器的状态，Form数据量大，提交的数据在url

中不可见，安全度高。可以传输中文；

• 归类描述HttpServletRequest接口都完成那些功能
  
  ! c! D& V; P2 ]; j, h" n
  
  • 读取HTTP头标
    
  • 读取cookie
    
  • 读取路径信息
    ( a4 ?+ i: x+ S/ e/ ^- z
  • 标识HTTP会话。
    
    

• 归类描述HttpServletResponse接口都完成那些功能
  
  $ C  ^' r- O* k) o* d9 H
  
  • 设置HTTP头标
    
  • 设置cookie
    
  • 设定响应的content类型
    2 }8 i: ?  |, X) F: P; H: D
  • 输出返回数据
    % w+ O9 l4 t0 g# Z2 r$ |- f( Y3 t
    

• 描述service方法所完成的基本功能？默认是在那里实现的？
  & v! ^+ g% K8 d; H6 {+ D
  9 v2 E0 }# J, U
  

基本功能：service方法是在servlet生命周期中的服务期，根据HTTP请求方法（GET、POST等），将请求分发到doGet、doPost等方法

实现：默认在HttpServlet类中实现

• 如何开发自己的Servlet？描述应该做的步骤和每步需要完成的工作
  
  
  

1.引jar包

1)构建开发环境： 新建工程，把tomcat下lib文件夹下的servlet-api.jar引入到Eclipse的工程中

2.开发servlet类

1)首先继承HttpServlet

2)重写 doGet( ) doPost( )

3.部署

安装web服务器，例如Tomcat

在Tomcat的webapps目录下新建一个文件夹作为web应用的根

    在根下新建一个名为WEB-INF的文件夹，里面建立一个web.xml的文件、一个classes的文件夹、一个lib文件夹

    按照servlet的DTD配置web.xml文件

把编译好的servlet的class文件复制到classes目录下

lib文件存放程序所需要的jar包

4.启动服务器

• 为何servlet需要部署描述？
  
  ( {) O3 Y+ V3 H3 b7 {' q9 ^$ @
  

servlet需要配置web.xml文件来使容器认识servlet程序（web组件）

/ _, N) j5 Q" q6 ~" b. n5 |. j

• Servlet基本的描述应该是？请写出来
  7 [4 s% e" D+ P4 Z) \
  
  

<servlet>

<servlet-name>Hello</servlet-name>

<servlet-class>com.javakc.web.action.MyServlet</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name>Hello</servlet-name>

<url-pattern>/greeting</url-pattern>

</servlet-mapping>

• 如何在html中使用servlet
  # X+ E( Y, r5 G- h+ t  D
  & D% ^8 c4 W, t# v8 Y; e# R# C/ K8 r
  $ G1 @* c& s) G1 f6 i! J/ f

FORM标记

ACTION– 指定form信息的目的地（相关的URL）

METHOD – 指定HTTP方法（GET或POST）

语法：

<FORM ACTION=’servlet-URL’ METHOD=’{GET|POST}’>

{HTML form tags and other HTML content}

</FORM>

• 如何接受request中的参数
  
  ' [! S8 b' @( eString userName = request.getParameter(“userName”)方法
  . `: p6 U! \5 ?% s
  5 M& l5 _* f# V: Y0 g; ^

• 如何接受request中header的值
  
  4 b  n9 s: b" m) _
  

request.getHeader(name);

request.getIntHeader(name);

request.getDateHeader(name);

request.getHeaderNames();

• 如何输出html
  5 n7 e7 u% d; K% q
  + c5 ^3 X+ A: c1 N1 ~9 Y7 T) e
  7 R$ H3 c* w% ~$ s" Z1 Z  `

PrintWriter pw = response.getWriter();

pw.write(“<html>”);

pw.write(“Hello”);

pw.write(“</html>”);

• 如何设置输出的contentType
  
  
  ( t1 n  {7 {$ E+ r

response.setContentType(“text/html”)

• 描述servlet的生命周期？
  
  
  

生命周期是指servlet实例在web容器中从：首次创建调用init方法开始初始化期，经过service方法运行期，一直到destory方法销毁期    结束。

servlet实例的生命周期由web容器来管理。

• 描述init,service,destroy方法的功能和特点
  
  
  

init方法： 是在servlet实例创建时调用的方法，用于创建或打开任何与servlet相的资源和初始

化servlet的状态，Servlet规范保证调用init方法前不会处理任何请求

    service方法：是servlet真正处理客户端传过来的请求的方法，由web容器调用，

根据HTTP请求方法（GET、POST等），将请求分发到doGet、doPost等方法

destory方法：是在servlet实例被销毁时由web容器调用。Servlet规范确保在destroy方法调用之

前所有请求的处理均完成，需要覆盖destroy方法的情况：释放任何在init方法中

打开的与servlet相关的资源存储servlet的状态

5 E4 o; A  ~( }1 A

• 什么是回调方法？有什么特点？
  % R0 S+ N+ o, Y0 l7 t& b
  
  

由容器来调用程序的方法

由容器来决定什么时候来调

• 如何设置初始化servlet的参数？
  ( P! \$ w1 a2 }/ k: D
  / h% M! h( ~- X! r- {2 H在<servlet>中添加如下配置
  ! O7 ^) T6 X+ N
  : [* C5 R- H2 t  R5 K  D

<init-param>

<param-name>greetingText</param-name>

<param-value>Hello</param-value>

</init-param>

• 如何获取servlet初始化的参数
  ! @+ L3 V; u. N" c( N/ \  ~! p4 J
  
  " Y( R3 E) T; c2 E/ {, {

public void init() {

greetingText = getInitParameter(“greetingText”);

System.out.println(“>> greetingText = ‘” + greetingText + “‘”);

}

0 Q' ^1 U% M4 r0 ~8 w) w9 E+ V

• ServletConfig接口默认实在那里实现的
  ) K; N  a# L2 ?- _3 ~2 r: u
  # u0 ~. N/ N( p$ ^* L7 b. h
  

GenericServlet类实现ServletConfig接口

• 什么是ServletContext？有什么作用？
  
  + x$ j: s. f# }, O% E) z
  : `. m3 c% E, Y) t

Servlet上下文

ServletContext对象是Web应用的运行时表示，约等于整个web应用；可通过其实现Web应用中的资源共享

% x/ ^7 X0 _9 ^. W+ ]2 A8 Q

• 如何访问ServletContext接口？是在那里实现的？
  
  
  

在Servlet的实现类中通过this.getServletContext()方法访问。

GenericServlet类实现了ServletContext接口。

• ServletContext接口的功能包括？分别用代码示例
  6 k: E# @/ T3 [$ j' n3 z- ^, E
  
  . s, r' }% V( t' O! h

只读初始化参数：     getInitParameter(name:String) : String

getInitParameterNames() : Enumeration

读写访问应用级属性：getAttribute(name:String) : Object

setAttribute(name:String, value:Object)

getAttributeNames() : Enumeration

只读访问文件资源：    getResource(path) : URL

getResourceAsStream(path) : InputStream

写web应用日志文件：log(message:String)

log(message:String, Throwable:excp)

* o0 ^1 m& P8 ]! A

• 如何设置ServletContext的参数？
  
  ( M" }5 v  T; o) F% z$ U; V
  

<context-param>

<param-name>catalogFileName</param-name>

<param-value>/WEB-INF/catalog.txt</param-value>

</context-param>

• 如何获取ServletContext设置的参数值？
  1 Q% h1 P  b0 p$ T9 W+ U
  0 C5 `+ ^- P( K& T* z: \
  5 k' d) ^  D) T3 n

ServletContext context = this.getServletContext();

String catalogFileName = context.getInitParameter(“catalogFileName”);

2 |: w, q  Y1 d) B0 |9 l

• 描述Web应用的生命周期？
  
  
  1 L+ S; S. D4 Z: P* p: i/ O1 D

Web容器启动时，初始化每个Web应用

Web容器关闭时，销毁每个Web应用

可以创建”监听器”对象触发这些事件；

8 q0 Z4 u% {1 d3 O0 {2 D

• 如何用代码实现监控Web应用的生命周期？
  
  
  
  

public class Test implements ServletContextListener{

public void contextDestroyed(ServletContextEvent arg0) {

System.out.println(“web 容器销毁了+++++”);

}

public void contextInitialized(ServletContextEvent arg0) {

System.out.println(“web 容器启动了+++++”);

}

}

' u1 C- I3 \$ }3 E9 c0 {, w

web.xml文件中的配置：

<listener>

<listener-class>

com.csy.Test

</listener-class>

</listener>

• web应用中如下错误码示什么意思：400，401，404，500
  % i$ t9 y! O( a- l! K* W% ?6 ~# }' P
  $ P& W# u8 Q& U4 C' S
  400 Bad Request//错误请求
  401 Unauthorized//未被认可
  404 Not Found//没有创建
  500 Internal Server Error//服务器内部错误
  
  

• 描述Web应用中用声明方式来进行错误处理的两种方法
  
  
  

使用error-page元素声明一个给定HTTP状态码的处理器

<error-page>

<error-code>404</error-code>

<location>/error/404.html</location>

</error-page>

可以声明任意数量的错误页面，但一个给定的状态码只能对应一个页面

使用exception-type元素声明给定Java异常的处理器

<error-page>

<exception-type>

java.lang.ArithmeticException

</exception-type>

<location>/error/ExceptionPage</location>

</error-page>

可以声明任意数量的错误页面，但一个给定的异常类型只对应一个页面

不能使用父类捕获多种异常

• 描述记录异常日志的方法，都位于那些接口？
  1 _' p5 F' w) I! x, Q1 j
  * a# ]6 C  w& I. u- q
  

GenericServlet：

log(message:String)

log(message:String, Throwable:excp)

ServletContext：

log(message:String)

        log(message:String, excp:Throwable)

• 什么是会话？
  : q! S* Q7 d4 J6 ?5 N6 h6 K0 Z
  % i+ y; N; W$ [4 T
  

Web容器可为每个用户保存一个”会话对象”，用来存储特定用户的会话信息。

• 如何获得会话？
  
  
  HttpSession session = request.getSesseion( );
  
  

) c$ T9 q2 c3 f) b8 G( H( {# ?

• 会话Api的基本功能？
  0 [, z- ~) s: ~9 i" }; P/ W( M% j8 ?% N
  ) @# }- H4 u5 B1 G& `/ N
  - A/ \4 D$ v6 A2 r

getID() :String
8 @" t4 k5 V% U: R

    isNew() :boolean
& ]0 k& q% [" p. Q0 o* L& T) p8 {: G

    getAttribute(name):Object
! `7 @# G$ m( L* _2 h; V) N

    setAttribute(name,value)

    removeAttribute(name)

• 如何销毁会话？
  
  
  

1、可使用部署描述符控制所有会话的生命周期

<session-config>
$ N5 a( }  z$ l0 V) q+ s; i

         <session-timeout>10</session-timeout>

     </session-config>

2、可使用控制特定会话对象的生命周期HttpSession接口

invalidate()
  m9 x! s1 o+ t  f3 E

     getCreationTime() :long

    getLastAccessedTime() :long

    getMaxInactiveInterval() :int
7 E+ j* Q" _# Z. m+ W; f

     setMaxInactiveInterval(int)

9 N8 ~5 |# B, F! F5 b. g4 W# B

• 描述会话保持状态的基本原理
  
  
  

    client server

request

response (sessionid)
8 p4 u1 |' n) x9 y7 R

request (cookies)

当客户端第一次请求时，服务器创建一个session与request绑定，用响应对象response来返回sessionid 放到客户端的cookies中存储下来，下次在发送请求时，直接根据sessionid来检索服务器的会话（每次请求都会将所有的cookies带到服务器端）

• 请描述session和cookie的异同之处
  2 g( i5 B$ x- G1 M' v" A
    O% o' x6 g7 H9 Z5 b5 _. q& A
  

3 p; ^% ?% H2 I3 ~1 n4 z6 _

• 如何读写cookie，代码示例
  
  
  

写：    Cookie c = new Cookie(“yourname”, name);

response.addCookie(c);

读：Cookie[] cookies = request.getCookies();

        for ( int i=0; i < cookies.length; i++ ) {

            String key =cookies.getName();

String value = cookies.getValue();
- U2 h( q1 r% Q

System.out.println(“cook”+i+“:key=”+key+“,value=”+value);
9 D* w4 j: y7 H5 }& x

     }

1 Y2 F/ G* F$ P3 @: H

• 什么是URL重写，如何实现，代码示例
  
  2 T! Z- h( e3 X% F" A. h
  ; h& u9 q# O. Q- z* i" Z

Cookie不能使用时，可使用URL重写 request.encodeURL();

客户在每个URL的后面追加额外的数据

服务器将此标识符与其存储的有关会话数据相关联

http://host/path/file;jsessionid=123

% _: N* i# A# w6 K% I

• 描述web应用的4种认证技术
  
  
  

BASIC – Web浏览器接收用户名和口令，将其以明码方式发送给Web服务器

DIGEST – Web浏览器接收用户名和口令，使用加密算法将此数据发送给Web服务器

FORM – Web应用提供发送给Web浏览器的HTML form

CLIENT-CERT – Web容器使用SSL验证用户，服务端和客户端的链路保护

$ F; x1 s, R. B6 Y( m

• 什么是授权，什么是验证？
  
  : Q# d1 K6 o! l! Z5 t
  

授权是根据用户角色划分web资源的过程，其标识web应用中的安全域 分配权限

web容器使用厂商指定的机制验证用户的角色 匹配权限

. k2 R5 ]; [: C. m7 H% g

• 什么是HTTPS
  
  
  : k( e! K9 d' }, S

HTTPS (Secure Hypertext Transfer Protocol) 是使用SSL协议的HTTP

- K7 h3 K6 Q9 p* z% ], t4 F" E# U

• 什么是审计？
  4 g( z. K  `0 g
  ( e/ R+ x1 m- U
  

也就是访问跟踪，是为web应用的每次访问保留记录的过程

• 如何实现声明性授权
  
  
  9 \7 G9 q; x; e; ^2 s; ?

1、标识web资源集

2、标识角色

3、将web资源集影射到角色

4、标识每个角色中的用户

在 web.xml里配

, H- M! z6 g% l5 e- A) |

• 描述servlet并发问题？
  5 o  q: L+ W( C# z( K& M
  ; O. I5 v8 I, R+ R+ s1 b3 X- H6 |) ?3 O
  

多个同类线程运行，可以共享同一个Servlet实例，共享的数据和资源未合理同步，可能会引起数据的冲突

& \. p6 j- E4 s; j0 w6 O" N6 N9 r

• 描述Web应用中的六种属性范围
  9 l6 L9 a7 f% H( V
  
  : U& t7 |0 y7 _% A

局部变量（页面范围）

实例变量

类变量

请求属性（请求范围）

会话属性（会话范围）

上下文属性（应用范围）

' e" [# h  m) x) Y: J" _

• 指出上述六种哪些是线程安全的
  
  
  * c  B7 m& V" Z# p9 h0 O; f6 H

局部变量和请求属性

# H% H9 r4 S2 Z$ U( a# J/ I

• 什么是STM？如何实现？
  & P1 F0 f* t3 n/ f9 g8 b
  4 I1 D" d0 p2 L  @  g, R
  

SingleThreadModel接口

可以实现SingleThreadModel接口保证某一时刻只有一个请求执行service方法

5 e5 M- b8 ?+ P. E) B) ?

• 如何实现并发管理？
  
  
  

尽可能使用局部和请求属性

使用synchronized语法控制并发

尽可能减少同步块和同步方法的使用

使用正确设置了线程安全的资源类

admin

JEE
  y- M8 Z) Q9 l# T3 U1 b6 r7 m简述JEE
JEE　： JAVA　 PLATFORM　 ENTERPRISE　 EDITION
" X) Y! P! i2 b. w# B& }
2 @9 }! U$ I* sJEE是一个规范集；
/ {% }) k7 l* j# e, r) C, X! ]
JEE是一个框架集；
. R6 b; T; w7 T, r# {2 w( J
JEE是一个技术集或API集；
0 F) V+ c/ V  `2 ]- A. w
' M% t! n& Q- @适用于创建服务器端的大型的软件服务系统


) u) ~1 F/ O, @5 Z' @* U
C/S B/S 模式
C/S client/server即客户机/服务器模式，客户端也参与程序的运行与计算（富客户端、胖客户端）

) f& b. i" w1 Q# [" d- TB/S border/server即浏览器/服务器模式，又称为瘦客户端，客户端不参与程序的运行与计算

5 D8 ~; s! K) Q0 Q+ C  r7 i
$ G) E7 K! O; }9 o3 N: Z  c
* J& c( I) }5 a3 s0 E企业级应用（大规模的应用）的特点
1.生命周期长、稳定、可靠
3 Z" q1 N9 n& ^( c
5 [) j) K: m% v7 s' Q! q7 Z2.组件往往分布在异构的环境中，能够跨平台

' _" o( r) c; E6 v2 Q3.维护性、扩展性、重用性

. l+ Y6 f) z: x3 l3 u9 C3 K  D4.有事务、安全、线程
9 J* D4 R8 |' ~$ J& b

. N3 b7 r& E) H8 ^# R
' a' K5 K1 e8 B' F6 B什么是业务逻辑？
: N2 I) n5 t! \7 _  `0 l8 B依照业务逻辑划分模块，

& w" b5 x& e% s# w  s+ Y所谓判定业务　就是具有以下特征：

) s2 E8 W. V; X" D1.业务流程
; Y! z- k4 T3 H# H& R7 O
3 C9 e' ]) p$ I3 V, F( y2.业务判断
* k) G2 c7 r- c& |; n
. K; c% @! p( H7 t5 U! _2 J- T3.功能组合

# Q/ u& O6 l6 Y2 V

$ T3 `! h' I5 C; _平台（角色）的划分
, W0 B; H# f1 b2 e3 F4 u1.平台供应商。提供满足API集实现的厂商（BEA weblogic IBM webshphere）

8 l7 j6 ]( R2 f3 T- Z2.组件供应商
3 ^; j$ O8 |6 h, E
3.组件装配人员
9 V3 a+ V0 G6 n. x
4.部署人员
" a4 K& J7 v0 d6 m
8 k, @0 H4 ^/ s$ e: J- a& m! V2 \5.系统管理人员
" b  \# {$ D5 y$ V
6.工具供应商 提供开发组件所使用的工具（Jbuilder、eclipse）

" [5 I9 V/ |6 d* q

java技术分布（设计架构 模块内部设计）
1.表现层 Servlet、 Jsp、 JavaBean、 Taglib
& z$ {2 D- I) u- ~' L# Q; j
2.逻辑层 EJB(SessionBean)

/ H. v5 N7 P' h3.数据层 （　JDBC 　EJB（EntityBean））
6 F% \3 c! M3 Y, V% ~
, g. h7 w/ `, N9 j4.服务 JTA（JAVA事务架构） JTS（JAVA事务服务） JAAS（JAVA授权与验证服务）
* i, i! N; l* f( a1 J
5 v7 u! ~  m0 Q6 x" g) q5.分布式通讯 RMI（IIOP）+JNDI 、JAXP（JAVA 的 XML 架构）
# J4 o  h7 {4 m7 L
* q( F6 W1 t% @5 w. qJAVAMAIL（邮件服务）、JMS（消息服务）、IDLC、JCA（JAVA连接器框架 （成））
& {3 x6 f* x8 z2 a7 F% I- C4 }
$ F7 u- k( e* f+ Q

. N# M  v: Z/ |+ p3 @$ rJEE的体系结构： 是一种组件的体系结构
, [  f! K9 d! w5 m  A2 o1.组件 ： 能够完成一定功能的封状体（独立的功能的集合）
/ U; ?) n, w/ h" m. {0 g- j
1 L% m/ J4 y3 i. x5 O5 P不能单独运行，必须运行在容器上

+ x. {! X) N+ ]# Y分为两类：web组件、ejb组件

6 a- k; a; p$ h1 |9 Q8 Q2.容器 ： 提供组件的运行环境，并对组件进行管理（一段程序）

! L4 a; O6 e; W+ P' n, e( W( o6 u管理组件的生命周期

- E" ~8 w+ S2 g不能单独运行，必须运行在服务器上

程序（组件）通过上下文来调用容器（context）
& l! O% L) V$ ~4 m0 ^9 r
# F5 m+ s$ |' k' s; C+ x组件通过web.xml向容器描述自己，使容器能够认识组件
- V9 N0 E" E) R) X# H( }- ?1 S
0 I! F# D' C4 T4 y, a容器通过回调方法来调用组件

3 a0 c, L4 v% J( e2 N; `$ y分为两类：web容器、ejb容器

% C. x* j, I( ]: N3 V3 f3.服务器 ： 提供容器的运行环境，提供大量的JEE基础服务
/ s6 f( n$ ?8 X4 N3 R
# P' j: Q$ N- E0 I! q1 I6 rweb服务器（只提供web服务）
( x, w& }0 {7 d
& i5 `# Y  B. ?) f- a: }jee服务器（提供web、jee服务）
* @' L' l" Q! |6 m
" @% ]3 L& R2 p* l9 z) o& G
7 f* b, p; C$ J. [  }1 D( g
5 z" n' d4 u, ?- I  h什么是回调方法
% B1 w. Z9 |; b$ I! a由容器自动调用的方法，就叫回调方法。

- F  b  ^- A8 g/ ~( f. p3 v

ＲＭＩ远程方法的调用机制
例如：Ａ主机有Ｂ（）方法，Ｃ主机有Ｄ（）方法，Ａ　想调用Ｃ主机的Ｄ方法



, M, L* T! ?) A. q; `$ g/ z+ e
% z! g8 `* R$ \' W
6 S2 F# z" \  ^# P( ^* S) V学习方法
6 |& j& G, B( [" A0 l1.规范（熟记） 2.熟悉API 3.多练 4.多想

admin

Xml
5 l5 e8 ]+ ?  D0 B* w1 B- h# p( V

XML有几种解析方法，有什么区别？
4 p7 n5 _6 Q; w5 z- g# \有XML DOM解析、SAX解析、StAX解析
- G) N: r8 O. B3 f2 y: I
3 m' q3 U6 G* M1 K* Z/ `XML DOM：（XML Document Object Model）处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文件之前把整个文档装入内存,适合对XML的随机访问；
& S6 g; `: D) `( P4 B; }' X* V5 G
SAX：（Simple API for XML）不同于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问；
6 ~& ?1 j9 \+ g" L5 ~9 C0 {
: w# ^- t8 J' b( H/ o" VStAX：（Streaming API for XML）与其他方法的区别就在于应用程序能够把 XML 作为一个事件流来处理，无论从性能还是可用性上都优于其他方法；

* X( k$ {3 K1 _/ C2 S8 y
- W. R8 v+ [+ L& q# }; }  t
3 Z" E5 P9 }" ]) t' `3 RDOM解析代码如下：
: O% B5 i6 n2 {
import java.io.*;

import java.util.*;
) a2 t( E% @: w' ^
; D; f0 R! u8 t5 @import javax.xml.parsers.*;

import javax.xml.transform.*;
* R& B% ^. }) m
import javax.xml.transform.dom.*;

import javax.xml.transform.stream.*;

import org.w3c.dom.*;
" h( r% q, l$ `1 J! u/ F5 T
! @( I1 A2 K1 P: npublic class Fuxi{

% m) s6 p6 H" A- J' apublic Fuxi(){}
  f+ X2 D: {' F6 {  _+ z
7 H# V8 |/ L) h( w- B4 _+ `' s7 npublic void runXml(){

File f = new File(“f:/test/xmltest/student.xml”);
+ A4 u, L6 J, x3 x
try{
7 l) \/ n" G! a* v
//首先创建一个documentbuilderfoctory的工厂
/ n; Y7 Y" U$ L) k
! ]( o* V7 v3 V% ~. i- i* A& {. aDocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

7 J1 ~5 {* \. U  D" m; c; Y
  A4 ?$ ^. G6 H, x: [
) F2 o6 {5 k4 K9 [//利用工厂来创建documengbuilder

& P) P- V& z; }" T  c$ J$ m  UDocumentBuilder db = dbf.newDocumentBuilder();

. g8 d! y; C! r1 R* x9 s4 B. D, x//利用db的parse方法来解析xml文件
/ c0 c" @; B) C% p
" i6 O' C4 T: G+ IDocument doc = db.parse(f);
8 N7 c2 r( G) r
//将读出来的文件格式化
3 k8 i+ ^) B$ h; v
9 Z5 C% ]: U4 R$ M, {% Mdoc.normalize();

//定义一个nodelist数组来存放xml文件中的节点（标签）

1 ]# Y7 T" S1 y" c! V1 ZNodeList students = doc.getElementsByTagName(“student”);
6 U: ~9 v1 E0 y9 |+ ^) N8 B1 `* m
//从xml文件中读取数据
! f- z/ ]! ]0 _
for(int i=0;i<students.getLength();i++){

. n  o0 U8 r; _//定义一个元素
( O* R5 p/ {4 L# }
Element student = (Element)students.item(i);

" k1 O: U4 \0 U3 ], d( C+ {System.out.println(“stu_id :”+student.getElementsByTagName(“stu_id”).item(0).getFirstChild().getNodeValue());

System.out.println(“name :”+student.getElementsByTagName(“name”).item(0).getFirstChild().getNodeValue());

1 ^5 {( u- p- t) [' \+ bSystem.out.println(“age :”+student.getElementsByTagName(“age”).item(0).getFirstChild().getNodeValue());

8 g- o) K8 ?% P}

3 T6 l% {) v* d" M4 Y. e0 f//向文件中写数据
/ l; [  r# ?8 v( M( I
String stu_id = “001″;
! L& p+ a3 I6 H- E( H) H1 y
, L* |  o; l4 o% wString name = “xingxing”;

# U& o% j" G9 b8 wString age = “22″;

7 H0 [3 M" I( r+ k+ c1 vText msg;
4 h) Y4 c1 G! D- v7 H) N( N
//创建元素
2 F& q4 R: m# |. c2 h
Element studentNew = doc.createElement(“student”);
$ R% ]/ }* F" y+ A
$ N9 W% t; E7 K8 d/ S" M//创建子元素

% f. y- N. O% ~+ ?% R" YElement stuid = doc.createElement(“stu_id”);
8 F" ?# W; _5 A/ d& }- p
  [5 ?! k9 Y2 N$ S& m2 f//设置元素的值
; }9 G( M" R# c
msg = doc.createTextNode(stu_id);
4 V$ s$ k, F1 V* C" w
6 H$ k3 l4 g8 ~2 V: a* ^% Z' g//将值添加 给元素
$ Y; P$ h- s2 J& D2 @: N
: X6 c  L3 L% _* F* B4 G  A1 Sstuid.appendChild(msg);

//将元素添加到节点数组中
1 O+ y6 V. u( [% t8 l" |% O0 H3 a
studentNew.appendChild(stuid);
' \! W2 W. ^9 h$ Q
; [' X" z  I2 H. a6 t0 zElement name1 = doc.createElement(“name”);
+ k3 f3 L, q6 {3 g7 ^+ e' O0 u
: M# C! \8 j9 ~6 Y0 C" T1 _msg = doc.createTextNode(name);

name1.appendChild(msg);

) x' ^% g; R7 K+ z# {7 A5 [studentNew.appendChild(name1);

/ u( {0 L" w3 P( M& jElement age1 = doc.createElement(“age”);

msg = doc.createTextNode(age);

age1.appendChild(msg);
& q/ A5 V6 ]# J
/ x! a7 b( z, S3 A  ?studentNew.appendChild(age1);

6 V$ K. k' S7 T6 H) A//将元素studentnew添加到document树中
9 I: [' A/ U+ V  M9 G$ @' m

9 z; T3 B& R0 H" f
0 o% T6 s6 P: L+ Bdoc.getDocumentElement().appendChild(studentNew);
( h5 C. j  x9 m3 O+ r$ `
//进行写操作

TransformerFactory tff = TransformerFactory.newInstance();
" P( L1 ?1 f. B% ~
Transformer tfor = tff.newTransformer();
" l0 }1 A( w8 a! g4 ?* X8 L1 e& z
$ f3 `& `+ m4 O9 y# I2 G' QDOMSource dos = new DOMSource(doc);

6 P) c! W6 R: |" PStreamResult result = new StreamResult(f);
, n+ l; y9 p" U& f& C% ]' [
tfor.transform(dos,result);

}catch(Exception e){

System.out.println(e.toString());
" R. R% z3 J# O( a* m) ^
: C+ K$ s; U& P: h' E  S  U}
- a  ?  [3 g5 c- v  d1 e
}
: f( x5 E) K9 q9 h2 f! T" z
2 i1 ]1 a/ j* H. ?( t) kpublic static void main(String[] args){

) T! Y& v. A  _( E7 b; C* J! BFuxi ff = new Fuxi();
& Y2 C( Q* q# V: c5 K% y2 S
ff.runXml();

}

}