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

admin

JEE
简述JEE
* _1 Q' ~6 T6 }% a2 T* H! B; sJEE　： JAVA　 PLATFORM　 ENTERPRISE　 EDITION

JEE是一个规范集；

JEE是一个框架集；
$ x* J4 Z$ P' [4 u, C& |
JEE是一个技术集或API集；
+ w+ c- ?# v$ A! _8 A, b1 a: ^
* {1 A7 m+ m/ `2 c8 d适用于创建服务器端的大型的软件服务系统

. ~0 y; y. E" X% I6 Q2 p
3 Y. i: F: K: U& ?
C/S B/S 模式
3 l1 R1 L8 ]$ I  N/ y2 z% [& zC/S client/server即客户机/服务器模式，客户端也参与程序的运行与计算（富客户端、胖客户端）
' H4 x) z' U, P2 P2 Z% S
B/S border/server即浏览器/服务器模式，又称为瘦客户端，客户端不参与程序的运行与计算
, w: f( s  B% ]  g

: ^5 S- W5 w1 {4 c0 {
企业级应用（大规模的应用）的特点
4 _1 d1 x# l/ B1 W1 }4 o1.生命周期长、稳定、可靠
+ W0 C7 Z. \) M5 v0 Y) {  r9 }' ~! Q
2.组件往往分布在异构的环境中，能够跨平台

, z' W# c; S4 O7 i2 j, [, s$ k3.维护性、扩展性、重用性
  `2 `) E0 ~- T
' a/ C$ D+ `8 C+ l6 t4.有事务、安全、线程
; S# [& J4 H& U7 A
% P% t- ^4 [" ~1 h: A

什么是业务逻辑？
依照业务逻辑划分模块，
) `% F8 t9 p" b' w( }9 @, ?& O
0 T; [) }4 A. k2 _/ |1 ]8 q2 ]所谓判定业务　就是具有以下特征：
: ^3 a- r/ G6 l% a& X2 ]" h
1.业务流程

2.业务判断
6 a7 B# t: {% X' ^  v& T, b3 S8 p
3.功能组合
. W6 h/ r7 j! n& G# b9 }5 |
5 ]1 G1 v3 i& y. A$ ?" R

) h% Y6 z3 Y, l6 ]) u1 B6 M平台（角色）的划分
) e3 {8 }9 L! p# ]; o6 V4 T# ^1.平台供应商。提供满足API集实现的厂商（BEA weblogic IBM webshphere）
  Z: [, P% e) ^5 R
2.组件供应商

- N& S7 @3 ^3 c" G% @6 U4 @3.组件装配人员

* @" R1 `5 q; A+ f2 ~4.部署人员

3 Y: U9 T" w! \5.系统管理人员

6.工具供应商 提供开发组件所使用的工具（Jbuilder、eclipse）


) t7 ^% P, @& l2 w* H9 F# g
, |& O( S' j$ ijava技术分布（设计架构 模块内部设计）
4 U5 }2 ?. d$ K9 p" }8 }+ Q1.表现层 Servlet、 Jsp、 JavaBean、 Taglib

2.逻辑层 EJB(SessionBean)
! b' w* F8 k5 f. p. m) `! V
) a) t1 |- V8 Y- S# F* k' G. m3.数据层 （　JDBC 　EJB（EntityBean））
8 G8 K/ y  L; X4 @0 S: G
$ x+ o2 z. E2 y3 ?# \& p3 n) {4.服务 JTA（JAVA事务架构） JTS（JAVA事务服务） JAAS（JAVA授权与验证服务）

, f1 c& U# v3 l0 r  @5.分布式通讯 RMI（IIOP）+JNDI 、JAXP（JAVA 的 XML 架构）
% E; e( q& R0 l; p' J4 K: F
- O8 m  b" T9 z; F, uJAVAMAIL（邮件服务）、JMS（消息服务）、IDLC、JCA（JAVA连接器框架 （成））

' @- J. i# e7 c2 E
: @2 F8 y5 L9 O
) A+ _* H) t; h1 w1 g6 L( WJEE的体系结构： 是一种组件的体系结构
1.组件 ： 能够完成一定功能的封状体（独立的功能的集合）
. _, e" o- y2 F/ [4 d! q, D
不能单独运行，必须运行在容器上

7 n( [5 v. q1 a; q& I分为两类：web组件、ejb组件
& h6 Q# U. t' ]) g
, [" ~* D+ E! V# \9 T' W2.容器 ： 提供组件的运行环境，并对组件进行管理（一段程序）
+ h1 r# x9 C8 v" u
管理组件的生命周期
, U" {- ^9 p( T+ ?8 u
不能单独运行，必须运行在服务器上

/ d1 J  m9 X6 ^( f* V3 q9 \程序（组件）通过上下文来调用容器（context）

# B7 P! G7 b( B2 n* w' S5 x组件通过web.xml向容器描述自己，使容器能够认识组件
0 J6 Y& t* p9 S4 s
容器通过回调方法来调用组件

6 Q9 L& N7 S! ?! H2 E( v* I分为两类：web容器、ejb容器
9 V7 P# ]4 R' x# H* m8 Z
3.服务器 ： 提供容器的运行环境，提供大量的JEE基础服务

web服务器（只提供web服务）
6 P% Z% ^6 p  N* x/ n
jee服务器（提供web、jee服务）



什么是回调方法
由容器自动调用的方法，就叫回调方法。



" ~& O& i# o! ]6 v! G) ]; \ＲＭＩ远程方法的调用机制
1 ~' w/ |6 v# U' Y2 K/ U& U例如：Ａ主机有Ｂ（）方法，Ｃ主机有Ｄ（）方法，Ａ　想调用Ｃ主机的Ｄ方法
, {% q6 v, E! N( A

1 o* o* s/ \2 ]/ M2 n3 V2 o
/ A3 v! u& ]+ Q! p! L
7 v9 Y0 s2 Q4 ?; o. X- r: ~( z
学习方法
1.规范（熟记） 2.熟悉API 3.多练 4.多想

admin

Servlet

•     描述war包、jar包、ear包的结构
  1 b  S7 s2 x7 p: p
  
  

war-                            web文档压缩包

—WEB-INF

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

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

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

! ~3 p9 n- f; O" J

jar-                             java文件压缩包

—META-INF

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

- E! T" H, E6 V4 p3 e  \7 [& [

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

–META-INF

—Application.xml 配置文件

–*.war

–*.jar

• 什么是servlet？servlet主要做什么？
  9 Z0 k8 r9 q+ \( c/ B
  
  5 M3 X" Y' {: T+ Z% [5 o8 q

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

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

" o9 P& P" Q/ U; s2 F3 k; m

• servlet 与cgi相比的优点？servlet的缺点
    [8 Q" Q+ L5 c% N: W
  
  

优点：

性能（线程比进程更快）

可伸缩

Java强健且面向对象

Java平台独立

缺点：

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

• 常用的servlet包的名称是？
  " d4 D: ?0 X" e' D5 e+ c5 s
  
  ' o, P6 y1 a* y. r( T( E# x5 k7 f

javax.servlet

javax.servlet.http

! ?1 X1 o0 Y5 \2 H1 W

• 描述servlet接口的层次结构？
  ! {# X* z7 l: A% Z* _
  ' f, M; o3 H  G/ ]* l* V& _
  + g# u$ o# N& |+ f: i: y1 N# w

Servlet

–GenericServlet

–HttpServlet

–自己的servlet

ServletRequest

–HttpServletRequest

ServletResponse

–HttpServletResponse

1 {1 H9 ~7 m0 I

• 对比get方法和post方法？
  ) H5 {4 p, Q0 m5 U$ i/ P$ f" P" q
  9 N. e; z/ e4 R( b5 S* i! o
  1 R1 J& a( q4 ^* r# _

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

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

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

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

% W5 i8 Z, o9 o& s, ~! G( C8 E9 U3 h8 Z

• 归类描述HttpServletRequest接口都完成那些功能
  
  
  
  • 读取HTTP头标
    
  • 读取cookie
    8 H9 T4 I. g$ ]- p+ n' C; V: c# o- M; @
  • 读取路径信息
    
  • 标识HTTP会话。
    
    

) X: F' C; ^7 d) y) Y4 W& k- z

• 归类描述HttpServletResponse接口都完成那些功能
  8 M" r' E8 I" _7 _
  ; \4 D# N$ x0 O( M  j/ ]" l3 v
  1 t& c/ S1 z" }
  • 设置HTTP头标
    
  • 设置cookie
    
  • 设定响应的content类型
    3 f: {+ }4 `7 H) j- M$ M1 t. z
  • 输出返回数据
    
    

• 描述service方法所完成的基本功能？默认是在那里实现的？
  : g2 t' C/ k: l: H; b
  
  

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

实现：默认在HttpServlet类中实现

6 s- t  r. t& `8 v% X, n, O

• 如何开发自己的Servlet？描述应该做的步骤和每步需要完成的工作
  6 T2 W0 f! K- T  p6 I  A  ?0 G4 |
  
  

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.启动服务器

8 E2 c5 H$ P! `2 z' F" c

• 为何servlet需要部署描述？
  " O+ u" \; \8 s! ?
  
  ; [& A3 G% X2 o3 u

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

• Servlet基本的描述应该是？请写出来
  
  2 ?: V3 U: R5 q9 p1 n
  

<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>

8 K- D0 H/ ~) d  d

• 如何在html中使用servlet
  
  , J% ]8 X2 P- t! L. D' u) u* ~
  " J! B' o9 C, _

FORM标记

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

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

语法：

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

{HTML form tags and other HTML content}

</FORM>

• 如何接受request中的参数
  
  $ ~" {- ]3 r5 m1 bString userName = request.getParameter(“userName”)方法
  
  . g) U# Q7 I( s& {) [- c

• 如何接受request中header的值
  9 c, x! E# Z4 ~' l" L9 w
  ; p# Z2 t; \; n  E7 G! A
  5 {3 q7 B3 c6 a

request.getHeader(name);

request.getIntHeader(name);

request.getDateHeader(name);

request.getHeaderNames();

7 N! I6 ?/ u3 w+ o, m1 v4 c  |

• 如何输出html
  / i1 R' D4 X) p9 `- d% l( O: _
  
  - t$ f) T( ~- ?6 K3 r7 w' m* X* G" `* ^

PrintWriter pw = response.getWriter();

pw.write(“<html>”);

pw.write(“Hello”);

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

8 J% T6 G4 L( y0 r6 n. H; E

• 如何设置输出的contentType
  
  
  

response.setContentType(“text/html”)

; F4 U3 K& z5 ~" G, \& c3 H

• 描述servlet的生命周期？
  5 H2 }' W9 f1 u/ ^! a& Z# q
  6 R" B  F4 ?* \7 t. s5 c! ?5 X, ~
  

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

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

• 描述init,service,destroy方法的功能和特点
  ! [! k: h' j) d& o, f& x
  
  5 a1 ]  j% z6 u+ |

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

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

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

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

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

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

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

& ^$ [0 I4 A6 Y+ d

• 什么是回调方法？有什么特点？
  
  ! ?5 _. {9 U% I2 ]3 z7 h3 k( V$ B  h
    A  ]2 w, J1 B! @, r1 Z. ?; z; f

由容器来调用程序的方法

由容器来决定什么时候来调

• 如何设置初始化servlet的参数？
  
  ! m" j# }) x  S3 n) h2 K在<servlet>中添加如下配置
  7 ^3 ~/ y. J0 j' u  _
  

<init-param>

<param-name>greetingText</param-name>

<param-value>Hello</param-value>

</init-param>

• 如何获取servlet初始化的参数
  
  
  

public void init() {

greetingText = getInitParameter(“greetingText”);

System.out.println(“>> greetingText = ‘” + greetingText + “‘”);

}

• ServletConfig接口默认实在那里实现的
  & t0 X5 G6 w3 E' B# I
  
    Q5 v$ T/ D, g- d5 ]5 F; u

GenericServlet类实现ServletConfig接口

  W, p0 q$ J% x7 ?

• 什么是ServletContext？有什么作用？
  
  
  & R+ l0 d$ Z5 R9 u* A

Servlet上下文

ServletContext对象是Web应用的运行时表示，约等于整个web应用；可通过其实现Web应用中的资源共享

• 如何访问ServletContext接口？是在那里实现的？
  ) w. u' Y+ l8 v' C4 w
  3 o) a- _9 L7 O/ e6 H9 ^! o. x
  

在Servlet的实现类中通过this.getServletContext()方法访问。

GenericServlet类实现了ServletContext接口。

3 e7 H/ y7 R/ _

• ServletContext接口的功能包括？分别用代码示例
  ( R# Z8 V9 ^7 \! \; u" b
  / i& J* }1 E5 Y* \. _
  

只读初始化参数：     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)

• 如何设置ServletContext的参数？
  5 q$ b& Y5 s5 H6 C* z& b
  4 D% g: s" }1 _
  / p, f! ?% L6 j) i3 `

<context-param>

<param-name>catalogFileName</param-name>

<param-value>/WEB-INF/catalog.txt</param-value>

</context-param>

• 如何获取ServletContext设置的参数值？
  
  # ]) H6 d( p0 J, V0 l( W
  

ServletContext context = this.getServletContext();

String catalogFileName = context.getInitParameter(“catalogFileName”);

4 K; h$ N9 S" r; R1 V+ O

• 描述Web应用的生命周期？
  
  
  

Web容器启动时，初始化每个Web应用

Web容器关闭时，销毁每个Web应用

可以创建”监听器”对象触发这些事件；

' V" K* h* G# v: M1 A

• 如何用代码实现监控Web应用的生命周期？
  7 q* m5 ?  f# l1 j. a( R
  
  + c! a: y, w1 w
  ( U' \8 V$ L- F. u$ J5 M

public class Test implements ServletContextListener{

public void contextDestroyed(ServletContextEvent arg0) {

System.out.println(“web 容器销毁了+++++”);

}

public void contextInitialized(ServletContextEvent arg0) {

System.out.println(“web 容器启动了+++++”);

}

}

web.xml文件中的配置：

<listener>

<listener-class>

com.csy.Test

</listener-class>

</listener>

• web应用中如下错误码示什么意思：400，401，404，500
  4 [( Z3 x' [# S. P3 r
  : C( M/ L9 W% {
  400 Bad Request//错误请求
  401 Unauthorized//未被认可
  404 Not Found//没有创建
  500 Internal Server Error//服务器内部错误
  
  - W; o+ U" e& Z5 n

  ]: G$ F) |0 d. S& U# Z. X" r

• 描述Web应用中用声明方式来进行错误处理的两种方法
  
  7 H9 x+ Z/ h+ Q7 S$ U2 Q! @/ S) g
  # N5 P, h. Q; I' [1 R

使用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>

可以声明任意数量的错误页面，但一个给定的异常类型只对应一个页面

不能使用父类捕获多种异常

& A3 w' Z9 I$ E0 `

• 描述记录异常日志的方法，都位于那些接口？
  
  
  

GenericServlet：

log(message:String)

log(message:String, Throwable:excp)

ServletContext：

log(message:String)

        log(message:String, excp:Throwable)

• 什么是会话？
  
  
  

Web容器可为每个用户保存一个”会话对象”，用来存储特定用户的会话信息。

- J$ ?4 u3 {3 [: l6 D5 u8 t% B

• 如何获得会话？
  ! Y0 i, z. f5 {
  $ \4 p* r* m7 v( S% S7 @6 o
  HttpSession session = request.getSesseion( );
  
  

' Y3 K: n. r9 I1 k0 N  l

• 会话Api的基本功能？
  
    }0 R% N% ~. g- y7 S2 {- A
  

getID() :String
- m- C5 K5 H0 H" l

    isNew() :boolean
6 Y0 K# t- V6 _4 [  Z4 E

    getAttribute(name):Object

    setAttribute(name,value)
! c2 D( {7 z+ g% }2 J* B0 Z

    removeAttribute(name)

, N3 Y, O3 ~0 m7 l8 ~+ V" m

• 如何销毁会话？
  + z. C, f. F: Q* c0 Z! q
  
  0 u% y6 P1 o% g, d$ d" C

1、可使用部署描述符控制所有会话的生命周期

<session-config>

         <session-timeout>10</session-timeout>
& I  O& a8 z% H7 Y0 H+ f4 D

     </session-config>

2、可使用控制特定会话对象的生命周期HttpSession接口

invalidate()

     getCreationTime() :long
- w. k; R# J/ h( z6 H4 P

    getLastAccessedTime() :long
2 P* R* y7 P, w+ F9 o

    getMaxInactiveInterval() :int
1 J% s* c( l% G, d* b  z+ f

     setMaxInactiveInterval(int)

• 描述会话保持状态的基本原理
  
  
  

& i$ D  D  G) I2 K

    client server

  S2 T5 u  Y0 \

request
/ v& l/ e( x9 o% r2 N. O+ G& X

response (sessionid)
9 e9 i9 u: R* R" W

request (cookies)
2 v1 g$ h3 z! j0 G& g/ u

当客户端第一次请求时，服务器创建一个session与request绑定，用响应对象response来返回sessionid 放到客户端的cookies中存储下来，下次在发送请求时，直接根据sessionid来检索服务器的会话（每次请求都会将所有的cookies带到服务器端）

. c' y! A, ~6 a! S  ^

• 请描述session和cookie的异同之处
  6 \; R& s7 Q9 a2 w# {
  ' j/ w/ m. Y& J7 z$ T6 n
  

• 如何读写cookie，代码示例
  
  
  ) D1 s& R1 O: X* p! o! a* ?

写：    Cookie c = new Cookie(“yourname”, name);

response.addCookie(c);

读：Cookie[] cookies = request.getCookies();
3 R# e* T0 X+ C8 B1 u$ w

        for ( int i=0; i < cookies.length; i++ ) {

            String key =cookies.getName();
$ [, a5 b# J  B2 _

String value = cookies.getValue();
& V8 F$ r4 e+ g5 f4 `+ A

System.out.println(“cook”+i+“:key=”+key+“,value=”+value);
1 k5 n! |/ v7 U, ?% g

     }

• 什么是URL重写，如何实现，代码示例
  
  * b5 s4 V/ V1 Z" Q5 C% A, S& s! b7 ~2 [
  

Cookie不能使用时，可使用URL重写 request.encodeURL();

客户在每个URL的后面追加额外的数据

服务器将此标识符与其存储的有关会话数据相关联

http://host/path/file;jsessionid=123

; q7 m2 o+ w+ B/ f1 p7 w& D
. p4 b2 P8 N1 x/ U- [

• 描述web应用的4种认证技术
  
  
  

BASIC – Web浏览器接收用户名和口令，将其以明码方式发送给Web服务器

DIGEST – Web浏览器接收用户名和口令，使用加密算法将此数据发送给Web服务器

FORM – Web应用提供发送给Web浏览器的HTML form

CLIENT-CERT – Web容器使用SSL验证用户，服务端和客户端的链路保护

• 什么是授权，什么是验证？
  % r1 X+ a  X- N5 F; o9 o3 e7 `# G
  
  + U( I. Q- z6 j2 l& y3 B

授权是根据用户角色划分web资源的过程，其标识web应用中的安全域 分配权限

web容器使用厂商指定的机制验证用户的角色 匹配权限

• 什么是HTTPS
  6 _2 s+ J1 E- E& y
  
  

HTTPS (Secure Hypertext Transfer Protocol) 是使用SSL协议的HTTP

• 什么是审计？
  
  1 P& |" e, c$ \# f, }$ k
  , C/ j4 M6 g: y6 W3 h

也就是访问跟踪，是为web应用的每次访问保留记录的过程

• 如何实现声明性授权
  , ?) _8 _; l& ]3 B. H+ h2 q
  2 {& V4 V4 O3 x( J; _: [4 d8 U
  ) x, D/ O; n3 t3 z7 V! \& Q# M

1、标识web资源集

2、标识角色

3、将web资源集影射到角色

4、标识每个角色中的用户

在 web.xml里配

: t, \+ S/ f% L5 u0 p

• 描述servlet并发问题？
  # ^9 n  P( C3 Y7 k
  & J+ Q4 _; t4 U! S* R* t6 }
  5 g3 _6 R5 e8 Q5 g! k1 k

多个同类线程运行，可以共享同一个Servlet实例，共享的数据和资源未合理同步，可能会引起数据的冲突

• 描述Web应用中的六种属性范围
  + E; ^- q' q. M/ {0 [$ W$ `
  " P8 Y7 [$ Y- R/ K+ w
  

局部变量（页面范围）

实例变量

类变量

请求属性（请求范围）

会话属性（会话范围）

上下文属性（应用范围）

• 指出上述六种哪些是线程安全的
  0 O/ z( W4 l: E
  . S8 X. i. ^+ V+ _+ y  ~4 I) n* E2 r
  , y$ i# V; a( j

局部变量和请求属性

• 什么是STM？如何实现？
  " F$ B2 A, P1 z4 t9 W& [  e$ U
  
  

SingleThreadModel接口

可以实现SingleThreadModel接口保证某一时刻只有一个请求执行service方法

• 如何实现并发管理？
  
  
  

尽可能使用局部和请求属性

使用synchronized语法控制并发

尽可能减少同步块和同步方法的使用

使用正确设置了线程安全的资源类

+ i3 H% |8 |: ]- j

admin

Jsp
) h: I! q* N. Q. _' R什么是Jsp?
Java Server Page    结合java和html在服务端动态生成web页面的技术
2 x; m4 [& `! J& O5 _- d2 J  v
* G8 y: f$ T4 U8 y" D) s

" _; n& `4 n% B# s描述Jsp页面的运行过程？
第一步：

  h5 h  b6 C) o" j4 ?) O& @请求进入Web容器，将JSP页面翻译成Servlet代码

5 R: @" K- l! ^2 l# T7 L第二步：
# k8 L/ n0 _; B, p% Y9 F
编译Servlet代码，并将编译过的类文件装入Web容器（JVM）环境

第三步：

Web容器为JSP页面创建一个Servlet类实例，并执行jspInit方法
! p" h4 X6 Z8 X/ N' l
第四步：

5 n6 ~( }/ V! k; _( ?9 uWeb容器为该JSP页面调用Servlet实例的_jspService方法；将结果发送给用户

. n8 v/ T+ @; Z/ J

描述Jsp页面的五类脚本元素的功能、写法、并示例
注释 <%– –%>

3 i$ h5 n1 d4 ?. D% F) s7 v2 k<HTML>

<%– scripting element –%>
# _3 H: _/ d4 x
</HTML>
8 v! i3 Q! L+ O: k
指令标记 <%@ %> 指令标记影响JSP页面的翻译阶段

3 J( Y; G- Z" Y<%@ page session=”false” %>
- S$ W( E) p/ ]5 H* f
" Y- E. c9 |8 [" `& \; z0 v0 x声明标记 <%! %> 声明标记允许JSP页面开发人员包含类级声明

3 V1 n% E8 c- ^* `<%! public static final String DEFAULT_NAME = “World”; %>

: u2 E  e! h+ x% M7 l4 I; Q3 Y3 O" W    脚本标记 <% %> 脚本标记允许JSP页面开发人员在_jspService方法中包含任意的Java代码

    <% int i = 0; %>

表达式标记 <%= %> 表达式标记封装Java运行时的表达式，其值被送至HTTP响应流 <B>Ten is <%= (2 * 5) %></B>

- n% R; B0 ]  ]
, w  O3 X$ ?: c: \" }
" Q  @% ~7 f# T5 V+ ^2 ~" i1 Y描述Jsp页面中的注释种类和写法
HTML注释
7 _3 ~. t- U/ Q3 O, q7 R
<!– HTML注释显示在响应中 –>

( X; @7 X3 n2 k0 g" h* V3 f: z- HJSP页面注释

<%– JSP注释只在JSP代码中可见，不显示在servlet代码或响应中。–%>
+ u: T8 z0 L. x4 L5 `
7 C* K- t9 Q% v7 E$ x6 t$ H$ U! N# F6 uJava注释

<%

/* Java注释显示在servlet代码中，不显示在响应中

" a+ `( ~( F, ?6 P  W  ~0 @# K*/
  u9 n9 A0 Z. E& E
0 T; n7 c: b8 F2 d& f7 H2 [: _9 ]%>
/ M! I) I  ~# ]" p

! M2 d" a+ `" B0 n. P- r+ \& M
+ E+ Q! D: M0 ?/ S  _描述Jsp页面的指令标记的功能、写法、并示例
! x4 W) v9 }/ p, F2 W指令标记影响JSP页面的翻译阶段

<%@ page session=”false” %>
! E- v) {! j, Y& W
<%@ include file=”incl/copyright.html” %>

<%@ taglib %>
! z* [" p1 ]' z. R2 ^3 g
( _3 C' S- t+ L! o' y/ s, u

' w7 ~; R9 @2 q. A9 h3 h描述Jsp页面的声明标记的功能、写法、并示例
声明标记允许JSP页面开发人员包含类级声明
- H1 k, g6 z7 `
# S) Y: @' ]0 O# A* ?/ x" G7 F写法：
2 @/ {: e9 |/ W8 ]5 S+ b
4 k. P5 w. _  c3 _+ r& r<%! JavaClassDeclaration %>
  M: y$ S. b" u( k
例：
' r: C% O( \( E0 @9 u0 E: y
<%! public static final String DEFAULT_NAME = “World”; %>

<%! public String getName(HttpServletRequest request) {

2 T4 {2 n+ i" G! a' hreturn request.getParameter(“name”);
; O3 N. b7 t; \; B( z
% y2 k1 V8 A- V! m1 y}

2 G% O( i7 R/ d. X, n8 R% }%>

8 x' @/ e% A0 `# R+ n" Z, C  w<%! int counter = 0; %>
. G4 ^5 _6 q4 D7 z( c  Z- j; }6 `
# C! \( O: z" T/ b$ v
0 Z( |$ O; O* k
  d9 A+ G, i8 s2 w( A描述Jsp页面翻译成Servlet的规则
7 B- A/ l3 Z  i0 a2 a* ?jsp中的注释标记被翻译成Servlet类中的注释

6 T1 u, C7 ?' C( ?" a. Ijsp中的指令标记被翻译成Servlet类中的import语句等
6 Z1 C" R7 D9 f0 G
jsp中的声明标记被翻译成Servlet类中的属性

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

jsp中的表达式标记被翻译成Serlvet类中的write()或者print()方法括号中的代码
$ r8 z& e( I( C, h' g$ [/ P2 w


  D! u' Y) |6 c% O+ A1 S描述Jsp页面的九个预定义变量的功能、用法、并示例
request 与请求相关的HttpServletRequest对象
- `& F8 l: w3 d* `1 C* `
. W6 Y0 ]) O  W8 q/ H$ }; cresponse 与送回浏览器的响应相关的HttpServletResponse对象
0 [# g. J+ J& ~  `
$ q9 t( H, R: E' \1 xout 与响应的输出流相关的JspWriter对象
  c) ^6 o- p% b$ A
    session 与给定用户请求会话相关的HttpSession对象，该变量只在JSP页面参

2 @- I5 \' C' E( ~2 x与一个HTTP会话时有意义
( C' N" S7 f8 P2 B- w+ k8 q1 `' j
    application 用于Web应用的ServletContext对象
' [$ _5 E* V( B0 A0 }
3 o; A3 ]; K: N# ]config 与该JSP页面的servlet相关的ServletConfig对象
1 g5 Z9 C3 U5 U2 o! r& K+ a
pageContext 该对象封装了一个JSP页面请求的环境
$ l0 g3 Z% [* @9 l0 [
6 K" C1 u" h6 H9 e7 ~page 该变量与Java编程语言中的this变量等价
- A0 O% d1 O& W7 ~: f) s
    exception 由其它JSP页面抛出的Throwable对象，该变量只在”JSP错误页面”中可用
8 S9 u+ S# J6 Q) F) M$ ]
: {8 ?/ s1 D  w6 M$ w2 ?! l) w; j
7 g$ s, ?' R# f' N+ V
page指令的功能，写法、并示例，并描述它的如下属性的功能和用法：import、session、buffer、errorPage、isErrorPage、ContentType、pageEncoding
9 \) }) f1 Y+ _" q4 Gimport import 定义了一组servlet类定义必须导入的类和包，值是一个由

* a' H; s. t5 k( k. r逗号分隔的完全类名或包的列表。
8 D% Q( {: _4 i0 q! q6 d- J# n/ _+ d
% F$ [' {% a% j: m, }1 rsession session 定义JSP页面是否参与HTTP会话，值可以为true（缺省）
: e5 z3 J' e7 [& r- @; l
0 R  A& Q8 C2 K& f! d# P0 I或false。
% y/ S& R- J( G* _, I5 I5 r
buffer buffer 定义用于输出流（JspWriter对象）的缓冲区大小，值可以为
# J" b* _+ B5 U; u
none或Nkb，缺省为8KB或更大。
, O* f& `5 h& x
errorPage 用来指定由另一个jsp页面来处理所有该页面抛出的异常
/ n1 C0 l& y. r. ~! Y* W
isErrorPage 定义JSP页面为其它JSP页面errorPage属性的目标，值为true或
; j: a& P( {/ S3 e
, `8 I0 H' K/ afalse（缺省）。

ContentType 定义输出流的MIME类型，缺省为text/html。
& m9 J9 |: H. d
pageEncoding 定义输出流的字符编码，缺省为ISO-8859-1

+ [! z! b, C$ M" T
- R+ J: c! L# \7 Z- y5 N' }
描述MVC各部分的功能？MVC的优点？MVC的缺点？
: W$ m. H2 A* o2 G9 t- CMVC各部分的功能：
1 e" {" W2 j5 Q: j- c: {3 X0 [
Model（模型表示企业数据和业务逻辑）
: g. D2 W! i% A4 r# ?
封装应用状态
- i/ P* ]1 b3 F) g( X, J  r9 z: F
: Y8 |/ M6 _3 w* Z3 V, C4 F3 ~响应状态查询

7 i6 _9 t% q! H4 B暴露应用的功能
- P8 X& V& T) n
7 j4 k( r0 J7 ~. d# p( K1 ]2 @Controller（控制器接受用户的输入并调用模型和视图去完成用户的需求）

+ \$ \) G& ^3 z; k8 |* r" n验证HTTP请求的数据
. G0 b, U+ r2 m$ q: h
+ C; C7 c& h( \  G; L) C5 \! l将用户数据与模型的更新相映射

选择用于响应的视图
& Y! W& J" N9 s3 x4 [
View（视图是用户看到并与之交互的界面）
9 d- k: z$ }" B9 ~# G$ J! f
产生HTML响应

请求模型的更新
, O' c0 v3 j  A( r* {) T9 J3 Y% G
/ x! |3 R7 B5 ]. B* Q提供HTML form用于用户请求
+ `; S; l1 t2 d4 \+ o
' p8 Q* E6 f9 z# L' TMVC的优点：
& U! ]) O! M+ i3 a; v7 Z
$ A( [( t4 D" a7 I        低耦合性：视图层和业务层分离

$ b2 B: Y4 _4 L2 }( k3 ]2 X高重用性和可适用性
; U9 C( {7 C# ]+ f; }' \+ h
较低的生命周期成本
/ {) u3 k5 I# c9 ]
6 _: b4 u# {  \& t- X" L快速的部署
9 v3 ^. ^# |3 [! |8 |  x% D  E3 q
可维护性

" `9 n) {7 ^! B. g有利于软件工程化管理
. I0 o7 J6 M# ]5 R: @9 s1 K
提高软件的健壮性
' \5 G, T! S- G" |; F: V0 X
& I5 t$ |5 b3 j( u1 tMVC的缺点：
4 H% S8 V" o- b0 Q8 j
        工作量大，增加工作的复杂性，MVC不适合小型甚至中等规模的应用程序
( F3 ~: H4 b# O2 k, @- n

# A$ _1 R5 V9 N/ T: c
什么是Model 1结构，以及结构中各部分的功能
/ Q2 y* C4 k: d* N1 u3 t* O5 q' G5 m结构：jsp+javabean
' x. z, f) K/ y1 L
Model1中使用jsp来处理web应用中的视图控制部分

" L$ V5 B; D- X' m! C; E' hJavabean收集参数

- g. B. E4 f1 ]% b1 j. q
( ]8 ?5 s' F4 y% ~" V
什么是JavaBean?
% A: z1 X' D; u9 j) b7 }用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。
: G4 k6 F8 m, i+ {( H! X2 d1 C) C$ t2 k! t
+ o, T3 O5 E  J* f! b' M
" B9 ^9 |. e) ^* g6 P
JavaBean的规则？
使用get和set方法定义属性

8 v  d, c' ]+ B# i一个无参构造方法
  C- n8 l. z* z2 z
无public实例变量( 所有属性私有化)


/ S/ t7 j! o9 b+ p1 H; }
什么是jsp标准动作？包含那些？分别都是什么功能？如何使用？
JSP页面中使用类似于XML的标记表示运行时的动作

% G3 z+ d! y% y% n  `% \jsp:useBean

! P! \$ S3 l; B8 q& j$ T. Kjsp:setProperty

! K  r, S+ S+ v  R2 Xjsp:getProperty
" ^  X# J* [) \" u
jsp:param
( O- F( U# a9 M
9 M$ z  K; m: q1 H; Yjsp:include
' n8 d/ R4 \- ^" W3 ^( w* a
' i: J* S2 C- s# H: q4 Qjsp:forward

( v' N& w. {! H0 ]
2 Q  d% ]; y: k, m; h8 Z
用代码示例如下标准动作的使用：useBean、getProperty、setProperty
<jsp:useBean

id=”myForms”

class=”com.base.mystruts.forms.MyActionForm” scope=”session” />

    <jsp:setProperty name=”myForms” property=”name” />

1 X: K- E/ r' O6 \0 j<jsp:getProperty name=”myForms” property=”id” />


$ W- s* n9 X% C# ]; s. f7 n, x
描述说明Bean的四种scope
& ?+ t- x9 r7 ^- Rpage

; C$ O& c: R9 `; }- ]" c9 Grequest

7 H3 b4 t: }  \$ i/ h, X8 Lsession
  G: K1 D# _0 }! k
application
1 Q1 N4 ]5 z* Z3 Q# R; P/ z3 y


8 e8 H/ n6 u; |  y) T3 w7 t描述说明页面上的字段和Bean中属性的对应规则
id 指javabean的变量名
; d7 g0 B9 z8 F7 X  g! s; _( V
" F2 D& X+ Z$ W$ H' z4 Mclass指javabean类的全路径
% h- q. F+ r4 `& V
$ r1 s- M. P: Y: k! v. y, Zscope指javabean的应用范围

name指所用到的javabean的变量名
# Q) A$ ], k0 C/ f8 b
$ q. U1 D8 I( m6 n  D$ {! Z5 j    property指javabean中的属性



描述useBean动作的处理过程
( b% {2 P2 I3 f7 M% A  e使用id声明变量

试图在指定的范围内查找对象
9 P& A% R- B! J
如果没找到
8 i* L2 e$ n# {9 n- X, A* u' e
3 k  Q" o( X% b' T7 f9 n创建一个类的实例
0 {8 z# \7 R" P* V2 a# z
* h. Z) U5 G4 I8 q8 k2 E" M0 s执行useBean标记体初始化对象

/ K; Z! T* n) I3 Z! J如果找到
: Y7 P9 g( A1 \7 t2 w
+ d& _' Z2 f  i. ~0 B7 P     将对象转换为类指定的类型

) S, {1 }0 g+ N5 x; p, V
# ]$ ?# I/ |6 @( q  {+ K
( B  Q  y) j, s& Y" ^% g描述forward动作的功能
使用脚本代码处理请求时，可用jsp:forward 动作产生一个不同的视图，
) f9 U7 T, E* d; {8 H+ ~) ?+ S
使用同一个request：
  n. ?2 z" f; N, d8 y5 b

( K, j% M' \4 d% O* K
1 J) v% v: N" g1 X# J( E6 {什么是Model 2结构，以及结构中各部分的功能
* ~) ~- x& d# [" [5 L" B% F8 ]5 ejsp+model+servlet

Model 2架构使用MVC模式，JSP页面充当视图，Servlet充当控制器
$ [6 A9 v) L9 ~! o6 E5 B
) D/ Y" T: F2 m# NServlet控制器：
; f7 j0 |1 \7 W. C
8 y$ u6 C+ w. Y) u; d验证HTML form数据

* v+ s8 J/ ]) t0 H/ h! W3 v调用模型中的业务服务

& `0 k, o4 A. h3 X. b8 T6 `存储请求（或会话）范围内的域对象
: l+ _6 {* _1 U) t
+ ~3 M8 ~: \9 t$ j; J, ~1 V3 l选择下一个用户的视图

5 b: X7 `  R8 B* AJSP页面视图：

. P; z) o. l7 p2 T1 C3 |4 i使用用户界面（在HTML中）
& i" i$ ]4 u3 k6 |
$ y1 ~' _+ Q; E6 m) v* N        访问域对象
0 o+ M# v, [8 h" m
. X0 g& d- r; V0 O' \

) h( Y7 u$ g+ O8 V/ B; I3 z% H如何获得分发器？分发器的功能？
上下文对象中的分发器：

ServletContext context = this.getServletContext();

: Q! l, v8 R8 O: r; B$ u8 Z6 ZRequestDispatcher servlet = context.getNamedDispatcher(“MyServlet”);

servlet.forward(request, response);
( B$ Z0 o- s# Y' X4 ^
' R" y( H! O; I/ P  p请求对象中的分发器：

; O+ d8 p3 N& E, X! \; X4 TRequestDispatcher view = request.getRequestDispatcher(“tools/nails.jsp”);
3 O( G: t4 c. P& u
view.forward(request, response);
8 u3 V, K8 I  V7 N7 O6 q5 s
& I1 ^- S( A9 p6 S: j: t可以将请求转发到另一个jsp页面，并保持请求的传递性

, D% V! y& n# }, |8 s. J8 L

# f7 c) C0 E: K6 @! p! TJsp中页面跳转的两种方式？
$ O& U/ l9 J6 R3 [) i: _, F% R$ U4 U使用分发器跳转页面
5 q$ _( ]8 e: lRequestDispatcher dispatcher = request.getRequestDispatcher(“url”);
( e+ V9 S+ i: \. h/ s
. ^5 P, @$ h; J# e* tdispatcher.forword(request);
# i  L3 }: q) J4 C6 E
& q9 x. j9 n- {7 f$ b& ^6 [    特点：保持请求的传递（上一次请求中的数据，在下一个请求中仍然可以得到）；
6 H" F; I. X- g
( a3 ^6 ^& D/ O2 l* s8 s9 G- Q        转发的页面只能是同一个Web应用程序的其他Web组件

使用重定向跳转页面
4 _4 {$ p  S; ?6 m4 L. Sresponse.sendRedirect(“url”);
& Q7 v. G( k4 F# x9 \' u
& k3 w# A6 V1 c" ~    特点：产生全新的请求，（上一次请求中的数据，在下一个请求中不能得到）；

        重新定向的页面可以是任意的URL
# q$ G+ x% r0 F6 e( l* @9 o. V

) q: Y7 h( y: a4 ~" w! f/ _) Q5 i
" N( M1 V% r+ s3 O. K  ]: b+ y描述Jsp中引入另外页面的两种方法，并比较两种方法的特点？
<%@ include file=””%> 在编译期间把另一个页面完全嵌入这个页面,可以说是一个页面
7 e' `1 }* b8 y/ m* I: k
+ f: L2 n" v% f* x: M在这里可以共享变量

<jsp:include page=””> 动态的再运行期间把另一个页面加入这个页面,可以说是两个

- y' U3 n' |/ Q8 }页面，不可以共享变量
+ ^9 ^& o. \( P$ o7 t" A  L" a


什么是自定义标记
自定义标记库是一个Web组件，

包括：

一个标记库描述符文件（*.tld）
! N+ g1 u; `$ I+ E/ ^
" i' S% L' k  p( c# A, S所有相关的标记处理器类(*.jar)
4 s/ V' u6 s, y6 N. x! b3 ~% y1 }
7 ]. d5 p  ]$ C" A

; b8 k, a+ D" _描述使用自定义标记的步骤，以及每步详细的工作
使用自定义标记前，要拿到.tld和.jar两类文件

5 V3 `! C" o. y% c2 G把.jar文件放到WEB-INF的lib里面。
1 ^, m# q" m* }. N把.tld文件放到WEB-INF根目录下。
! g  K7 j/ W7 J9 f# P7 n; b在web.xml中配置。
9 w4 {1 o7 D' q<taglib>

3 t) l/ J: J2 ~: T' o; m<taglib-uri>http://java.sun.com/jsp/jstl/core</taglib-uri>

! D: D. T3 c# b9 p     <taglib-location>/WEB-INF/c.tld</taglib-location>
( H7 \  H1 W1 n. r& u2 e0 S
</taglib>

在页面中引用。
<%@ taglib uri=“http://java.sun.com/jsp/jstl/core” prefix=“s”%>

# {1 o& E" g7 w1 G/ _0 Nuri必须与web.xml中的uri对应
. g3 i- s! f1 V6 A
prefix是前缀，用来区分是哪一个taglib
# O* j9 S) U7 G1 W
使用标记
格式：<prefix:tag名称 属性>
; ~1 a& H  C* [; m$ I( u/ P8 J, N
! H% o- E. C  T<s:forEach >

admin

在tomcat下配置数据源
+ y  g7 s& }; ~) D4 v1、服务器与数据库的连接
( ~2 v& F+ X6 S! j8 j; k
( }& t5 R9 K( W0 f( W7 e8 X配置server.xml文件
2 A3 J* e3 |6 J* }# L
1.oracle

" G2 s- ~/ R6 _; t2 ?* L<Resource name=”jdbc/company” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”

+ q- D* P: A7 {2 ^8 Z' ?4 z                        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”

7 l9 K7 ^( l. r9 D3 Q" d- ^5 Z& Vurl=”jdbcracle:thin127.0.0.1:1521rcl”

driverClassName=”oracle.jdbc.driver.OracleDriver”
2 n' g) {& ?( r& G
username=”aa”
6 L1 O! o" w2 a% O0 E
password=”aa”
. T+ b$ W0 V& Z' U
2 u* C) z  ?& E$ WmaxActive=”50″

maxIdle=”10″
0 L4 u) e( U5 ^: ^. R
/ i$ j' i9 J5 y3 ~" ~maxWait=”-1″

/>
0 W, y: p; b) C
* O2 f2 `! X) T2.sqlserver

3 y4 r7 r4 V4 F; z  V2 \9 W; n<Resource name=”jdbc/webpage” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”

2 ?& p& C: v5 S        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”
4 \) \! y8 E/ Y+ j! a! s4 G- Q
) V2 R) z; s" h% U4 }" eurl=”jdbc:jtds:sqlserver://localhost:1433;SelectMethod=cursor;
7 i, ]/ |9 Q/ Y/ j: h; z0 ]0 K
/ Z2 W; ^5 B4 e, ?DatabaseName=webpagetest”

( U# W' X; I6 ^+ f( [9 qdriverClassName=”net.sourceforge.jtds.jdbc.Driver”
5 R8 `5 \6 K# s+ {$ ?; _0 i
username=”aa”
% T  X- s+ @" v4 l- Y
& b- `# S+ x* Ypassword=”aa”

7 ?* K6 k7 a! a$ u. L$ R( C. fmaxActive=”50″

maxIdle=”10″
1 S$ V9 C/ ]2 L- H7 v/ M2 g
maxWait=”-1″

5 m& z6 @+ ^; }9 O/>
8 D# n. D' k0 \, d& v7 W' ^8 o
- J/ X: i6 h- V2、配置自己的web应用的xml文件

2 _0 b3 `7 S) e

! Z: M& o" A1 ?% z5 z+ M<Context path=”/eb03web” docBase=”F:/workweb/eb03web”
" b& B$ o. n6 t
. q+ Z0 d3 L% A" H, |! E  zprivileged=”true” antiResourceLocking=”false” antiJARLocking=”false”>

<ResourceLink global=”jdbc/company” name=”jdbc/company” type=”javax.sql.DataSource”/>
2 x, o2 v/ @& _
</Context>
8 S2 x" o, f. B! l
% F+ q* j6 \7 |2 @# w$ B2 p

3、配置web.xml文件
( }5 F8 U8 o4 D0 S" g' X
# K% C8 E' [+ A  b+ {与服务器建立连接
7 [1 [& @9 ]! X/ X
8 h: M' o# \! X! A( ?$ h<resource-ref>
5 t7 U6 b# X9 f3 i% g# i% _
5 b; P9 K# t$ o* o7 |9 H0 {<res-ref-name>jdbc/company</res-ref-name>
" d6 T% l! v5 J" g9 ?
<res-type>javax.sql.DataSource</res-type>

" e' i6 r5 [/ E- ^8 I) {<res-auth>Container</res-auth>

7 m. a8 `( n. e0 T</resource-ref>

4、在应用程序中不直接与数据库连接，通过DataSource连接池建立连接

//1.在程序单独用时设置系统的属性，在tomcat下可以不用配置，

System.setProperty(Context.PROVIDER_URL,””);
' u. P9 p5 J1 @3 @
System.setProperty(Context.INITIAL_CONTEXT_FACTORY,””);
4 W/ @. O7 L8 }# O
//2.创建一个上下文对象

InitialContext context = new InitialContext();
3 g8 O& p6 x- m
* K+ I8 F$ N5 ]+ v9 t//3.通过上下文对象在连接池中查找DataSource

DataSource ds = (DataSource)context.lookUp(“java:comp/env/jdbc/company”);
1 x; j& ~9 s5 u- I& v
% Q0 C9 ~7 _+ k/ ]4 C$ D0 D//4.通过数据源建立连接

% Y# o/ t5 Z3 a+ ^/ b( _ds.getConnection();

admin

ORM对象关系型数据库映射
5 u% M; P5 u& ]2 Q, _(Object Relation Mapping)
6 H  o; I( e5 j+ c
0 n2 V3 D9 v0 }一、映射的特点

1.一个对象可以对应多个表
- E7 {* S# y" [/ _' h& u
# t  L$ E" u. V- |- s' ]9 T2.一个表可以对应多个对象

2 ?5 N" N3 |/ \& ~) R+ @2 E) y1 N3.对象和表的关系不用完全对应
$ B0 b' k2 E2 F: V: N& `7 F
, q$ _* a7 I+ }4 t4.对象的属性的名称和表字段的名称可以不同
* B9 |/ v0 m' e: p) r0 [
5.类型可以不同，但数据类型之间可以转换
  X' R3 g: s7 Z3 m  e* q# H
6.对象中必须有主键，数据库的表对主键无所谓
  l% M  p! W- F' V. a* k5 N2 |5 f
7.数据库中有主外键关系时，对象中可以有，也可以没有


8 X+ W/ [- k! \
$ H1 q$ l3 D8 P2 Y" n6 E+ W6 k二 、有一个映射的描述文件————>xml

- f( Q" H0 b  m4 o# Z' d三 、怎样实现描述文件————>一段程序

对象 映射（mapping） 数据库

) R+ t' ]9 x/ m+ c4 I/ `user
" Z7 k3 l9 ]" r/ N% J
  m: m# D: g! g* [+ V( H) [# Jid=11

- t( B% A' [6 q" z- z2 _) O: fname=”张三”———— > (1) —————> tbl_user(id,name,age,tel,address)
. f9 `/ p# E8 T0 t5 `, ^; f
% C* ]' f  Z" X* s# q1 `age=25 <————(2) <————

9 z/ L7 i. a3 t+ U  J/ ]7 w
) f0 e: H+ `% z' _4 _, B9 r
" u; n% ?. G: O0 S9 N' L(1)从对象映射到数据库

# u% T1 U3 a4 k! s1.JDBC
- {. h2 _1 w& s% @3 A+ ^
# M+ i( z9 p/ T1 @# h3 [, L/ i9 ~2.根据描述文件来动态拼接sql

3.执行，添加到数据库中
+ {, \2 k+ h+ A% o/ ?: E
$ z3 V- p1 H) B# s" A

(2)从数据库中映射到对象

1.JDBC

2.拼接查询sql

3.ResultSet
' s% ~# o$ Q( `/ w7 q7 \; {$ S% Y
4.Model

: N9 @6 o5 t$ M3 k( u& U, y

hibernate
开发流程：
  ]; j0 e. k2 O+ J9 K+ q% Y4 I& G
是什么？
hibernate是一种基于orm 的轻量级的框架
$ N& k: D4 P/ d+ u6 j% Z) Z

; X" K: A9 D/ S% u% Y4 f5 i5 Z: u
有什么？
1. session 保持连接状态（依赖事务和连接池）
5 K8 J! Y4 @* U/ Y3 Q
2. Transaction事务

/ o0 U/ }' |  m% I  Q, H3.
Connection Provider 连接池



+ {) r4 Q$ P) N) W' z能干什么？
1.orm

# ?# A7 Q; l# w9 j# o+ K5 P7 e. M2.提供操作数据库的接口，简化数据持久化的编程任务


3 S5 D6 O2 ^2 J8 g' Y3 _0 {7 @
怎么做？
9 s9 W4 `9 C6 i! d/ b4 R1.搭建hibernate的运行环境，将hibernate的包和hibernate所需要的包拷贝到lib 文件夹下
3 m! c# p! a5 j- i
2.O（vo）

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

4.配置文件

$ }4 G* X( z: A# a5 L! ^, U# ]4.1 cfg.xml 放在classes根目录下，默认名字为hibernate.cfg.xml
; T0 N1 |; Q+ f9 h$ G* ~4 u
a.与数据库的连接
3 p/ R4 m  e  B8 h: D( I* F8 x7 c) U
$ t  I0 G' v" _$ C# qb.可选配置

c.映射资源的注册

4.2 hbm.xml文件 名字与类名相同 并且与类放在一起

a. 对象与数据库表之间的映射

b. 对象的属性与数据库表的字段之间的映射
* N6 @0 [2 i9 W6 s4 U5 h
c.组件之间的映射
' j) x1 Q6 p3 s! G1 z6 L
0 t. U) X  l2 K3 O! n$ t6 od.对象与对象之间的关系映射

5、客户端

, \3 N9 Y* v% x6 h1.得到SessionFactory
0 L4 m: J( E# q$ z1 P* ?
2.通过SessionFactory 工厂来创建Session实例
3 h0 P" r& I) X+ C6 y  {
3.打开事务

4.操作数据库

1 z  E6 j4 q* |- n/ k5.事务提交

6.关闭连接

, I" @8 V7 ?. m$ |0 B运行流程：

) c! U0 [, k/ Q7 K( @整体流程
8 {1 a' U0 ~( K; P& J, J1.通过configuration来读cfg.xml文件
" K3 o/ C9 S! t% O4 H
: ^; M( f* g- [4 I0 d2.得到SessionFactory 工厂（根据数据库的连接来创建sessionfactory）
2 D0 U! }0 Z$ B
9 t/ Z* M' Y4 n$ y3.通过SessionFactory 工厂来创建Session实例
$ k: ^2 I- H9 ^8 W9 V
4.打开事务

6 a1 p* w- B% k9 o9 E0 o1 {5.通过session的api操作数据库
( S0 {- l% Q$ v# k+ |( l
6.事务提交

- C! z, L. S$ X! j7.关闭连接



save
1 j" x# s" m: B( a1.to—>po
# k7 F5 o/ {, i' d6 N4 R$ a
2.根据model和cfg.xml中映射文件的注册来找到hbm.xml文件
2 }2 ?$ G: @" A9 i$ ^- O3 D
3.根据hbm.xml文件和model来动态的拼sql
. ~. U% Z* @& j
4.客户端提交或者刷新内存
- k$ ~9 J5 ]" L% t
5.执行sql，值放到数据库



8 a% ^$ e- _9 l' U0 q" J, q" R0 |update、delete
; d9 A  m/ M: E* \& Z6 a1.根据model 的id在内存hibernate的缓存中查找该对象

9 r& i; x% Y: _/ |7 T8 T; _如果内存中没有就到数据库中查找来保证对象的存在
# r# m) y' a1 a$ m4 h, X/ H! r
2.根据model和cfg.xml文件中映射文件的注册来找到hbm.xml文件

! ~4 o& k, i. s3 a% X& A3.根据model和hbm.xml 文件来动态拼sql

4.客户端提交或者刷新内存
5 B- {' o7 C$ Y8 x, E" T
5.执行sql
) }+ u+ T( o' I6 o, P


! C9 B4 y0 @% YQuery
: {6 u+ @1 p% i0 f% S/ `load
) ?8 B- b8 k9 o2 p- O5 i% M% d; O
1.根据model的类型来找到hbm.xml文件
# E' i1 h2 }3 E" E* Z: d0 r% P' l- @
2.判断id对应的对象在缓存中是否存在，如果存在，就直接使用，如果不存在就进行下一步。
" J/ T" w1 |* s
3.用id做为查询条件来动态拼sql

+ P. P, C5 o% q2 N5 M4.执行sql 查询（先在内存中查找，如果没有找到（会抛出例外），就去数据库中查找）
# q8 V; y4 O) @6 r
5.返回一个model类型的对象

! ]0 j' \  E3 U  G( oget

    1.根据model的类型来找到hbm.xml文件

2.用id做为查询条件来动态拼sql

# ?1 X; a- `* \3.执行sql 直接在数据库中查找，如果没有查到就会返回null

' J, H7 C$ F' h7 e) A4 a* i; @query

: n! r* Y- w" g1.分析hql语句，得到model的类型
1 d- M: d! N6 k0 m$ c+ A! B9 ?. h
2.根据moedel和cfg.xml文件中映射文件的注册找到hbm.xml文件
/ C" [8 O, q" a( @& {( F2 t
3.根据model和hbm.xml文件来动态拼sql

4.执行sql查询数据库

5.返回一个resultset

; v/ x2 ^, d9 m& b2 }  [: ]$ y6.循环resultset的值，放到model中在放到集合（List）中

3 i, }! U; Z: n9 I# Q+ K, P

6 c6 }0 k/ O, u  Z! l; R1 a谈谈hibernate缓存机制
: j% u9 n9 }; ^, n
缓存其实很直观的理解为放到内存或者硬盘上的一块区域，缓存就是一个缓冲的作用，有很多时候，我们的数据需要经常访问，如果放到数据库中，不是不可，只是效率上低，如果有了中间产物来代替数据库，就省很多事情了。打个比方，去买酱油，不一定一定要去酱油的生产工厂去买。代码中需要数据的时候，可以先到缓存中查找，如果存在，就直接拿数据，不存在就去数据库中取，也省了很多事。
2 E; U3 W: n) {, Z5 w$ K
( |2 b- L2 m6 U# o7 q
* |3 j8 ^5 `0 d* e
% F+ v' ~! g, X' X  vhibernate使用的是二级缓存，有两个级别，分别是Session，SessionFactroy级别，一级缓存是Session级别的缓存，Hiberante来管理的，这个我们一般不用管，二级缓存是SessionFactory级别的，可以进行配置和更改，加载卸载，就是我们平时用的hibernate配置文件中的配置SessionFactory的属性。


& \3 L8 F, Q& l9 i, z9 F( y- ~3 c
; P1 s3 o5 `9 K: j3 f对一级缓存中的session事务进行数据的预存取，数据在各个session的上下文中存在（单例），当session关闭时，就是session.close( )，整个所有session范围内的数据全部清空；二级缓存默认的情况下是不开启的，如果开启，数据库汇总的所有数据都先copy到二级缓存中，这里要注意的是，一级缓存是每个线程下创建的session缓存区域，可以是多个，二级缓存只有一个区域 ，画个图比较容易理解。

7 U% P& E0 I3 t" T6 n1 D) s6 K# {

0 k! A! J$ @. L/ k' I| 一级session缓存| | 一级session缓存| |一级session缓存| |一级session缓存|
4 w' a6 `- p, G& V$ f
| | | |
. H! F; r) E8 z4 J1 y: i
. O6 ^1 p1 }5 `4 ~' C$ }| | | |
+ j/ Z) S* d; ^" ^* M
—————————————————————————————————

sessionFactroy级别的二级缓存
$ l% u9 p% @* k) X6 A
——————————————————————————————————————-
2 H0 J( y' Y5 G6 U. C
  g* |5 R/ y9 L; _|

|
: _; C7 j7 Q' `, i+ I: V0 S
" ?" U9 K' F2 T|

& p; c4 i( A0 b. f" X$ ~: M——————————————————————————————————————
; G% a/ r- n" ]7 g( e* l3 I. T
; B- l' E! [; R) L+ w. e9 IDB

—————————————————————————————————————–

# N5 x+ }* _9 r# {* l

admin

Spring
: n* f* N, k; l! q

• 是什么？
  * h: e9 U" C" `
  9 O4 A6 n3 L/ [: _9 l4 c+ x6 k, s

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

• 有什么？
  % S! D% |' s, [  q# Z: o
  * u5 T) E9 f8 R6 l' F

每个包的功能：

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

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

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

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

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

AOP ：面向切面编成

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

• 能干什么？
  
  

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

• 怎么用？
  6 g: K3 @& g. L
  8 l3 J/ ?3 ?* t7 I' ?1 u
  • 搭建web工程，引入spring的jar包
    6 L/ y! o0 u8 \' A' O
  • 在web.xml中添加如下配置
    
    " ?: x) u* i1 Y
  
  
  

            contextConfigLocation
, Y* I8 t$ K* j8 ]

            classpath*:applicationContext*.xml

   
* Z6 Q2 w" S1 |! W4 I5 ?5 \

        

            struts2

            

                org.apache.struts2.dispatcher.FilterDispatcher
1 E8 g% v6 M& c* y8 U

            
& n4 ^! l: V! L% _

        

        
. N1 u5 p: ^5 g' G

            struts2
) M' [5 `" f+ x  l  f

            /*

            
/ q. L# L# k  d5 a9 a

                org.springframework.web.context.ContextLoaderListener

            

        

• 部署
  8 p4 t/ ]* ^8 B; U9 ^! t# S7 K
  

" J0 z( u4 `( _. t- W* M: h

• 容器和bean
  * f# z2 P' @5 z0 W4 r$ P

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

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

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

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

• IOC控制反转
  
  
  
  
  
  从前的应用程序想要得到A的实例他会直接主动的去拿，当用了sping后，应用程序由主动的去取变成被动的等待，由spring来控制应用程序所需要的对象
  
  
  • IOC的优点
    / O( y; P! V3 u; X  r
  1.可以通过IOC来获得实例
  2.可以通过DI来获取注入的资源
  • 配置IOC的原则
    
    • 一定是可变的资源才采用依赖注入
    • 一定是层间的接口或者是模块之间的相互调用才采用依赖注入
      $ Y4 _  D. I. y

• DI依赖注入
  ; N* s. u0 F# X( R. z5 S6 `

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

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

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

例如：

在配置文件中

在应用程序中

Public DBDAO dao ;

Public void setDao(DBDAO dao){

This.dao = dao;

}

3．构造器注入

3 j: M% q  \( i3 q

4．ref 表示参照其它的bean

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

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

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

6.lookup注入

7.singleton

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

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

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

8.DI的优点：

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

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

• Aop面向切面编程
  
  

1.AOP面向切面编程 一些较好的模式或者是示例—-范式
* r5 q0 n  h/ _6 N9 Z0 ~

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

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

3.AOP 的概念
  k- Y4 K7 s2 z" k" b

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

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

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

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

5.引入 ：扩展的功能

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

7.aop代理 ：实现机制

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

4.AOP的事件机制

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

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

3.找到切入点

4.确定连接点

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

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

9 e5 D9 v5 n4 N' u


4 l: x9 G8 n# L0 z4 Y- D7 H$ h

5. AspectJ
  N( u" b! ], l. c* o

5.1.在xml中配置比较烦琐

所有的入口必须从一个代理（ProxyFactoryBean）开始
) c  Z9 N1 n" i) X

         
9 g7 l  g# R& N% _; n
% U6 d2 z( m" h$ E
% t, _$ B* r/ B1 D$ a" W         
& Z! e2 ~( O* P( P

        
$ A# ~" H' ~& m, x- }' l# H

        

' m1 I4 ~4 _; U# g; Wexpression=“execution(* com.javakc.aop.MyTarget.t*())”/>

        
" A" v) G" `5 }+ {. L! ?

        
! {$ H$ D+ W3 Z

   
7 W, G/ x2 h9 i

. _: m  M; n$ _' l( A
7 [0 a, R2 U. I

5.3.使用注解的方法相对简单
+ @3 O+ I" B- ~8 R: f/ I+ ~! y" [

@AspectJ的基本语法

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

直接在类上定义@Aspect
- B8 P3 ~9 a, R5 J* {

2.@Pointcut声明切入点
2 [% @1 o9 ^( i/ {& x% m

2.1、用一个专门的类来定义pointcut，类中的方法名就是该pointcut的名字
- E) T2 ]4 \" o$ f/ R! C6 X

2.2、可以使用匿名的pointcut
6 D$ a- i& f# s

2.3、执行切点的几种方法

2.3.1 execute（public * 包结构.*.*.（..）） 可以指定到具体的方法
/ A$ D1 t" D( `! j+ \9 o; u0 S6 m

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

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

2.3.3 this 指定到实现接口的所有的实现类
& V& B& @+ x# q+ w! \

2.3.4 target 指定具体的实现类

5.4.advice的五种类型的示例

　　　 客户端必须从接口走才能得到监控，实现想要追加的功能
& O, O9 x  R! x, ]" b9 j

5.4.1.@AfterReturning(pointcut=”” returning=”retVal”)
0 f# v8 f2 W( Q" w9 u& H

追加的方法的参数名字一定要与retrning的名字相同
! [& k# J& b3 J: ~. z6 g

在注解@AfterReturning中必须加上pointcut和returning两个参数
3 v0 D1 ?+ O; ]( T

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

得到目标对象的方法的返回值，来作为参数，进行下一步的处理,参数没有顺序，按参数的名字进行匹配

完成追加的功能
* a" W; \4 b+ i% q' F& ]* I

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
& M  l; a6 }& z8 |

(1).@AfterReturning(“com.javakc.spring.schemaaop.TestPointcut.t4()”)
& l* c$ r0 M- n+ |) F, o

(2).

     2.直接引用匿名的pointcut
- L3 y: k4 K# X2 O7 q1 k$ d

     (1).@AfterReturning(“execution(
8 h: K* M1 m& j2 m4 }

* com.javakc.spring.schemaaop.Api.test4())”)
9 \0 Y$ D( {, V, l$ i* a4 n

     (2).@AfterReturning(pointcut=

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

args(str)”, returning=”retVal”)
' T" {- O( @$ ^) u; b" H* F

@AfterReturning (pointcut=”com.javakc.spring.schemaaop.TestPointcut.t4() && args(str)”,returning=”retVal”)
0 ?- T  ?. r/ }; @; h

public void testAfterReturning(String str,Object retVal){

    System.out.println(“afterReturning1=>”+retVal+”=>”+str);
9 T9 o& k' v% [8 I

    }
: v+ k3 X7 ?% P4 X. w+ I1 U

5.4.2.@Aronud
3 s' p7 C$ R) r1 c6 A, l

     注解@Around环绕追加功能；
2 R8 U! P% i: S) i+ X' F  x# \

     在执行目标对象的方法的前、后追加功能；

     必须有参数；第一个参数的类型必须为ProceedingJoinPoint；
7 y, E" e4 ~  Z

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

目标对象的方法

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

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

     (2).@Around(“com.javakc.spring.schemaaop.TestPointcut.t2()

&& args(str)”)
) H- \/ H9 O. c2 ~

2.直接引用匿名的pointcut

     (1).@Around(“execution(
' n; J: W6 J, r3 P

* com.javakc.spring.schemaaop.Api.test1())”)
0 k9 F) y0 W& G. c9 X

     (2).@Around(“execution(

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

// @Around(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
  b0 F8 r; f0 h8 n- l$ ?

     @Around(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
% I8 n9 q" }  |

public void testAround(ProceedingJoinPoint prj,String str) throws Throwable{
, q+ ?! x) \3 m* u6 U) }% m) X

    System.out.println(“around1==========before1pointcut==>”+str)
" g1 c! d5 s# y/ k( Q

        Object obj = prj.proceed();

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

    }

5.4.3.@Before
! U8 O0 C! F9 I: S) N

注解@Before在执行目标对象的方法前追加相应的功能
5 R+ P2 f. q: ?: b

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
9 d2 U, o+ w- w* l6 e( m' ?5 \

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

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

注意args后的名称与参数名相同
3 b( G. l4 x2 Y

2.直接引用匿名的pointcut
7 F5 T8 y' l/ N' I8 Z/ l& ?% o

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

(2).@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
" j% r: @9 j5 p/ Y/ C& ?# U

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

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

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

public void testBeforeParam(String str){
  Z4 F! k; Y' ^

    System.out.println(“before1=param=>”+str);
; f" x& i& X  |

}

3 L0 x5 D. C' o6 C* L5 `* M* \& @5 F

5.4.4.@After
5 R- u7 {- j% K! H; [- k

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

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

     (1).@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
0 J- ^* k/ }4 I  k5 K+ f/ F

     2.直接引用匿名的pointcut
6 r' i" }& {- T1 f9 Z$ v

     (1).@After(“execution(* com.javakc.spring.schemaaop.Api.test1())”)
  y: _: o( j0 B- _- B3 Q

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

    public void testAfter(){

    System.out.println(“after1== >pointcut”);

    }

5.4.5.@AfterThorwing
3 r/ q: J. I0 ]5 G  y- }% j! I

6 K  V& ?, |# V& O' r4 N( Q# N! S
9 {( H2 r  m) \) _

• 描述一下spring中BeanFactory和ApplicationContext的差别
  
  2 Y: ?. c) H" g/ f" @2 S* b

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”);

• 谈谈spring对DAO的支持
  6 |* s  ?2 N7 o- _( Z1 v
  

Spring提供的DAO(数据访问对象)支持主要的目的是便于以标准的方式使用不同的数据访问技术。
% a6 Z/ V& _; C

简化 DAO 组件的开发。
- O7 c' E0 {  F( z8 CSpring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法，用来简化代码开发。

IoC 容器的使用，提供了 DAO 组件与业务逻辑组件之间的解耦。所有的 DAO 组件，都由容器负责注入到业务逻辑组件中，其业务组件无须关心 DAO 组件的实现。
4 |% l) a6 @" r" A/ c6 b/ H: {

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

方便的事务管理: Spring的声明式事务管理力度是方法级。

异常包装:Spring能够包装Hibernate异常，把它们从CheckedException变为RuntimeException; 开发者可选择在恰当的层处理数据中不可恢复的异常，从而避免烦琐的 catch/throw 及异常声明。

% H) I( r( J' S# f2 O" _

• 谈谈spring对hibernate的支持
  , T$ C* r8 a, f+ x9 I' g
  

在所有的 ORM 框架中， Sping 对 Hibernate 的支持最好。如 SessionFactory 的注入、HibernateTemplate 的简化操作及 DAO 支持等。另外， Spring 还提供了统一的异常体系及声明式事务管理等。
% b; J1 j6 ~7 B

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

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

! O# Q0 ^! ]' u9 P

        class=“org.apache.commons.dbcp.BasicDataSource”>

        

            oracle.jdbc.driver.OracleDriver

        

        

            jdbcracle:thinlocalhost:1521rcl

        

        
. k) L) }) }! ]/ ^- p) b9 S0 D8 w

            javakc2

        
+ K/ d9 z) o$ h% D0 f4 _3 W

        
! I& P- C3 z1 t) C2 {" _; K

            javakc2
$ G9 q6 A: `- r5 \% i

        

   

( V& N" N) ?" R3 L$ x; s

   

        class=“org.springframework.orm.hibernate3.LocalSessionFactoryBean”>
3 Z( l4 S7 ?! R

        
* x+ Y5 Z7 I' e/ c3 G) p

        

            

                com/javakc/spring/h3/UserModel.hbm.xml

            
" h2 U7 J- }, |4 X8 g- q6 A

        
9 M3 A9 G! a8 W5 _. }# o

        

            
5 p9 |5 b  ~2 U! m

                hibernate.dialect=org.hibernate.dialect.OracleDialect
, B+ B6 J; _* J; B2 }

            

        

   
! ]. A. e- J2 p5 J; y# O. {4 ~

   
. W( I/ T: k& y' H

        

   

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

   

        class=“org.springframework.jndi.JndiObjectFactoryBean”>

        
* z  G6 P$ ^( f0 @6 k1 \$ z4 u

            java:comp/env/jdbc/myds
0 g- ?( y% d0 v. O8 M% x. _1 v

        
4 j8 v3 ]( c) j0 L4 Z9 _7 E! r$ x1 \

   

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

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

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

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

   

        

   
8 o4 [' P" F' `; C

   

        
$ Q4 Q6 _. p7 ~

            

        

   

   
6 d/ Q& j0 w1 F

        
# _$ w9 u+ i/ ]* x7 K

        

   

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

0 q6 R5 Q0 O7 w2 B. i

Spring2.0之前事务的写法 - s; J) ]0 C* ]1 n! m/ ` 3 I! ^) }% b$ E4 R         class=”org.springframework.transaction.interceptor.TransactionProxyFactoryBean”         abstract=”true”> ; E, N9 i1 u& {. Y 5 ?. g+ [4 n, b3 o $ ~# _3 w) D& g# r9 a) l! z                 PROPAGATION_REQUIRED,readOnly + `4 i- y) U; C; g0 A5 A" v9 _                 PROPAGATION_REQUIRED * \3 h8 ]. T0 Y

" D3 l2 ^! T6 I6 v
2 V2 A1 S8 `8 U

• 谈谈Spring对事务的支持
  
  

1、声明式事务管理：

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

2.做法：

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

2.2

2.3 注入数据源

6 u( D2 @2 N+ i" z2 |
( U9 E, k% A! b
0 h, F8 ~8 k: g( c
. F+ T( g) L& u7 i% d2 h) W

. v3 X$ L1 ?% g* @& m

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

- y1 A  U* t& u* g( i: N

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

8 |% g' X7 o0 u5 ?" l' \



) p: f/ k" x5 e) G: V

2.6 定义切入点

9 J: `+ I: p+ F2 t2 I$ y

5 z, m/ [9 t, \1 Y6 t$ m

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

1.注解@Transcational

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

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

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

  Y, e. e  w" E. s

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

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

5 J- z: Z$ `1 G2 ^

admin

事务
. ]4 v1 h  G. O* kACID
/ ?: S. B' {0 v8 M& T（1）原子性（A）：一系列的操作具有不可分割性，要么成功，要么失败

, {8 a. Z3 o0 J& m4 |$ p（2）一致性 ：操作的前后满足同样的规则，保持平衡。

1 A9 h. U- {- S' W) S（3）隔离性 ：在事务运行的过程中。事务内的数据对外的可见性和可操作性（必需由数据库的支持）

2 p4 ^: P8 y9 J$ O（4）稳定性 ：保证数据在事务的操作的过程中不会遭到破坏，而且是永久性存储的
! R1 E1 R5 t% r

' C- u' _6 W3 m. E6 h3 k
  ~: a' [" w/ z: `0 `7 h" f% A/ c事务模型
（1）经典事务模型又叫平面事务模型（JDBC） 事务不允许嵌套
; |, _* c+ y0 c: @" V, q; h) T
( l- W- c& M9 X- f8 s4 i! l" n（2）嵌套事务模型
3 A* M7 \! C! p- }( O


事务的两种方式
（1）声明式
$ g# m( q6 m5 O  O1 v9 W6 I! h& k
在配置文件中设置以下6项
1 P5 i( n6 h2 ~. G) R6 p# K
（１）.required

( O/ ]3 @6 E; D如果客户端没有事务　在bean中新起一个事务
  Q5 a' k5 D6 Q! u0 ?) o% @
如果客户端有事务bean 中就加进去

(2)、 requiresNew
4 a, Z7 c$ C$ Z. _% g/ K7 U$ n
不管客户端有没有事务服务器段都新起一个事务
. ^/ f0 q! n' T& G  H) x- C- C
如果客户端有事务就将事务挂起
/ B$ V5 q- c- b# B" Y1 Z8 R' Z
) u0 Z% x8 Z" J6 t/ M" J6 q(3)、supports
8 t8 J' M0 i' n( {' F+ i
如果客户端没有事务服务端也没有事务

如果客户端有事务服务端就加一个事务
$ ]& Y4 }# f' ~
+ Y( q3 o1 ~. M( j! a3 j! A+ Q(4)、mandatcry

如果客户端没有事务服务端就会报错

0 A6 s2 o2 Q: _) Y3 o如果客户端有事务服务端就加事务
% ]- ]6 m! N, U) B- z1 A% v) r; {
1 W' m, e: [  o  U4 ]" d(5)、notSupported
9 z% z  m- i) ^% a8 O/ @. l
不管客户端有没有事务服务端都没有事务

如果客户端有事务服务端就挂起
; [: {7 X' u4 ^. e7 r) R, `1 e
3 J  D- O+ n) X( W* Y% [/ i(6)、never

不管客户端有没有事务服务端都没有事务

7 y' n* H$ E* [  b  U4 {6 W" ~如果客户端有事务就报错

8 c/ V* u* @: _# O4 U2 n  @. P) k（2）编程式事务

Javax.transaction.UserTranscation
. s/ x9 L* J  S- n' o
) u  e8 [, F& j, \; UJTA 事务可以精确到事务的开始和结束

9 E+ c- W/ ~4 D+ g7 k( A5 R  g& H
) e( X) p! D7 w
事务的隔离性
6 w) m. B0 O. ~; W- d9 @: D7 eRead-uncommited

7 G' K! x) u+ z" ^; e# t. |读取未提交的数据（基本上没有锁）脏读，存在不当读取的问题。
2 r6 V# F- E4 f" L
Read-commited
0 F+ y4 Y; V# x6 c& h
读取已提交的数据（行级锁）
% ~" z, u9 b6 A
无法读取已经写入，但没有被提交的数据。
2 a3 K2 j/ Z9 o
Repeatable_read
6 w& F$ h+ q% P# c' j7 T. s
读取的数据不允许修改或删除

, V* O, R5 v5 S5 a4 H+ b不可重复读（行级锁+不允许修改/删除）

Serializable
* H* E9 }* F) z' L* b! ^% o
- M  P& s  y& ]$ }' V幻影读（表级锁）
$ `5 b, e# O; ^6 T! t* N5 w$ O
3 d6 ?* r" k% u3 B; V
) f0 G  z4 x# \
. e2 u1 F4 l8 X" F; p. ?+ i. ustruts
开发流程

# R. Z% A) P0 R6 P( o4 _9 T1、创建表单
0 _, c& ]& D4 u9 c- P, o
2、从表单中获得输入

3、处理输入（业务逻辑）

# d' P6 p  i  G, a9 _4、根据动态输入改变输入流
# T3 M! G  Z( L" m' @
要完成上述四步，我们需要创建
) Q( u/ F4 z& {; G# F5 g+ [
. l: _1 }/ H7 C& O) y; X5 i1、一个ActionForm
; H& l! t3 r2 |0 _
: B5 G+ ]( L2 N- U2、一个action
* \- i' p& @& y( l
3、一个配置文件struts-config.xml
, ~8 X# k+ w! j  y  b% d6 k: M
4、创建页面

创建ActionForm

1、写一个类继承ActionForm

: z! k# B5 g8 P- T* x8 B2、私有的属性
. Z* `* w- Y3 I3 b
3、相应的get、set方法
1 Y" r6 t  T6 T  V5 O( M6 K; W4 N! B
4、重写tostring、equals、hashcode三个方法
  o9 F, [0 U+ b* @
9 ~# B* {  i3 A3 |4 [; {( m创建action
+ N+ K. ~! Q+ {
1、写一个类继承Action
+ W  `. b! c+ U1 ?. W
2、实现一个公有的方法（回调方法）
* Y* P5 a* T. X" Z9 Q  r( a
& s' p- e' f/ p; `! Hpublic ActionForward execute(ActionMapping mapping,

8 ?/ [( t0 w  }! P9 @) \/ mActionForm form,
* t4 [+ d8 Q' W# v6 _2 j/ R! e
HttpServletRequest request,
. P% v6 i! b( Y5 u0 `. X
HttpServletResponse response)

8 q! G! ~  p+ Q9 |( ?6 y{
; @1 v- c, k( h
//1.收集参数

* P- w. q  F6 y" IMyActionForm myForm = (MyActionForm)form;
( _, ?# P4 g: b) R
//2.组织参数
8 b7 j9 l0 ?' _/ \( ~! ?

. E: R0 f! Z; k$ S0 n, `4 W
//3.调用逻辑层
  M9 a/ e8 v6 H3 _7 t  C
boolean flag = true;

//4.根据返回值来跳转到相应的页面
" U6 r6 S) }  O: L( s
5 _$ W0 A$ ^+ U& k: e7 P3 vActionForward af = new ActionForward();

! P* K5 v2 }; n& ?# Lif(flag){

6 W9 @! d5 Z$ }% Y6 @2 ~* Yaf = mapping.findForward(“1″);

+ y' G( {( d( @$ b}else{
$ c7 g% V. j5 P$ F0 k* t
af = mapping.findForward(“2″);

0 J0 w% G3 l5 G/ F/ O  N, [9 v}
2 R! [; J( l8 E. @" J8 z
return af;

6 d2 [1 b' j: A# w}
, f! z6 W, A) l5 M# T
. u- \& W: z3 B% u配置struts-config.xml文件
8 Q( ^7 b& }3 `
1.<form-beans>
9 L$ F  h  [& G0 h8 u5 t
: E  e6 B$ v1 m+ o<form-bean name=”myActionForm” type=”全路径.MyActionForm”/>

* L! U1 k; m% h<form-bean />
$ p+ k0 @. D. P$ ~
</form-beans>
- s! _, ^+ B% @3 ]% |* |7 ^# Z# Y+ A
" q2 U( O/ q0 {  s2 q, S2.<action-mappings>

1 @9 \  S! X: B6 M# z7 x2 Y<action path=”/sll”
" e4 Y" ^5 i' {4 F* ?
- ?; ^3 g5 Y$ H/ X6 n) Xname=”myActionForm”

type=”全路径.MyAction”
" Q# `6 q) ?8 T' F+ T
scope=”session”

input=”错误返回的页面”>

- N! u5 W; o  c<forward name=”1″ path=”/1.jsp”>
+ F; \& v- T0 }2 B9 s( c
! }; R) f! I0 v3 R8 G( ?<forward name=”2″ path=”/2.jsp”>

</action>

</action-mappings>
) d- ?7 F' {! ?8 O
# Q5 o* Z1 d) v9 H2 A6 T, h步骤:
: n) L; X2 I; G! L% @
1.创建一个空的web应用
( q5 t, r2 c9 s
2.将struts的包放到lib文件夹下
, t$ m9 O8 |% \! [' d( `
4 j" @3 Y) ~0 a4 K% |1 k9 ]3.将.tld文件文件和struts-config.xml、web.xml放到WEB-INF的跟目录下
# t3 {( s; J. B5 D
; K' i2 K4 |" C* z9 W4.配置struts-config.xml文件和web.xml文件
8 ?0 [8 z& N* m9 q1 J9 L
/ i  s0 `9 C' n; R  y: V5.在页面引入tag文件uri

STRUTS运行机制
; x, u" V" g1 ^8 d
1、界面点击产生请求
& X$ F0 o* o- l- d
/ j6 a% o- j7 Z# ]) `4 E- G7 q2、容器接到请求

# f; x1 L( b& ~! z% a% f" e! `3、匹配web.xml文件中的*.do来调用ActionServlet
. k, @( O! p) a4 Q/ Z% |3 C5 [5 H6 |7 Y
4、ActionServlet的处理
7 Y' A8 ]$ }) [( @* _- B; |
  ^; s+ S2 y" L4.1 读struts-congfig.xml文件形成ActionMapping
' h7 y* i$ g1 ]9 v
4.2 通过path 来匹配Action类，通过Action的name属性来匹配ActionForm类
( n! Z) X* b/ G7 B% q, d$ D
: I7 R* d6 j( h  l4.3 通过反射机制来给Form添数据

4.4 由ActionServlet转调Action的execute方法
& n& ]. s0 o; g, K' {% I4 l0 s
4.5 得到execute方法的返回值，跳转页面
8 P1 X7 K. Z, ~6 X) p& n  |8 Y
# Z0 j5 F+ l3 ]4.5.1 RequestDispatcher
5 T& d/ y' H; P9 K4 z0 L! J9 K; _
. ^: u; \9 U0 j+ C4 w4.5.2 response.sendRedirect(“list.jsp”);
- C& L0 ]/ y% |
7 r; o8 u/ H' r  s. B" A
( j0 Q$ p8 r( ]
4 N7 p+ Y# e) ~9 n进入execute方法
: x& V% X) D, l4 L8 @
1 收集参数

2 y, N2 g1 R9 Z- l& s2 组织参数
5 B3 e( u( }( n8 k, M
3 调用，逻辑层

  T8 _5 V# ]4 q4 返回值
. G( [9 M: X; s8 Q6 {2 e3 S2 a
4.1 选择下一个页面 （ActionForward）

4.2 把值传给下一个页面
- d( \6 Z+ y4 r4 x' u/ v9 F4 D


比较struts和struts2的不同
; ?% Q7 I7 D& I. z
/ F, a8 T9 p$ Z% @Struts

# K8 p) L; N  r$ [, G+ P9 U0 JStruts2
+ `+ m6 a, o5 S& g
组成        五个部分：ActionServlet，ActionMapping，AtcionForward，ActionForm，Action        十个部分：AcionContext，FilterDispatcher，ActionMapper，ActionProxy，Configuration Manager，Action Invocation，Interceptot，Action，Result，Taglib
url        .do        .action
3 {  a4 o! P% c' U; p/ D分发控制        AtcionServlet        FilterDispatcher
收集参数        利用JavaBean技术，将数据封装到ActionForm的子类中；
一个Action对应一个ActionForm的子类
1 a$ X$ e* z" s& m% j7 J
使用拦截器将数据封装到值栈中。
* E) y  o/ z. t使用域模型，一个Action对应多个值栈中的Model
+ S2 C, K% M% x. X4 p& s2 |
& ~: N) U* m( ~. z9 B7 l读取配置文件        ActionMapping        Configuration Manager
. K/ Q$ A+ ^" \. b9 V, W拦截器        无拦截器        执行Action前后有拦截器
返回页面        将字符串封装到AtcionForward，进行跳转页面        Action中直接返回字符串，通过Result跳转页面
- J) h* _9 q* Y7 r: r$ T: j页面跳转方式        两种：dispatch，redirect        三种：dispatch，redirect，chain
. d1 {( o1 p1 }& A& F! b% ^3 @值栈        无值栈，Action通过在request范围内设置属性，向jsp页面传递数据        有值栈，Action和jsp页面通过值栈传递数据，jsp页面通过OGNL取得值栈中的数据
, M6 V& i; |# W9 }2 A配置文件        struts-config.xml        struts.xml
9 Y5 ]( O6 Y8 S" R0 N2 S中文问题        不能解决（需要使用filter）        可以解决中文问题：
1 O  J2 B  v. ^) x7 n1、在jsp页面添加Meta；
. P3 w9 x  x2 q8 }
) v$ }9 C9 L! E, X0 i3 N  B5 `2、修改struts.properties中的设置。

admin

其他开发工具和技术
/ D/ p2 h. s: ^4 ?# o$ OAnt
. x1 a; ]- L7 TAnt是基于java的批处理工具
2 L  R( m) k6 X5 a9 h% U+ _! J
一、配置ant的运行环境
  S& M) T* m+ R) @
9 L* r8 }1 P0 F$ z$ f& R( y! u/ P4 E1.将ant的bin目录添加到path中
, K2 p# q; N9 s' U# z
$ z' i: i9 W9 q2.配置JAVA_HOME

3.配置ANT_HOME

二、配制build.xml文件，该文件放在应用程序的根目录下
5 |$ Z& \1 [* O4 Z8 u
" y5 ]/ A: E: X! Y6 \. [2 z+ l# d编译java文件
8 q/ m: Y" q* f* J. Q) s* l5 P- e$ _
7 y! g6 b6 f# k) G执行java文件

copy
9 q6 Z* d: c: J4 d+ @  }
删除
6 ~: g# b$ ^2 V  \' S
打jar包
1 k* _, D6 ?* O2 Z5 g
根据注解生成配置文件
% ?4 |! Z5 I8 X% x+ |' H. K' j& _
* }5 B: S. p2 @1 w, P% J+ g: mXdoclet
通过注释生成一系列文件的工具（txt、xml、java、html等）

xdoclet本质是摸板技术+字符串的替换
- J7 t$ z9 O, `: l5 J
- y  H( `- i1 ^" q1.在java文件中写符合要求的注释（将hbm.xml文件的内容搬到java文件中去写）

1.1 在类的上面 写与表的对应
1 l3 Q8 z' o) s3 b5 d2 A
1.2 将每一个属性的注释都写到get方法的上面

0 M& r/ ?  S9 B9 d. Z8 o3 {* D2.在ant中引入相应的task来驱动xdoclet
2 M2 ~0 b" W7 T5 x; q4 z
. d7 E# H: r! h- y3 |/ H! ]

log4j日志管理
1、是什么？

在开发期间用来测试、对整个日志信息进行管理的工具
# F' a' r' t+ m- a) K
+ B/ H7 S" |, Z0 Z: P2、功能
# m4 _% _5 U' @1 A: H- l
% B! w9 C0 [; q9 A0 p' m1.控制输出的目的地
9 y8 {7 L/ s( x5 r
6 a: f$ P) K# Y. W1 t! P2. 控制输出的格式
$ {) i- c( e0 ]6 k. N
3. 控制输出的级别

6 }; ~# h& F/ F. W4 j3、日志的级别
' m: \/ N* e- p: E
! K: }# v* L8 J# s* W" C/ r1. debug 调试

2. info 给用户的提示信息
3 u  r+ S5 N5 `$ L- ]( e
5 ?6 v4 @3 r& ]' H7 P3. warn 给用户的警告信息

6 N9 w$ n) Q& D4.error 给程序员用来调试

9 K$ l% t7 q. p3 bDebug—-〉info—-〉warn——–〉error
- r* }" [( l+ ~5 ?
: H  o0 }+ \/ e# S7 M4、配置
. G( H7 `' S4 Z5 ^# o2 N8 Z4 m
% X1 I2 b0 ?' @1.配置级别
  j7 J0 i* {6 t; b* h, Y0 W
4 s+ G* g0 w% A: @  H0 U2.输入源 （控制台和文件）

3.可以进行分包控制
( K( d" K9 l7 `7 H( S' V' d
9 g8 F* G  s! n/ r$ zLog4f.logger.包结构 = 级别

5、使用

0 r2 l' h5 }/ t, F6 JLogger log=Logger.getLogger(Test.class);
; p9 M- ^$ l# T2 Q0 S3 M1 ?
    public
8 n" x# ]; D  k, L7 [void t3(){
) y( L( p  {: E7 _* f
$ e9 D% P0 h4 Q6 ?) \% u6 _0 l        log.debug(“this is debug”);
2 w; l! t1 R2 d7 y' q+ u: R
        log.info(“this is info”);
  C, }7 \" x: A$ o, }% Y- i
        log.warn(“this is warn “);

0 u1 a; f, w7 F2 {4 X1 y6 S        log.error(“this is error”);
. R5 Q$ @" R+ n/ a( b2 F
3 |% ^! W5 \! F5 P2 \8 A    }

Junit
1.是什么？
% q; B# m/ z1 i4 [% U$ f6 @9 b
单元测试的框架

2.怎么做？
: v- X+ n4 q! h
( q' o, k8 @# V1 q/ z  [写一个类继承TestCase

! B0 L) r8 X% b% @& O, O! P测试的方法一般都以test开头并且没有参数
2 L8 @* W7 _4 d$ k% z& v
在测试方法前执行的方法public void setUp( )
8 D% g% `; _: e' o! u/ @9 @
/ F& {$ n. z4 j( @" Y, s在测试方法后执行的方法public void tearDown( )
4 u0 c% v+ v" d3 G# Q
error和故障的区别
9 }' I4 z$ ^& Y, w6 y. \/ P
# t9 w! D6 b  @# cerror ：代码有问题

0 y! y1 R, a3 \6 @1 [0 f故障 ：逻辑有问题与祈望的值不相符合
4 g& q8 O& Q& {9 m5 P
生命周期

测试—〉SetUp（）—〉testXX（）—〉tearDown（）—〉结束；
5 ~, G# ?) r1 s- |5 ]1 l
# q8 V- S! F) i2 \/ I2 I; CTestCase套件

public class MyTest{

        Public static Test suite(){
9 J3 J: o! Z  N! I7 j; e; C! S
  a- b4 d4 j! {, L4 a  Z( c, ?1 eTestSuite suite = new TestSuite();

& W) l  z0 D( b( {suite.addTestCase(Test1.class);

# u; I/ i4 H- i8 Zsuite.addTestCase(Test2.class);
: t0 y% K2 f# K2 f! m: l
}
& x1 c* \' W5 a
7 i/ l0 V  }* U4 D+ x}
- Q) c8 [% c4 |
& e: B% @; E+ J6 m! L( I
0 O( ~$ q% J2 B9 w- I# k9 ]
- m( W7 k, f/ _9 n4 \9 B( n5 }6 k0 A; ]Ajax
是什么？
' |% M4 P' n( c  }AJAX即“Asynchronous JavaScript and XML”（异步JavaScript和XML)。是一种创建交互式网页应用的网页开发技术。

8 ~6 p" C; r$ ?9 a# q6 Z无刷新页面。

有什么？
AJAX是多种技术的综合，包括JavaScript、XHTML和CSS、DOM、XML 和 XSLT、XMLHttpRequest。

能干什么？
  k+ ~0 g- A( D* G5 f( G  h使用XHTML+CSS标准化呈现；
) G1 }" Q! X6 f1 U! _) z2 v; Q/ B使用DOM进行动态显示及交互；
1 z  z1 f' \; j使用 XML 和 XSLT 进行数据交换及相关操作；
使用 XMLHttpRequest 进行异步数据查询、检索；
使用JavaScript绑定和处理有所得数据；
$ \7 o, C/ d: k
传统的web应用允许用户填写表单(form)，当提交表单时就向web服务器发送一个请求。服务器接收并处理传来的表单，然後返回一个新的网页。这个做法浪费了许多带宽，因为在前後两个页面中的大部分HTML代码往往是相同的。由于每次应用的交互都需要向服务器发送请求，应用的响应时间就依赖于服务器的响应时间。这导致了用户界面的响应比本地应用慢得多。

7 ~( |9 P& Z& ?( w与此不同，AJAX应用可以仅向服务器发送并取回必需的数据，它使用SOAP或其它一些基于XML的web service接口，并在客户端采用JavaScript处理来自服务器的响应。因为在服务器和浏览器之间交换的数据大量减少，结果我们就能看到响应更快的应用。同时很多的处理工作可以在发出请求的客户端机器上完成，所以Web服务器的处理时间也减少了。
: G( _2 w$ }6 @* }( s
5 a8 ]4 e( A* U+ C& f使用Ajax的最大优点，就是能在不更新整个页面的前提下维护数据。这使得Web应用程序更为迅捷地回应用户动作，并避免了在网络上发送那些没有改变过的信息。

' S2 l( c9 E0 O. B% `对应用Ajax最主要的批评就是：
, V3 z! g& x! `3 E# m) y5 Y6 f1 它破坏了浏览器后退按钮的正常行为，就是用户点击后退按钮后不能看到之前的数据；
% P. p  B7 c, ]) C) K3 i2 一些手持设备（如手机、PDA等）现在还不能很好的支持Ajax；
) L4 W7 Z6 u9 e1 L; j3 用JavaScript作的Ajax引擎，JavaScript的兼容性和DeBug都是让人头痛的事；
: x! I/ D/ c3 x9 I1 r  p# D+ D6 b& i1 Z4 Ajax的无刷新重载，由于页面的变化没有刷新重载那么明显，所以容易给用户带来困扰――用户不太清楚现在的数据是新的还是已经更新过的；现有的解决有：在相关位置提示、数据更新的区域设计得比较明显、数据更新后给用户提示等;
2 O: e1 o9 i4 k) [7 i' r
怎么做？
1 f9 \- F# ]3 E1 ~% V" o<script language=”javascript”>
0 x( A1 Y4 O+ V+ r  U
var req;

function add(){
7 \* v3 |; ~$ ]0 V1 h% V
//1:创建用于传输的对象

5 P9 d8 \3 C) l. S9 }- Q: Oreq=new ActiveXObject(“Microsoft.XMLHTTP”);

7 d5 Z4 D) o+ A: X. G( k( b8 m// 声明返回后，处理数据的方法

req.onreadystatechange=manage;
3 ?( x  _, ~& p% `! Y
5 H) A3 y; ]/ m//2:准备传输的内容

var str=”test1111″;

5 E$ ^& C% v4 i//3:发出请求
1 R' }8 H$ _) K7 C4 ]5 Y0 t& p
$ M. c5 i: m; \/ s4 r& [req.open(“GET” ,”/others/ajax/test/t2.jsp?str=”+str);

0 V" @( z' K2 P0 a: d& [+ o4 nreq.send(null);
) L. d  `2 z* M4 R
}
, a# o6 f7 K& m7 d5 Z; Q/ a6 U
$ L: W0 k' A( s0 g  {//4:接受返回并处理

function manage(){
7 x6 O3 Q' b$ s
( k8 a! i* K! l1 d- vif(req.readyState==4){
6 z) T4 c* d! J0 S! ^5 a; r
) N5 b& H( x1 X0 ealert(“r==”+req.responseText);

}

0 q7 h) C& n% M; x6 L/ {! V}

</script>
  E! n) g6 J7 w1 U2 x
% U+ n3 A# J' a! @2 dreadyState的取值如下：

# v8 d& Y2 E0 M+ ?" j　　0 (未初始化)
9 H+ D$ F: [  Y* b
) P5 w$ o4 w- i, \　　1 (正在装载)
8 V  ?5 q) w6 t; I% x; i8 @/ U
　　2 (装载完毕)

　　3 (交互中)
: U. K! O' e. ~: @: M" H4 ^# s
　　4 (完成)
) x0 G/ F7 J& S* u2 y" }3 c$ L& \
+ T+ Y# e, ?' I7 y3 P
& `1 s$ Y6 q- \  b$ M
& n/ t9 C! N4 t* X, k原理
Ajax的原理简单来说通过XmlHttpRequest对象来向服务器发异步请求，从服务器获得数据，可以是xml格式，也可以是一个字符串，然后用javascript来操作DOM而更新页面。
5 l3 Q' P+ s" L/ W" V
Dwr
是什么？
- q. j1 J. g3 S- s/ o$ A( I1 ^DWR（Direct Web Remoting）是一个开源的类库，可以帮助开发人员开发包含AJAX技术的页面。它可以允许在页面中使用运行在WEB服务器上的JAVA函数,被调用的JAVA函数就像是在页面中JavaScript方法一样。
- [4 F3 v9 c) {  W
6 V! m) A% _. C  t% K  _/ E有什么？
它包含两个主要的部分：允许JavaScript从WEB服务器上一个遵循了AJAX原则的Servlet中获取数据；另外一方面提供了一个JavaScript库可以帮助web开发人员轻松地利用获取的数据来动态改变网页的内容。

( U1 g' q! ?4 `/ X1 c
2 J+ w4 {) @' }: v+ I5 @7 Q$ V; C
能干什么？
. |# W0 Q, o# k5 t8 c# ~3 n动态地把java类生成为JavaScript，感觉调用就像发生在浏览器端，实际上代码调用发生在服务器端，Dwr负责数据的传递和转换。这种从Java到JavaScript的远程调用功能的方式使DWR用起来有种非常像RMI或者SOAP的常规RPC机制。
2 L% v. l. p) D
4 m4 m) C) z6 H; D, C- \

怎么做？
① 编写配置文件

* w  l. g& f5 ]5 g' k5 Wweb.xml

$ P. W$ V! F$ a<servlet>
: |% q, B0 Q/ H1 L
% d0 h' R7 Y0 s4 G: O<servlet-name>dwr-invoker</servlet-name>
1 b5 N! h7 U# p5 E7 m7 W. y* M
<servlet-class>

org.directwebremoting.servlet.DwrServlet

</servlet-class>

<init-param>

  i2 V1 F$ F6 k9 n<param-name>debug</param-name>
# U. j4 [$ C/ f4 K+ p
<param-value>true</param-value>
5 `' u) y, {% x% b
; q7 q. n# ^  f7 j2 l& e</init-param>

" S% y1 H  \7 K0 J</servlet>
4 K) |& b/ _1 W! h1 i) Z7 }
<servlet-mapping>
3 z0 \" T, E; |- h( S$ G: l% `
/ x" [) Z  e7 J. y! A% X$ J1 P<servlet-name>dwr-invoker</servlet-name>

! `& i8 z/ N$ T& i( O% U1 N" p<url-pattern>/dwr/*</url-pattern>

</servlet-mapping>
7 e2 U- d( j" [9 p" @6 n/ z9 g! l* U( f
$ T: q, x5 d1 P, Edwr.xml
% N  d) M. [- R) ~6 E
<allow>
& }3 p6 l4 R+ p0 ^5 H) Y) Q" l
! s' |$ T' I9 P. P9 R<create creator=”new” javascript=”kc2″>
- ?  |" K; L& `, S2 ?# y$ e
% {4 D. S* \' ^: ~9 u<param name=”class” value=”dwr.Service” />
; p2 B. H6 x$ f- \; j& \5 w9 m
0 _  z4 T: T  u9 X$ r- a</create>
+ a: W0 `0 o) K# u
</allow>
% |. h8 G2 }8 K! I  Y3 {6 d2 U) b
6 W" D! x. a& B- j6 L8 q% u- H$ K②编写service

public class Service {
1 t9 o# C5 y4 v0 n
! U& @8 K& u. S7 vpublic String sayHello(String yourName) {

+ V4 Q$ h# q* J5 G//可以是访问数据库的复杂代码

return “Hello World ” + yourName;
0 V3 B  }9 v0 o
}
" t+ `( |; e4 B) V$ x8 e
}

③测试DWR
: `& c' j# z3 ^* W7 n& O
# l2 J7 F1 N. L. X' o将代码放入应用服务器（比如Tomcat），启动。

/ `" k" J8 G/ ^然后在地址栏输入http://localhost:8080/你的工程/dwr
3 u6 n* [- v+ n1 N/ P. C
2 G* N, {% f0 U) }, n- w④编写jsp页面
' Z" {* T; V% N2 }4 m
1） 要引用3个dwr的js，其中engine.js必须要，如果需要用到dwr提供的一些方便的工具要引用util.js

1 S# E2 M" p: D: {& ?3 Z/ d2） 然后还要引用dwr自动生成的js，dwr/interface/service.js，注意js名字要和dwr.xml配置的一样

3） js里的service.sayHello和java类的那个有一点区别，多了一个参数，用来得到返回的数据