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

admin

JEE
7 I6 R3 b( s* C/ H, |2 S9 d简述JEE
JEE　： JAVA　 PLATFORM　 ENTERPRISE　 EDITION
$ S& r6 n! v# ]9 K0 |! p" N3 D! r
: Z- l! J' g4 u9 Q3 ?  v4 R1 XJEE是一个规范集；

% b6 a7 `1 w3 C2 }" jJEE是一个框架集；

JEE是一个技术集或API集；
* ~  |; [( P/ {6 U! t; v; e  J
适用于创建服务器端的大型的软件服务系统
5 {7 J6 n4 V( B; S
+ u8 @7 c  U( T
* I  o0 }) F1 q# L: \* _
7 y$ y/ H2 K, U7 \$ i7 R( lC/S B/S 模式
C/S client/server即客户机/服务器模式，客户端也参与程序的运行与计算（富客户端、胖客户端）
3 [6 ~$ w. M7 a6 G
B/S border/server即浏览器/服务器模式，又称为瘦客户端，客户端不参与程序的运行与计算

3 d% z6 P" ^3 X; U; C, U0 k8 h& W; p
5 b# x. f+ h* s9 w/ H
1 }. [/ t, |) D7 D/ ?企业级应用（大规模的应用）的特点
# \5 S9 b7 A2 T$ `3 G1.生命周期长、稳定、可靠

2.组件往往分布在异构的环境中，能够跨平台

2 G8 |0 ~6 _8 F+ Y5 e. t3.维护性、扩展性、重用性
2 K& ?- Q' W8 s0 y$ P+ b" ~
4.有事务、安全、线程



什么是业务逻辑？
依照业务逻辑划分模块，

9 R3 g% K3 e9 `! }/ {. l$ A所谓判定业务　就是具有以下特征：

4 j$ N! P$ k) `* ~* H# s1.业务流程
5 p- u& c1 ?/ }
2.业务判断
$ y5 b7 j* I8 g8 \0 d! u( C' `# o2 g
3.功能组合

6 Y) f  h! Y8 c5 q" j7 z8 r

+ l9 ~, S* x% j+ p/ J* K平台（角色）的划分
0 E9 G  ^; d, Z9 g1.平台供应商。提供满足API集实现的厂商（BEA weblogic IBM webshphere）

2.组件供应商

9 v$ w) K8 Y  s/ {3.组件装配人员
& l  d# f( w% a4 [6 Y: n  u
; j# M0 V" x% X. Y! |6 m4.部署人员
" q9 {2 \* R+ B
5.系统管理人员

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

) j7 F0 h: N# D9 p  U8 D% e
/ W' e' G) a0 T/ r5 r  C
java技术分布（设计架构 模块内部设计）
1.表现层 Servlet、 Jsp、 JavaBean、 Taglib

! K9 ]  k* H) @5 n% M* j1 k2.逻辑层 EJB(SessionBean)
( r5 R* n5 g* `
& W6 n5 Z) v6 u( @) z$ `& Z3.数据层 （　JDBC 　EJB（EntityBean））

1 |3 x( r! O. y) m) ^- S# Y4.服务 JTA（JAVA事务架构） JTS（JAVA事务服务） JAAS（JAVA授权与验证服务）
0 Q( [; p; L2 b: Q& X& \/ L5 g
3 m$ S- \" I, F( k3 Q2 r5.分布式通讯 RMI（IIOP）+JNDI 、JAXP（JAVA 的 XML 架构）
: M7 Z2 a/ W! _# t" |9 {6 P
$ p' S6 e$ n; C& z. `JAVAMAIL（邮件服务）、JMS（消息服务）、IDLC、JCA（JAVA连接器框架 （成））
9 x6 ?1 @! l* U! Y

* u7 p* ~2 [9 @& b" S0 y1 w9 Q
4 S. o  L( P5 G8 _. n" a7 ^JEE的体系结构： 是一种组件的体系结构
1.组件 ： 能够完成一定功能的封状体（独立的功能的集合）

不能单独运行，必须运行在容器上

分为两类：web组件、ejb组件
; e5 c$ ~- ?3 }) ]9 H# v
, d" Z$ S  k$ L  Y1 s2.容器 ： 提供组件的运行环境，并对组件进行管理（一段程序）

+ t0 w  g- P; U) @$ D  X; t* w管理组件的生命周期
: D5 J0 s! D# @9 K6 }3 Z
+ _  ~/ h  I6 z) \% M) s9 P不能单独运行，必须运行在服务器上
" f" B% e% n* F: R$ h0 j
  ^0 N3 P0 a0 Y$ K! a" L程序（组件）通过上下文来调用容器（context）

组件通过web.xml向容器描述自己，使容器能够认识组件

9 }; C: i( b! g7 ?1 m! C容器通过回调方法来调用组件

0 _1 A0 [3 t# W4 |% g分为两类：web容器、ejb容器

6 P; H" O) n' p% u3.服务器 ： 提供容器的运行环境，提供大量的JEE基础服务
8 o, z6 E" E' k% z" ?
web服务器（只提供web服务）
$ e1 Z' n, @; V) |, q" u7 g& v; `
jee服务器（提供web、jee服务）



1 t$ s3 e  {. Z; ~: w$ b什么是回调方法
: Z3 D6 O9 \4 w由容器自动调用的方法，就叫回调方法。
, O4 k" Z  v% y- y8 X4 m

) w  L, U: C) K
9 b0 \0 J6 `+ @) W8 eＲＭＩ远程方法的调用机制
9 U3 K/ E6 y. U+ w( J+ G例如：Ａ主机有Ｂ（）方法，Ｃ主机有Ｄ（）方法，Ａ　想调用Ｃ主机的Ｄ方法

& p8 d; }" F. \
; j3 S  L3 v1 m9 n
" o, h: R# d( `9 d' x1 [( t1 h; p
+ G5 X. c) B5 l+ V/ q% V$ A0 r
) F. h  Q6 x' i- ^+ T; u! j' y( P, ]学习方法
6 F2 Q' S: c: |' v% h1.规范（熟记） 2.熟悉API 3.多练 4.多想

admin

Servlet

•     描述war包、jar包、ear包的结构
  
  
  

war-                            web文档压缩包

—WEB-INF

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

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

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

jar-                             java文件压缩包

—META-INF

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

" T* ]( O1 x! Y2 O) V

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

–META-INF

—Application.xml 配置文件

–*.war

–*.jar

% r& B: Z  i$ J) q: ~' h3 a

• 什么是servlet？servlet主要做什么？
  
  2 B: J9 I5 k% t5 J+ v: Q
  0 C4 `2 P/ e* A1 B

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

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

• servlet 与cgi相比的优点？servlet的缺点
  3 h& B. D) J' X) h, a' T1 C& V
  
  

优点：

性能（线程比进程更快）

可伸缩

Java强健且面向对象

Java平台独立

缺点：

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

7 A7 w8 P! W$ U# f8 Q

• 常用的servlet包的名称是？
  1 L' D1 d9 e  F& f4 Z
  # v# ?3 d) w% f' e3 `' Q  \3 Q7 U
  ; ?. o5 l9 z+ \/ W5 U+ i: b

javax.servlet

javax.servlet.http

• 描述servlet接口的层次结构？
  ' i! F. U* Q! w4 z4 N8 `1 Q
  ' w0 P8 Z0 I$ C; k& Y
  

Servlet

–GenericServlet

–HttpServlet

–自己的servlet

ServletRequest

–HttpServletRequest

ServletResponse

–HttpServletResponse

• 对比get方法和post方法？
  ; U' N  @, j( S9 x) e3 M6 @: p
  
  & n# O: C! _8 ]' {- j/ f  B$ M

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

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

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

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

6 x) z& u) E4 Q  q' Q5 z+ I- P

• 归类描述HttpServletRequest接口都完成那些功能
  5 d; f4 H8 J/ S9 N! H  {9 {
  
  
  • 读取HTTP头标
    " x0 @# N$ N& n( u# Q0 P9 a% j0 E' Q% a
  • 读取cookie
    & I8 Z8 X- w" L$ A3 p
  • 读取路径信息
    8 n5 b. M$ l1 \8 N5 P* j+ g- O+ @
  • 标识HTTP会话。
    
    

) Y1 c1 `. n; \! o4 \7 A

• 归类描述HttpServletResponse接口都完成那些功能
  " y3 E8 c  W7 c& r) [
  4 @, [% `: I; E$ |  W
  ! b! k0 h* b0 f9 `
  • 设置HTTP头标
    
  • 设置cookie
    / Y8 M7 H- \8 J" J
  • 设定响应的content类型
    
  • 输出返回数据
    
    

• 描述service方法所完成的基本功能？默认是在那里实现的？
  
  ; B. P7 z* q* E- k
  

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

实现：默认在HttpServlet类中实现

• 如何开发自己的Servlet？描述应该做的步骤和每步需要完成的工作
  2 Z, b% T2 h0 \% P' a
  
  . y6 ^& Z% \# ^

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

. `+ r$ X5 T. |4 w7 x2 q

• 为何servlet需要部署描述？
  6 J7 m8 n) Y) ^" U. m1 ~" ~
  - z- E' ]% Z  S! g& ?
  ! f! D# b% m- ?* K5 P

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

& \0 f2 g/ u2 k% o5 r' s+ ?

• Servlet基本的描述应该是？请写出来
  
  
  : l% s! M: _+ l# j

3 G9 a. ~9 T. ^- \/ d. `. ]$ k

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

6 p9 |! x+ v3 U7 m" }5 h2 ]

• 如何在html中使用servlet
  ) c) G/ {3 h+ s4 D
  $ n: D9 |: @9 t! k/ a
  

FORM标记

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

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

语法：

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

{HTML form tags and other HTML content}

</FORM>

: h/ O$ b9 |, V- l4 J( @

• 如何接受request中的参数
  
  ; B& i& W$ J$ H. T* _String userName = request.getParameter(“userName”)方法
  
  5 H3 y" i! i8 ]- d) p3 u

• 如何接受request中header的值
  6 W9 q6 Z% @9 g/ w/ W
  0 m7 m/ |5 E/ D
  

request.getHeader(name);

request.getIntHeader(name);

request.getDateHeader(name);

request.getHeaderNames();

• 如何输出html
  . W; m4 t  v( h  z4 z& P
  
  

PrintWriter pw = response.getWriter();

pw.write(“<html>”);

pw.write(“Hello”);

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

• 如何设置输出的contentType
  
  " `- s* _: F! p3 C* g" |7 R+ l1 h
  

response.setContentType(“text/html”)

• 描述servlet的生命周期？
  ' @* w" h- K0 y' B5 j1 n& Y
  ( W" j7 D$ t" o7 B' s9 \
  

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

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

" [: h# I( v* Z: ]- w# q+ s

• 描述init,service,destroy方法的功能和特点
  
  + \$ E  ~. n$ B, a
  ) R$ \+ v0 W# s# b  \+ V, v. ?: k9 @

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

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

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

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

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

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

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

• 什么是回调方法？有什么特点？
  
    i9 W7 |8 `. B- R
  

由容器来调用程序的方法

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

• 如何设置初始化servlet的参数？
  
  在<servlet>中添加如下配置
  : b/ R: R0 T) y& y, s  ^2 J
  

<init-param>

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

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

</init-param>

; `5 B- |) v& a7 X

• 如何获取servlet初始化的参数
  
  9 O, {  O- ~. c/ s2 d1 x/ T3 c
  

public void init() {

greetingText = getInitParameter(“greetingText”);

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

}

• ServletConfig接口默认实在那里实现的
  4 F: U# r1 v( M$ B2 N6 V( s: m: E' j
  
  ' A- M$ _1 ?* k8 u

GenericServlet类实现ServletConfig接口

• 什么是ServletContext？有什么作用？
  & e9 G7 \7 }( a9 V8 V1 J
  2 A% V% v# A$ _; s7 C! `
  ; [$ d6 N$ T3 Z/ l

Servlet上下文

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

• 如何访问ServletContext接口？是在那里实现的？
  : T5 E+ U/ w" J  z$ b7 x
  
  

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

GenericServlet类实现了ServletContext接口。

• ServletContext接口的功能包括？分别用代码示例
  
  ( Z$ q) w* }8 y# P+ ~+ x
  

只读初始化参数：     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的参数？
  
  * F5 W* M) u( T# x1 `2 F1 _
  . o4 h7 q* n% o( s$ A( P& Y

<context-param>

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

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

</context-param>

• 如何获取ServletContext设置的参数值？
  2 _" Z( B: a. k0 U
  
  

ServletContext context = this.getServletContext();

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

• 描述Web应用的生命周期？
  
    K$ r. b5 i6 o! S, L: i: @0 D
  

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

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

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

3 i& _! |) a6 s

• 如何用代码实现监控Web应用的生命周期？
  4 _) K" t1 r; s3 t
  
  
  

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
  7 M9 P. d- ?6 n
  8 b- D" l2 |' r* U
  400 Bad Request//错误请求
  401 Unauthorized//未被认可
  404 Not Found//没有创建
  500 Internal Server Error//服务器内部错误
  
  

+ M% A1 E' |! V

• 描述Web应用中用声明方式来进行错误处理的两种方法
  
  6 U! T7 }* ^) X0 s
  4 \4 j$ w( B9 F" \

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

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

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

% T- `+ a2 `6 R+ u$ [

• 描述记录异常日志的方法，都位于那些接口？
  ) F; z& t' t) E. Y
  6 s6 ^+ h- `* A( e6 z
  

GenericServlet：

log(message:String)

log(message:String, Throwable:excp)

ServletContext：

log(message:String)

        log(message:String, excp:Throwable)

/ ?+ q) R! C# \! `

• 什么是会话？
  - x2 k: u& i) Y, G4 _) q
  9 Y& m  R, h: S, Z' E
  3 J9 a: B, D9 _- c2 ^+ C1 X

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

• 如何获得会话？
  
  7 F5 s- i) D; w7 s. A0 ?; j
  HttpSession session = request.getSesseion( );
  
  : Z3 c4 J. O2 x) X

• 会话Api的基本功能？
  
  
  3 N4 k) T/ h* ]3 F3 @5 ~7 j

getID() :String
+ V: V4 @' C/ t& Q/ }

    isNew() :boolean

    getAttribute(name):Object
* D6 `: ^) Y7 N

    setAttribute(name,value)

    removeAttribute(name)

• 如何销毁会话？
  
  " n3 b& X; Z: D! g9 I6 a' O- C
  / D2 k) U# b& s: H0 F- x3 ?

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

<session-config>

         <session-timeout>10</session-timeout>

     </session-config>
6 r& r0 G0 E- M# e

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

invalidate()

     getCreationTime() :long
/ S. u! e- m: k- q8 D" e0 u

    getLastAccessedTime() :long

    getMaxInactiveInterval() :int

     setMaxInactiveInterval(int)

# A; \9 s4 p/ F0 k9 {8 c! z

• 描述会话保持状态的基本原理
  
  
    D  [) U# s5 L

    client server

6 l) u' s1 m# I% ^- }7 S

request

response (sessionid)
9 F3 @/ S1 b6 H0 Y" K7 l7 k

request (cookies)

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

; \" X3 c- [' F

• 请描述session和cookie的异同之处
  0 B& G' \; t5 F# X: N/ N! Q7 H9 |
  
  0 @7 T) v% r; r! u; P0 A) b( v

/ u5 z7 n8 A0 d$ X, e0 p4 e- p

• 如何读写cookie，代码示例
  
  5 v% d" A4 x6 N9 w' `
  

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

response.addCookie(c);

读：Cookie[] cookies = request.getCookies();
# E$ |+ a: w+ a) |+ b  F  V

        for ( int i=0; i < cookies.length; i++ ) {
) h) ~- b) Z  ]. m1 t1 f( P

            String key =cookies.getName();

String value = cookies.getValue();
/ r, O) [6 \" t: j3 f+ q

System.out.println(“cook”+i+“:key=”+key+“,value=”+value);
- K6 i  N6 |$ H' V3 W1 K$ F

     }

• 什么是URL重写，如何实现，代码示例
  * M; m  C1 G8 n" X
  
  3 i2 `( i" L- v( a5 u6 N( T

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

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

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

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

, Y. X* N. J8 x) s
5 S0 A( K# V7 Q" f8 c2 ^

• 描述web应用的4种认证技术
  8 K  G9 J- h- P4 h, V& M! b% c" p+ @* X
  
  

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

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

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

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

• 什么是授权，什么是验证？
  # W4 X+ m) B' v, |8 }: B1 `1 ~1 O
  
  2 d# w4 B4 |) U, T; M

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

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

+ z, ~5 j# F  q6 W4 x. A2 u

• 什么是HTTPS
  
  
  * g; `* T( r) v

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

# N' z4 W- |8 G) L' q+ m0 t

• 什么是审计？
  
  
  

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

9 F  ~2 O: K# R

• 如何实现声明性授权
  
  6 S2 a) I# ]7 O0 [9 [/ ]+ X: E
  9 c. u4 r5 p( {

1、标识web资源集

2、标识角色

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

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

在 web.xml里配

& a3 W+ Q) s1 T$ a* r! N

• 描述servlet并发问题？
  
  1 U& h' B/ F* |, Q% l2 K. r! T
  

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

• 描述Web应用中的六种属性范围
  
  
  ! G9 M& ?' l; x' J4 {  k

局部变量（页面范围）

实例变量

类变量

请求属性（请求范围）

会话属性（会话范围）

上下文属性（应用范围）

• 指出上述六种哪些是线程安全的
  3 l# N- I  L  V& G4 F4 D  g
  % C( i, _7 X) J
  * z) O, W+ T- k; I. e, O2 a

局部变量和请求属性

- b) [4 \$ ?: A, x% k

• 什么是STM？如何实现？
  0 H$ D/ L: v% @0 \( z8 F4 U
  
  * D0 @, J/ K9 s- o8 V6 Q

SingleThreadModel接口

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

• 如何实现并发管理？
  $ V/ }8 i8 v8 m. L3 k( a
  3 ]( p% o9 X4 h) g  x* |
  

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

使用synchronized语法控制并发

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

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

admin

Jsp
4 k  _! h5 m3 S什么是Jsp?
7 p# g3 c& J" VJava Server Page    结合java和html在服务端动态生成web页面的技术
  z7 ]8 |  \5 d


3 c5 |: ^1 q3 q$ i# E描述Jsp页面的运行过程？
: x* i0 H9 a" N$ n5 M# e第一步：
1 `& E; A9 h$ U! K: L" l
请求进入Web容器，将JSP页面翻译成Servlet代码
* {! e/ z8 C3 z& S6 z0 Y* n
第二步：
7 k, c, w% u8 B% R! }
编译Servlet代码，并将编译过的类文件装入Web容器（JVM）环境

& J2 U9 ]- M; {* g0 t第三步：

Web容器为JSP页面创建一个Servlet类实例，并执行jspInit方法

第四步：
% ~, o5 Z. J3 C- H- }' m  a
Web容器为该JSP页面调用Servlet实例的_jspService方法；将结果发送给用户
+ G" o0 L! ~2 d/ ^( r3 S! u7 f

5 }* X! u/ m8 B- A% e' P
9 b0 Z+ ?& Q4 v5 {3 @! r描述Jsp页面的五类脚本元素的功能、写法、并示例
注释 <%– –%>
& r. L4 S7 j1 j% f9 U2 c8 Y  G1 z/ R
<HTML>
/ B3 I: n) _5 j3 f4 W* f; e# \' z6 [7 b
<%– scripting element –%>
( X+ K3 _- |3 x0 V7 F
</HTML>

指令标记 <%@ %> 指令标记影响JSP页面的翻译阶段
3 W4 \. x# W3 q! ~; M
<%@ page session=”false” %>
4 N2 _" K  n" j3 D, T
声明标记 <%! %> 声明标记允许JSP页面开发人员包含类级声明

<%! public static final String DEFAULT_NAME = “World”; %>

* t" s; {! T/ E* @4 @# v- N    脚本标记 <% %> 脚本标记允许JSP页面开发人员在_jspService方法中包含任意的Java代码
# b% ~2 Q+ X" [- Y
5 X' z& n6 c9 R- L    <% int i = 0; %>

表达式标记 <%= %> 表达式标记封装Java运行时的表达式，其值被送至HTTP响应流 <B>Ten is <%= (2 * 5) %></B>
9 j( l6 u! M$ D2 [
% G* b7 `9 C# N
/ U/ T7 I% U% A* y
: U' [0 o4 R( s5 w2 v8 D: {* o3 j描述Jsp页面中的注释种类和写法
HTML注释
* c# [" D8 l# ^/ h* \
<!– HTML注释显示在响应中 –>

# o( _5 _8 r% g2 {4 WJSP页面注释
3 {1 u( R! B. F9 S- d$ _
/ N4 H3 `5 B7 E' j& W! [* |3 j0 B, |<%– JSP注释只在JSP代码中可见，不显示在servlet代码或响应中。–%>
1 P! u& h& T2 L' M- v+ o1 e
2 k. D  I$ G% o# L$ yJava注释
; H  w" p" Z2 @* z
<%

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

*/
1 ?9 ]% X7 Z) e) a: O
%>



描述Jsp页面的指令标记的功能、写法、并示例
$ O6 g3 `3 {0 a& J3 v% l4 t指令标记影响JSP页面的翻译阶段
, O9 [& h. V9 w1 C) N  O* ]9 ^
$ g: \' X# c8 ?  n) Y& {& U% r2 N<%@ page session=”false” %>

4 M& Z  t1 ?& ]2 h<%@ include file=”incl/copyright.html” %>
9 u& f3 f) d; m
<%@ taglib %>
/ w+ E/ @6 ?0 u6 \
4 v6 E# w, `: P
% h0 _% X& Y4 p% g
描述Jsp页面的声明标记的功能、写法、并示例
声明标记允许JSP页面开发人员包含类级声明

& E6 ?- c9 W: d9 y1 j9 N写法：
- |! L/ e, H% m
<%! JavaClassDeclaration %>

" \& u% Y( t$ v9 s" p/ E( ~例：
2 v5 j" ^. t( E6 d" D
7 K. U5 n; K) t( l. C<%! public static final String DEFAULT_NAME = “World”; %>
# q0 u9 D* [2 ^- i/ A* N" Q( j! s
<%! public String getName(HttpServletRequest request) {
# x( N! N! E* A. ?
1 ^, |8 s% A& B6 l4 N( V! Treturn request.getParameter(“name”);
9 Q' G  y! d# Y4 N3 f# ~
5 h) I4 I% m0 R}

+ t9 B' f6 h6 K/ d+ I- m%>

<%! int counter = 0; %>
5 B- {1 d* B3 i1 m  L0 ^& O6 @

: \) F6 e. t9 E% z+ `. d% L
/ P3 z; u6 o$ u% _2 c% W" S2 g描述Jsp页面翻译成Servlet的规则
  x- A* X; ~3 l$ E, C' vjsp中的注释标记被翻译成Servlet类中的注释
2 z) F2 E& k- O0 U+ y
! P, k( H5 K+ @: O2 w* H+ kjsp中的指令标记被翻译成Servlet类中的import语句等
; _: C4 e7 t. [  ?
: f1 Z" y% G% Y& ojsp中的声明标记被翻译成Servlet类中的属性

jsp中的脚本标记被转移到Servlet类中service方法中的代码
4 n, k- v* ?# m' N
, \4 _1 f; A  |1 Yjsp中的表达式标记被翻译成Serlvet类中的write()或者print()方法括号中的代码


- e" z  e4 B% I0 e# K) x
描述Jsp页面的九个预定义变量的功能、用法、并示例
+ S0 O) w9 p! h. H; V, m4 Orequest 与请求相关的HttpServletRequest对象
  k' k' a# j! f, J$ \- v& a
response 与送回浏览器的响应相关的HttpServletResponse对象

out 与响应的输出流相关的JspWriter对象
- p/ f2 s5 v0 r; U$ k
  x( k! z( g: y1 D0 M. w8 M    session 与给定用户请求会话相关的HttpSession对象，该变量只在JSP页面参

与一个HTTP会话时有意义
' ?' _; b" U. n' ~5 z
    application 用于Web应用的ServletContext对象

config 与该JSP页面的servlet相关的ServletConfig对象

pageContext 该对象封装了一个JSP页面请求的环境
% V0 X2 K8 D$ `. `, J- H
page 该变量与Java编程语言中的this变量等价
2 p5 a1 Q3 R  O) K- n5 [) a* t
    exception 由其它JSP页面抛出的Throwable对象，该变量只在”JSP错误页面”中可用
8 R8 _' H$ x4 s3 f' h+ I
3 p. M) h! f4 N6 F% l2 ~0 H

page指令的功能，写法、并示例，并描述它的如下属性的功能和用法：import、session、buffer、errorPage、isErrorPage、ContentType、pageEncoding
. x, H; w8 U& N" |$ x2 l: Iimport import 定义了一组servlet类定义必须导入的类和包，值是一个由

$ d! Q7 V( Q5 _( h7 W" q逗号分隔的完全类名或包的列表。
: q0 V2 k; M# P
4 @( q  L! D4 G0 X' ]6 R, A$ bsession session 定义JSP页面是否参与HTTP会话，值可以为true（缺省）
; q4 r: g, H2 f4 H! C
或false。

buffer buffer 定义用于输出流（JspWriter对象）的缓冲区大小，值可以为

; w# g; ?( H7 [% q+ D/ `none或Nkb，缺省为8KB或更大。

errorPage 用来指定由另一个jsp页面来处理所有该页面抛出的异常
! u* a! p  e( G) q  V
0 m, w( R1 u% L% I" O0 `isErrorPage 定义JSP页面为其它JSP页面errorPage属性的目标，值为true或
2 s- A5 k0 D# }/ U+ `) z
, Z9 z1 r. w' O, ]6 sfalse（缺省）。
& o6 @2 Q+ N2 S  P" w# O; m
ContentType 定义输出流的MIME类型，缺省为text/html。
1 i7 \# b" |6 g5 D$ M2 H
pageEncoding 定义输出流的字符编码，缺省为ISO-8859-1


; W6 X: x; k4 u1 z* R! a
描述MVC各部分的功能？MVC的优点？MVC的缺点？
MVC各部分的功能：

Model（模型表示企业数据和业务逻辑）

封装应用状态
* j0 @2 a$ R5 A2 P
响应状态查询

暴露应用的功能
* V" M, c3 }# }2 e: g2 r
# x' {& I+ b! Y8 H  W9 ^# vController（控制器接受用户的输入并调用模型和视图去完成用户的需求）
! x& P' w9 ~7 @: D2 i7 ?% y
验证HTTP请求的数据

将用户数据与模型的更新相映射
* w! Q9 \( h6 G0 R4 V/ ^
7 J8 V- k9 O9 F+ S6 G选择用于响应的视图

+ y+ a/ g" N# U! ]5 \4 z0 w' c6 OView（视图是用户看到并与之交互的界面）
6 v# k2 b$ ~  H
0 ~3 p) B, s& G" D" c/ c产生HTML响应
, G' q/ X( ?8 u
, z- j4 U& N: d9 {请求模型的更新
% b2 g* x0 [( e/ \2 F: u/ }% W# o
# r. p' C$ T# m: c2 L& g提供HTML form用于用户请求
9 J6 F( Z  I2 D. i% W# Q; K" r
) }. ?: g: @; r6 H/ q6 f9 y$ eMVC的优点：
4 V3 V& D4 T! c( w* Y. G- u  y9 E
. @2 S9 c% Z- l- J        低耦合性：视图层和业务层分离
; |6 x. C' r0 b$ R# i1 K
2 \3 j9 ]) L6 o高重用性和可适用性
* o1 ?* D2 N( G' l. h
较低的生命周期成本

% C* v* A5 p3 D8 T快速的部署
/ r" p' r% k6 K4 f; P
可维护性

有利于软件工程化管理
! B3 A4 z( ?8 M
提高软件的健壮性
! B8 Y4 Y  p) g0 A; n. L
MVC的缺点：

+ i# `% k9 u8 W0 K/ |        工作量大，增加工作的复杂性，MVC不适合小型甚至中等规模的应用程序
- V: n- A1 r2 F

# K0 Y5 W- e" y/ i: A( t3 d: l1 C$ M
什么是Model 1结构，以及结构中各部分的功能
, }' {; C7 m5 b: F结构：jsp+javabean
, `3 R, r( A! P+ [" h7 e
  }- U- I9 ~' ^Model1中使用jsp来处理web应用中的视图控制部分
' B( _+ c& s! N& B* m- H+ J
Javabean收集参数

% ^0 K# V; v! k# z: F+ u
: n4 Y& u: S/ o5 ~9 ^
  v6 W5 _0 _% Q& t: T% z, D什么是JavaBean?
用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。
  G5 |. L/ m/ t+ B- W
, Z$ |2 n3 A  ]: P- n

JavaBean的规则？
使用get和set方法定义属性
2 s" q$ W  a' h2 K1 }! W
一个无参构造方法

无public实例变量( 所有属性私有化)

* w' u. {% L' O9 h; ?4 w/ c

什么是jsp标准动作？包含那些？分别都是什么功能？如何使用？
JSP页面中使用类似于XML的标记表示运行时的动作

jsp:useBean
3 U' C$ G3 E( ~. j7 T
jsp:setProperty

jsp:getProperty
0 W8 F1 D$ |0 K
7 e" i/ a3 e$ ajsp:param

jsp:include

* S+ n( Z! y# M2 B8 Q. P% Ljsp:forward

6 Q* f- O; {( ?- A$ ?
4 M9 X, \; G7 E7 u$ h% ]
用代码示例如下标准动作的使用：useBean、getProperty、setProperty
: W- ^. Y1 I! q! c5 I7 n1 R<jsp:useBean
' x5 n8 A3 {7 p1 p
& M6 a' i/ J2 M: [5 P: A- h( n" E; xid=”myForms”

0 O5 c* R, B$ {, E1 f, vclass=”com.base.mystruts.forms.MyActionForm” scope=”session” />
1 p/ f4 Z$ w" O  |1 e( T
    <jsp:setProperty name=”myForms” property=”name” />

2 B6 N& _# u- A  o0 \0 T: H/ V<jsp:getProperty name=”myForms” property=”id” />



3 _, v4 J; Z* d描述说明Bean的四种scope
page
4 `& ]; [6 w" L+ a8 o
( I" w* Q& }0 y, G2 jrequest

' r1 n4 T1 R1 I3 t, [, dsession

6 P+ ^  m  R9 u" b5 D! sapplication
+ s1 J3 `6 y- H7 i% D. S' {
% h/ s4 f! Z6 M

" d8 D; g% ]; l3 Z1 Y6 y( u+ t7 x描述说明页面上的字段和Bean中属性的对应规则
& W$ O/ r3 c& i( Bid 指javabean的变量名

  J7 \. [; Y2 [+ d( B1 Xclass指javabean类的全路径

1 @& Z/ O; `, M+ ?- X. z- Hscope指javabean的应用范围

name指所用到的javabean的变量名

    property指javabean中的属性


0 G4 S# H& R, b( }+ ]4 d
) K# S+ z* M% i: p* R描述useBean动作的处理过程
使用id声明变量
; u4 ?8 y% s( _. ~# |  v# }
试图在指定的范围内查找对象
; {' \3 `- [% \/ C
如果没找到
+ ~, O. ~( E' }+ X. P
创建一个类的实例

+ T2 E6 \' @$ d  w4 o1 j0 D6 Z( \执行useBean标记体初始化对象
- v) O0 l& W* s" w& h2 M
- z3 I7 b, K; _. J9 J' Y, G1 `; `如果找到
; L7 {! Z6 @* Q& `( ?2 ?! U
! U( z1 k3 I" f* C' N" o" j     将对象转换为类指定的类型
& W% U3 I( U( o8 g- y( o1 |3 M
3 M: [5 y# ]# o( o! U7 q) b; a+ X

3 ~& V5 \. ?( G# j" d描述forward动作的功能
使用脚本代码处理请求时，可用jsp:forward 动作产生一个不同的视图，

使用同一个request：
& K. \3 G, V* h( b9 o$ R

# q! r& T% h& B" e
什么是Model 2结构，以及结构中各部分的功能
3 U6 [: O. o4 a: T* xjsp+model+servlet

  {, Z- `2 k- u1 }& h& }Model 2架构使用MVC模式，JSP页面充当视图，Servlet充当控制器

3 z. u) i! R7 P$ b" t; w" zServlet控制器：

5 i% ?9 l! i6 e" ?! Z( ?验证HTML form数据

调用模型中的业务服务
$ k; U+ I/ k( Q7 X; \5 L5 f
存储请求（或会话）范围内的域对象

* g2 W$ x+ |# N2 L选择下一个用户的视图

8 E# O; ]7 ?* n: VJSP页面视图：
# t5 t1 r* p$ N5 [. x, x6 g6 r. Y
使用用户界面（在HTML中）

        访问域对象



4 Z$ d$ U6 j3 b$ e如何获得分发器？分发器的功能？
上下文对象中的分发器：
8 E) D' x2 I% r5 ~0 g
ServletContext context = this.getServletContext();

RequestDispatcher servlet = context.getNamedDispatcher(“MyServlet”);

servlet.forward(request, response);

2 I( A, p/ y5 h0 W' Q6 @2 K请求对象中的分发器：

RequestDispatcher view = request.getRequestDispatcher(“tools/nails.jsp”);
# F  u" i7 V2 n; t' {  l
8 w2 w9 B1 B5 s- `' pview.forward(request, response);

可以将请求转发到另一个jsp页面，并保持请求的传递性
) E# K' F4 Q( ^* a: J
7 |" _1 Z9 J3 q

Jsp中页面跳转的两种方式？
; C- u8 j$ B$ P- o& ~使用分发器跳转页面
RequestDispatcher dispatcher = request.getRequestDispatcher(“url”);

dispatcher.forword(request);
( z3 H8 H% L7 G) e6 Z
" t/ t8 }6 l3 s1 z) U, m    特点：保持请求的传递（上一次请求中的数据，在下一个请求中仍然可以得到）；

" Y( @; F- p1 X5 T  Z- S! |        转发的页面只能是同一个Web应用程序的其他Web组件

使用重定向跳转页面
6 `1 C+ B" @1 H" v+ sresponse.sendRedirect(“url”);
" k* z' K8 v) Q. m) w' d
    特点：产生全新的请求，（上一次请求中的数据，在下一个请求中不能得到）；

        重新定向的页面可以是任意的URL
1 G  c% ?9 \5 d5 ]; m- `5 H


描述Jsp中引入另外页面的两种方法，并比较两种方法的特点？
7 r( {, o+ O& ]% ^<%@ include file=””%> 在编译期间把另一个页面完全嵌入这个页面,可以说是一个页面

* q: w0 p# u2 B8 ^在这里可以共享变量

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

页面，不可以共享变量

: S8 H4 h) c- l' j6 w7 O

什么是自定义标记
# V$ j3 l( f! _) \4 p自定义标记库是一个Web组件，
& D+ O# l+ y: p5 l" S; N5 @
, q$ [; S2 q7 l包括：
3 n1 m7 T4 x+ c% O
1 t* G; B7 Z; E3 K- U  q一个标记库描述符文件（*.tld）

所有相关的标记处理器类(*.jar)

2 q8 _8 f2 J2 Z* J4 T0 A5 i$ m- |; P
7 a8 R& v) q- O' H2 q% d3 m
描述使用自定义标记的步骤，以及每步详细的工作
, @/ b7 L; n3 Y; m8 b4 Q0 Z使用自定义标记前，要拿到.tld和.jar两类文件
5 |5 i' x. ?  C% j" I
把.jar文件放到WEB-INF的lib里面。
7 v: M2 a& k; S, c把.tld文件放到WEB-INF根目录下。
在web.xml中配置。
8 k$ J+ g) X* P8 R& p+ x<taglib>

<taglib-uri>http://java.sun.com/jsp/jstl/core</taglib-uri>

. b9 D! p  N- r" A; k     <taglib-location>/WEB-INF/c.tld</taglib-location>

</taglib>

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

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

prefix是前缀，用来区分是哪一个taglib
, P3 y; E6 T" p2 A: ]7 X' \
使用标记
格式：<prefix:tag名称 属性>

5 S4 {' P$ |/ U8 O9 m<s:forEach >

admin

在tomcat下配置数据源
1、服务器与数据库的连接
- l0 \2 n" s3 W% \
配置server.xml文件

# N4 T! v- A) k6 p5 Q1.oracle

, n) Q* X# Q& l% S/ b<Resource name=”jdbc/company” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”

                        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”
: }) S6 y  u& V) ?* u
( e3 {9 [) I; V( f  g- aurl=”jdbcracle:thin127.0.0.1:1521rcl”
* o3 f$ e5 g$ C! S- a. r
, h) l1 X& X  x$ r- B; _driverClassName=”oracle.jdbc.driver.OracleDriver”

- p8 p' l6 ]$ n* P; F0 Tusername=”aa”
7 T( y& h& Q# [! p, a' p8 J
) G7 b  z8 A: x/ @+ Q4 [8 kpassword=”aa”

9 E  ^: K1 K& l$ s2 GmaxActive=”50″
0 [8 f9 ~- k- d( g
maxIdle=”10″
3 m  e' B0 q4 n" `) |% w
maxWait=”-1″
* c4 u( w9 R# u7 V9 x' _( L" t
/>
/ p  r# x# n* r, d; {) e. |
2.sqlserver

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

        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”
  K3 t4 p, ]) W" b9 I
9 p  Z) D# h* A% G, gurl=”jdbc:jtds:sqlserver://localhost:1433;SelectMethod=cursor;

. G. {1 z3 c: z! I4 cDatabaseName=webpagetest”

! m( d9 }1 ~( k1 tdriverClassName=”net.sourceforge.jtds.jdbc.Driver”
$ ]9 s4 L  \3 V
5 L& X. ~, \) A& A4 l1 U) Cusername=”aa”

: G5 d0 T# l' z( |password=”aa”

2 |* _, ?% U7 T7 d1 [. g2 u* c, _maxActive=”50″

maxIdle=”10″
# t& u( m6 [; ^' v
maxWait=”-1″

0 G& P$ X; }( F; Q5 N+ e/>

3 N' u' u( l! S, }2、配置自己的web应用的xml文件
4 N! S2 m" a9 b2 }  V


<Context path=”/eb03web” docBase=”F:/workweb/eb03web”
5 m: o$ @1 `; y5 ~
privileged=”true” antiResourceLocking=”false” antiJARLocking=”false”>

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

. r2 [3 n) I4 I& Y! z</Context>

# t. S/ @4 o6 L

3、配置web.xml文件

与服务器建立连接

9 s% F# T; s# B! I+ c<resource-ref>
' n% G) v& p9 f2 w# x' K5 e
<res-ref-name>jdbc/company</res-ref-name>
3 R9 x+ Q( x$ l0 y
<res-type>javax.sql.DataSource</res-type>
! j. Q' Z5 @5 l9 `6 y( X' [
/ d6 w$ J0 d6 e% x# E<res-auth>Container</res-auth>

$ ~9 c) A, h. f: R: R$ K</resource-ref>
% S% C4 ]& F+ f5 C$ z  Z! z7 P
& }- }* ~+ @" |# f9 p' s3 c/ |4、在应用程序中不直接与数据库连接，通过DataSource连接池建立连接

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

4 S7 z6 _/ j1 c, j- {System.setProperty(Context.PROVIDER_URL,””);
6 [0 \2 d0 U; w0 ]# q1 b
System.setProperty(Context.INITIAL_CONTEXT_FACTORY,””);
1 Y" s# G: n6 ^; E$ Z
* E: u4 U( N* \- E% H/ O- R% d$ j//2.创建一个上下文对象
  l/ c" D) y7 E0 w: ~0 K* x
InitialContext context = new InitialContext();

//3.通过上下文对象在连接池中查找DataSource
4 j9 q7 T* i# U- |5 K7 t( |
/ c" ]( F5 j  o6 r0 ?3 P: _8 HDataSource ds = (DataSource)context.lookUp(“java:comp/env/jdbc/company”);

//4.通过数据源建立连接

ds.getConnection();

admin

ORM对象关系型数据库映射
3 h2 o' p+ {( G6 ]- h(Object Relation Mapping)
- J; H2 y, j, J
一、映射的特点

1.一个对象可以对应多个表

2.一个表可以对应多个对象
7 A- m; E" a7 s4 x' h1 [
' @' q4 x( ]& }; l# Z5 m3.对象和表的关系不用完全对应
6 q! |+ {# V8 N$ B9 a/ _- G
" c* [: c5 X/ R, w8 X: P% y4.对象的属性的名称和表字段的名称可以不同

* P9 V( S" x& _5.类型可以不同，但数据类型之间可以转换
$ q3 ~$ {; t4 V: N4 S$ I
6.对象中必须有主键，数据库的表对主键无所谓
6 Z/ a* D) R# a1 j& \% S% g- n0 ]5 g  f+ o
7.数据库中有主外键关系时，对象中可以有，也可以没有



2 L5 U% N" H% U* m4 ]. ~. ]二 、有一个映射的描述文件————>xml
; r) O, S8 m- z8 B4 `% L
三 、怎样实现描述文件————>一段程序

: r( f0 p/ i, h$ G; @; z# l7 F对象 映射（mapping） 数据库

user
# g& i$ `) I$ K# ~
, }/ i' Z0 Z1 o8 o: o8 Did=11
, S% T. }$ ~' h* R
: y, C! v3 B8 p7 t$ oname=”张三”———— > (1) —————> tbl_user(id,name,age,tel,address)

age=25 <————(2) <————
" D+ F% d% T* B3 I: V

% x; I$ K9 V$ U: k: @1 B, ~! s6 z. L
(1)从对象映射到数据库

1.JDBC
1 [0 I3 F- @8 u; D! F; }
3 Y- C) Q4 Y( w  S+ o) |2.根据描述文件来动态拼接sql
. F9 X2 M; p& I' T4 f
" U. e5 E) J& X% |$ m3 u% p3.执行，添加到数据库中

2 E, }- K4 e% q* f* c
, g4 Y* F; m& o% }$ {' |; {- {
, o# _9 x- ]' D(2)从数据库中映射到对象
3 R# d* g! P8 m- @# S: x
1.JDBC
6 q- o, T9 }7 U" T4 p4 Q: D& t
4 y- v8 ^0 W) f& E; R$ _2.拼接查询sql
- j& j+ m. j) s7 M) ^8 k7 i
3.ResultSet

4.Model
/ y* s1 m6 h1 f4 K; E6 a

4 x, ?; o8 G- C4 ^( Q8 `4 R0 [
hibernate
开发流程：

是什么？
7 m  f2 X, F1 h2 k, khibernate是一种基于orm 的轻量级的框架
1 D. l" y9 I" c* P


8 n7 i/ u* U- c% {有什么？
1. session 保持连接状态（依赖事务和连接池）

" m. _' B' t, N' l( o  k) C2. Transaction事务

/ r5 G+ p$ F" c$ w3 T3.
Connection Provider 连接池


! F! r& C2 H; u( \0 ?, J9 j5 }5 X
能干什么？
% m! J9 J: }7 s# r# d1.orm

2.提供操作数据库的接口，简化数据持久化的编程任务
  f& ~( W1 ]/ @6 b" V
" c! \" [) f4 |
# ^/ e6 y# r6 Z* p8 g
怎么做？
- G6 u" U0 V% a6 E. a2 K1.搭建hibernate的运行环境，将hibernate的包和hibernate所需要的包拷贝到lib 文件夹下

, [' ]3 m- z. |# e* m' F; m2.O（vo）

8 b5 M! V( d& M$ g; j/ J3.R （关系型数据库中的表）
5 \( V; E+ r5 I. W5 e! L3 H1 W; W
9 z7 ~! \* i: @* T- ^! b+ m3 h4.配置文件

% [* E. d/ u/ A  I4.1 cfg.xml 放在classes根目录下，默认名字为hibernate.cfg.xml
5 \- Y* a6 I- m5 @2 a
, l' N' p) ^# Q9 m# na.与数据库的连接
1 F% ^+ V! d- T$ y( {  l" }# H6 c6 K
0 t$ m. J# {' h# t* e9 J2 W/ @b.可选配置
+ l7 Y8 L9 r) U: K" m
0 ~9 U7 j* Y, I- j7 x- rc.映射资源的注册
& A; @6 n2 j# R% Y4 Y) l7 g
$ Y& r: B  Q) z0 w& M/ H4.2 hbm.xml文件 名字与类名相同 并且与类放在一起
) D& }; V! n& p2 e
) f- x/ N1 l, Q% G1 La. 对象与数据库表之间的映射

b. 对象的属性与数据库表的字段之间的映射

# L8 U" ]( m5 C. Fc.组件之间的映射
2 A) ?' n5 A  ^0 ^+ F
d.对象与对象之间的关系映射

5、客户端

0 {3 u% L; @; \% `2 s1.得到SessionFactory

2.通过SessionFactory 工厂来创建Session实例
! f7 p6 [7 _: l" f
3.打开事务

. x+ g, H! }" g  T4 K4.操作数据库
& ^5 ^) M2 @) f% T+ L
5.事务提交

6.关闭连接

$ }! Z+ z3 `% h) e9 O: X运行流程：
+ j6 j# b/ ^: G* w! x6 o. o
7 z0 N& \: U& a4 ~& z整体流程
1.通过configuration来读cfg.xml文件
" F5 C, {8 x7 b  e
2.得到SessionFactory 工厂（根据数据库的连接来创建sessionfactory）

% b! b) F3 r9 i" O6 ]3 Q% _3.通过SessionFactory 工厂来创建Session实例
9 U: ]3 s; c3 c1 O( t* _# X
4.打开事务
" ]9 @$ U$ X! r# R  y
0 f0 E9 g! q* _6 @% \3 X5.通过session的api操作数据库

1 S, f) N* _" A4 V- a: W2 b6.事务提交

7.关闭连接
3 w9 X8 g  Q2 M7 j* S0 a9 t
1 |9 Q- F% Z! p+ \) F6 k9 {9 u) b

' ^% a1 \# x0 D5 Jsave
2 X0 a4 V. P! s4 J( g6 N0 V1.to—>po

+ R/ G, }5 g( _1 x( j# y4 m& b2.根据model和cfg.xml中映射文件的注册来找到hbm.xml文件
3 D- I( F/ \: U
3 ?8 n  ~; Y  ]# Q3.根据hbm.xml文件和model来动态的拼sql
0 [% Z1 X) W6 @
4.客户端提交或者刷新内存
9 ?8 h& J, H8 H! k$ _/ Q
5.执行sql，值放到数据库

7 q# R5 C& x$ Z( o$ \6 a
! p( ~& [9 C6 U6 T* a
" M: x4 I1 h0 P. S5 j9 d( ^' Oupdate、delete
1.根据model 的id在内存hibernate的缓存中查找该对象
1 k: E" ]' r( d4 a
如果内存中没有就到数据库中查找来保证对象的存在
4 r; c8 c( h& T" ~
6 z  H* D1 N/ o+ h3 z" u1 Y- p2.根据model和cfg.xml文件中映射文件的注册来找到hbm.xml文件
% d/ F1 D" Z: ^- U7 O; |6 S; t9 z
. M" j7 `5 w0 |% B1 l+ C; I- l3.根据model和hbm.xml 文件来动态拼sql
4 i( ]: ], M; X& r' L+ X! C
3 w8 P* R1 t+ T4.客户端提交或者刷新内存
. m  z5 l1 B0 \5 s/ R4 A# ^' `
5.执行sql

7 |: T% T# y/ ~6 m, ?7 s& v' U& O
9 a2 A& B0 V% R+ w3 l' _2 r
Query
6 L, U# k+ R/ N4 M6 tload

* W# P8 ~3 F4 h9 n* q1 U1.根据model的类型来找到hbm.xml文件
5 x5 S1 c2 }/ e1 O" j
2.判断id对应的对象在缓存中是否存在，如果存在，就直接使用，如果不存在就进行下一步。
. e+ m2 o/ u: `3 I
/ R" j* ~; Z+ i1 ]3.用id做为查询条件来动态拼sql
" f& z8 f( e7 v
4.执行sql 查询（先在内存中查找，如果没有找到（会抛出例外），就去数据库中查找）
4 g7 O0 Y% B+ `/ k# A+ p/ C
3 b8 U% n% t+ p- W% j+ X4 O5.返回一个model类型的对象
  e/ I3 P/ s- g& y
* L. _' m8 p2 b  N' @% p  uget

    1.根据model的类型来找到hbm.xml文件
$ u. u5 J5 J& _, N( z; h
9 Y' f  T! e9 l& F: \8 F5 O% t; N2.用id做为查询条件来动态拼sql
, H* N& k2 I) M! V. I( x
3.执行sql 直接在数据库中查找，如果没有查到就会返回null
3 }5 a. p* H# I: f' x
' w4 l& h4 B' f6 \+ W2 |$ @8 I! qquery
! L5 \8 a8 I' w' g4 y1 |
1.分析hql语句，得到model的类型
. U; e5 W5 T, v2 P8 y0 f8 l- V
2.根据moedel和cfg.xml文件中映射文件的注册找到hbm.xml文件
- j9 k0 k( c, K& m4 b( s
3 f: X! z% u1 k8 H$ z0 n; H3.根据model和hbm.xml文件来动态拼sql

4.执行sql查询数据库
8 ?- u3 I" g% a( ~# }3 C0 D
5.返回一个resultset

0 H8 \" H! @3 C$ J3 x# G6.循环resultset的值，放到model中在放到集合（List）中

# F+ x4 n( \; u& N$ Q& x

9 `, J+ C$ n9 i  l9 |$ v9 b谈谈hibernate缓存机制

缓存其实很直观的理解为放到内存或者硬盘上的一块区域，缓存就是一个缓冲的作用，有很多时候，我们的数据需要经常访问，如果放到数据库中，不是不可，只是效率上低，如果有了中间产物来代替数据库，就省很多事情了。打个比方，去买酱油，不一定一定要去酱油的生产工厂去买。代码中需要数据的时候，可以先到缓存中查找，如果存在，就直接拿数据，不存在就去数据库中取，也省了很多事。
" [8 o1 d+ m+ ]! O$ S+ `

( v8 P* ?/ _' Q8 d. i
4 q) q, {  i2 W! i( B, \' khibernate使用的是二级缓存，有两个级别，分别是Session，SessionFactroy级别，一级缓存是Session级别的缓存，Hiberante来管理的，这个我们一般不用管，二级缓存是SessionFactory级别的，可以进行配置和更改，加载卸载，就是我们平时用的hibernate配置文件中的配置SessionFactory的属性。
" @" p7 D" Z( u. e; S4 E4 U
) _, u( e3 `1 l# Y( N5 ~+ o5 \
0 h' L+ I# _4 R% z
- I7 M( F$ _! ?% j0 ~对一级缓存中的session事务进行数据的预存取，数据在各个session的上下文中存在（单例），当session关闭时，就是session.close( )，整个所有session范围内的数据全部清空；二级缓存默认的情况下是不开启的，如果开启，数据库汇总的所有数据都先copy到二级缓存中，这里要注意的是，一级缓存是每个线程下创建的session缓存区域，可以是多个，二级缓存只有一个区域 ，画个图比较容易理解。
: R- m3 ^& ]) V5 X
! m, X* K& c, s8 l& i5 z
& U0 I# b! [. _
| 一级session缓存| | 一级session缓存| |一级session缓存| |一级session缓存|

| | | |

( H; z( v8 N) `% K$ w; R| | | |

—————————————————————————————————
8 f6 C8 Q% H: \
sessionFactroy级别的二级缓存
* v+ B* Q2 J' Z, P; Q8 b
——————————————————————————————————————-

|
6 _" I! W( H, i+ Q
0 M9 U; _- ~% l) ||

|

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

DB
& s, T. Q! n3 _8 @) x) s& J& P
—————————————————————————————————————–

admin

Spring

• 是什么？
  
  

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

, w  Q' {4 C8 Y) |0 D. Y

• 有什么？
  3 q/ |3 r4 X* R  k
  

. F3 y4 \8 @% i. s8 ?

每个包的功能：

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

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

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

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

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

AOP ：面向切面编成

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

• 能干什么？
  - ^9 ^  ?9 r  H
  

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

" _8 q* B% b# e' e  b" h8 d( M. d

• 怎么用？
  
  3 E( T1 C+ ~' g
  • 搭建web工程，引入spring的jar包
    
  • 在web.xml中添加如下配置
    ) r- T7 D! H2 x3 p1 ^
    
  
  6 ^$ W4 v1 w. p7 H$ K* D
  * Y2 Z! f0 {4 w( o& H9 n

            contextConfigLocation

            classpath*:applicationContext*.xml

   

        

            struts2

            
# ^. D& N( O! u8 R

                org.apache.struts2.dispatcher.FilterDispatcher

            
4 K- c9 C1 _1 O1 |: y7 B0 f

        
2 ~8 Y- V) ?. g4 m" q/ u" a

        
8 ~2 i# A6 V( b5 J

            struts2

            /*
$ z: S! b" }8 Q) `

) c  N  w+ M5 t9 u5 g

            

                org.springframework.web.context.ContextLoaderListener
2 {4 l) D  X( G

            
, M+ {( W$ ?; }, g& T& o# U

        

• 部署
  
  8 f  p% a. V# \' P! E6 O6 x5 k1 Y

" V$ {: Y9 g& y/ q

• 容器和bean
  

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

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

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

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

• IOC控制反转
  3 B. p) z, ~9 z' p# D
  4 A) S, t7 a9 r0 d4 R$ ^# X
  
  
  3 s& H. |! L5 q! P
  从前的应用程序想要得到A的实例他会直接主动的去拿，当用了sping后，应用程序由主动的去取变成被动的等待，由spring来控制应用程序所需要的对象
  
    V2 ^$ L1 H2 ^% W) B) M
  • IOC的优点
    
  1.可以通过IOC来获得实例
  2.可以通过DI来获取注入的资源
  • 配置IOC的原则
    
    • 一定是可变的资源才采用依赖注入
    • 一定是层间的接口或者是模块之间的相互调用才采用依赖注入
      

• DI依赖注入
  

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

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

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

例如：

在配置文件中

, c7 t( O- q; g  B; H
2 L! W" g9 z6 e. ]( v
" @8 X8 f! V' |9 N

在应用程序中

Public DBDAO dao ;

Public void setDao(DBDAO dao){

This.dao = dao;

}

3．构造器注入

! \# Q5 s- M) }3 N. h, h" B

4．ref 表示参照其它的bean

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

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

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

6.lookup注入

7.singleton

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

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

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

8.DI的优点：

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

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

; Y- A3 b( v7 Z% g$ x: ]

• Aop面向切面编程
  
  

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

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

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

3.AOP 的概念

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

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

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

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

5.引入 ：扩展的功能

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

7.aop代理 ：实现机制

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

4.AOP的事件机制
' R% d3 u4 W' ]* z  t' ?, `

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

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

3.找到切入点

4.确定连接点

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

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

3 I( a/ N4 }( w

1 Q, E4 F) V+ N" @( B4 D

7 _9 A: e7 y$ `) G3 Q' y

5. AspectJ
. n- E& I0 F* l2 x4 o

5.1.在xml中配置比较烦琐
, k+ G2 \) V' U9 M( j5 r, f

所有的入口必须从一个代理（ProxyFactoryBean）开始

         


         
- f1 d- z5 h; x( q4 ~9 u

        
. O6 S' O3 }: f& A

        

expression=“execution(* com.javakc.aop.MyTarget.t*())”/>

        

        
( q# v; F4 @. [

   

1 C4 @6 I) B( p; J' m/ H3 ~
' N1 ^8 K: U* p0 j+ l- }

5.3.使用注解的方法相对简单
/ A/ D, u( p3 y% m. e+ I

@AspectJ的基本语法
( H4 }7 L, i( r# A) P' r

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

直接在类上定义@Aspect
) J  u3 n$ J7 C: C5 u

2.@Pointcut声明切入点
- m, K4 V7 e5 U' e8 e1 n4 s

2.1、用一个专门的类来定义pointcut，类中的方法名就是该pointcut的名字
4 y, E* c, x6 C7 U3 A+ f

2.2、可以使用匿名的pointcut
0 g) d5 H, C/ q( S

2.3、执行切点的几种方法
9 d) Z; u1 B, D! R; p; [- X5 j

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

2.3.2 within 指定到包，不能指定到类
, I2 I; m; J/ x( n; o2 r5 J9 l

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

2.3.3 this 指定到实现接口的所有的实现类

2.3.4 target 指定具体的实现类

5.4.advice的五种类型的示例

　　　 客户端必须从接口走才能得到监控，实现想要追加的功能

5.4.1.@AfterReturning(pointcut=”” returning=”retVal”)

追加的方法的参数名字一定要与retrning的名字相同

在注解@AfterReturning中必须加上pointcut和returning两个参数

pointcut指所要监控的目标对象的方法
! Q2 Z6 C) E* ^+ Y8 k* S9 J( U5 c

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

完成追加的功能

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
: q, l4 ~) W0 I! B

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

(2).

     2.直接引用匿名的pointcut

     (1).@AfterReturning(“execution(

* com.javakc.spring.schemaaop.Api.test4())”)
/ A: v1 `: U& v+ d* d) y

     (2).@AfterReturning(pointcut=

“com.javakc.spring.schemaaop.TestPointcut.t4() &&
3 |3 L9 b6 M0 ~9 a% Q

args(str)”, returning=”retVal”)

@AfterReturning (pointcut=”com.javakc.spring.schemaaop.TestPointcut.t4() && args(str)”,returning=”retVal”)
& D* m% M( m$ T, V! h" P0 u( e

public void testAfterReturning(String str,Object retVal){

    System.out.println(“afterReturning1=>”+retVal+”=>”+str);
; r4 k  F# F& M9 A

    }
! V( c3 F# i" A* V

5.4.2.@Aronud

     注解@Around环绕追加功能；

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

     必须有参数；第一个参数的类型必须为ProceedingJoinPoint；

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

目标对象的方法
' y* r; u( J9 t. f

     1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
4 z( ]1 t7 C( C; g& c0 g9 S$ {

     (1).@Around(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
! b8 U7 x+ i$ q

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

&& args(str)”)
* a$ i7 J% Q; i+ X: E; o/ j* A

2.直接引用匿名的pointcut

     (1).@Around(“execution(
; Y0 J, f7 V, f, K6 \

* com.javakc.spring.schemaaop.Api.test1())”)
0 f. s5 q* J" U9 d

     (2).@Around(“execution(

* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
; I6 q' g; W1 H/ _. v3 A* z

// @Around(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
: F& o$ e9 R6 N  N

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

public void testAround(ProceedingJoinPoint prj,String str) throws Throwable{
6 R% z5 J4 L6 ^. ]: n

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

        Object obj = prj.proceed();
2 T3 [) J1 _; n, Z% ~

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

    }
! `6 Z3 F* ]/ y2 g, l% P) Q* a

5.4.3.@Before

注解@Before在执行目标对象的方法前追加相应的功能
0 r) D4 \3 Q0 K/ q% a$ k

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
5 [) y8 |5 k6 `+ h5 N

(1).@Before(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
$ U6 M3 Z5 d8 `8 P0 C; _, y! K8 c0 S  m

(2).@Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
0 V& ^, S3 X/ C  J1 F! G% H8 z

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

2.直接引用匿名的pointcut
: ~/ r9 J: |# t

(1).@Before(“execution(* com.javakc.spring.schemaaop.Api.test1())”)
4 a+ k8 ~$ g7 J/ t

(2).@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
& z5 N$ d# q0 |" V, H# C

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

// @Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
$ M1 s; l2 J! I( o  a" V5 }% z! n

@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
! S6 @, B* \/ y

public void testBeforeParam(String str){
1 J7 ]0 k0 s) Y) \+ f* r& Y: y, n

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

}

5.4.4.@After

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

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
0 _! \5 K0 z6 g1 b9 B! C

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

     2.直接引用匿名的pointcut
" X' o6 v. n4 g$ @: S8 W0 a6 Q

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

@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
$ u, K4 U8 |# g: _6 O* V) ?$ C% b( W( E

    public void testAfter(){

    System.out.println(“after1== >pointcut”);
! G& F* r9 {! ?; k  e3 g9 r

    }

5.4.5.@AfterThorwing

• 描述一下spring中BeanFactory和ApplicationContext的差别
  
  

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

5 N5 `4 F2 V; v/ z) p9 C8 D

• 谈谈spring对DAO的支持
  ( D0 N2 C1 y" ~8 y# b' s* t
  

Spring提供的DAO(数据访问对象)支持主要的目的是便于以标准的方式使用不同的数据访问技术。
% n' K8 x" ?" {8 h9 g

简化 DAO 组件的开发。
Spring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法，用来简化代码开发。
: }2 u3 I/ q5 R1 H

IoC 容器的使用，提供了 DAO 组件与业务逻辑组件之间的解耦。所有的 DAO 组件，都由容器负责注入到业务逻辑组件中，其业务组件无须关心 DAO 组件的实现。

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

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

异常包装:Spring能够包装Hibernate异常，把它们从CheckedException变为RuntimeException; 开发者可选择在恰当的层处理数据中不可恢复的异常，从而避免烦琐的 catch/throw 及异常声明。
+ |" l; y; e0 P( A. g2 r; J% _

# A$ T, U% y/ z: C  W/ _( w

• 谈谈spring对hibernate的支持
  
  

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

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

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

        class=“org.apache.commons.dbcp.BasicDataSource”>
4 w& ?3 {$ |6 n9 s6 O1 K6 N  I

        
7 w0 S( x; q+ A9 P8 R

            oracle.jdbc.driver.OracleDriver

        

        
6 j$ r6 H4 U- |) r; H& R

            jdbcracle:thinlocalhost:1521rcl
8 N1 y! l8 j& q( V) n9 ~0 k

        
1 @4 \( M# y( o6 g

        
$ ]9 b$ T( h# a/ ~! X

            javakc2

        
2 `* C, R4 t, g% g, q

        

            javakc2

        

   

7 k7 u* X2 L' `# i; C9 Q: z% X

   

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

        

        

            

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

            

        
+ j$ p+ ]8 O) K' |2 r8 T

        

            
2 U1 g. d6 z' ?

                hibernate.dialect=org.hibernate.dialect.OracleDialect
; T" {" z" l- V3 ], q

            

        
1 _) J1 E4 H+ r9 h

   
' e8 q! ]- [$ O5 ]2 Y- c7 Z/ Y0 N4 L

   

        

   
, \) g. R/ ~) q# q

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

   

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

        
  |8 N# N2 V- v6 X/ u9 x

            java:comp/env/jdbc/myds

        

   

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

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

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

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

   

        
+ {, \7 k- ?$ N6 z5 L6 T5 c

   
7 o- L+ [9 \4 H

   

        

            
& ^0 j# y6 G& S& x

        
( H- j5 g  d/ u7 A& M

   

   

        
% n+ J/ w  Z7 G7 N( k8 \' w7 V

        
9 k1 v. n3 w9 p6 l$ X

   

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

. w- |/ o0 j1 d; M/ |  o

Spring2.0之前事务的写法 5 M( h1 t- r% y6 z# H5 c         class=”org.springframework.transaction.interceptor.TransactionProxyFactoryBean” + w& P+ }  I8 z& W) s: L         abstract=”true”> & h9 A% R3 Y! e8 }2 F) _+ ^8 t( n 5 k! h8 Z5 Z/ n4 D % |- Q+ a5 D* T5 w6 I                 PROPAGATION_REQUIRED,readOnly                 PROPAGATION_REQUIRED $ e, A1 u5 q- {" C 2 w: W/ t; P" g. k; g , i* y- m; s0 k3 q

7 a7 D2 {; o: W* w

• 谈谈Spring对事务的支持
  
  ! ~. n+ H$ d0 x

1、声明式事务管理：

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

2.做法：

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

2.2

2.3 注入数据源

/ \7 p1 d6 s! n& j
1 X5 f. [0 {; E( Z


7 L1 j. f8 B5 H( W) Z6 o( D& O

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

2 v. Z, g# e: [6 E" H. v/ h! c- W
4 ?3 M. e4 s; i
) p) ?1 h7 K, Y. \3 I) g

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

% Y6 n6 ]- P0 E

2.6 定义切入点

8 q; T4 Z( ]- e0 M3 ?0 ^



9 W# R3 I$ k/ ]6 y3 F' u6 C4 P

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

1.注解@Transcational

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

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

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

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

! ]9 J/ g9 V, N# m( [( r# O- G  w( q

- t# X" i1 W8 |1 ]- ]( a

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

admin

事务
/ U3 S& c! a9 q3 UACID
（1）原子性（A）：一系列的操作具有不可分割性，要么成功，要么失败
5 ~* J/ e. L% @
3 T/ N6 W- k5 f+ O. r6 u  y（2）一致性 ：操作的前后满足同样的规则，保持平衡。
$ v3 e2 k; g# K- @- a; E; f
3 \0 U1 a& L) E( m7 B) C8 Q（3）隔离性 ：在事务运行的过程中。事务内的数据对外的可见性和可操作性（必需由数据库的支持）
7 K$ N! d- P% n2 L" Y! G+ X# u
（4）稳定性 ：保证数据在事务的操作的过程中不会遭到破坏，而且是永久性存储的
6 h  |( a4 r* ?6 G

2 T, Y* L! J3 V- l4 A4 [
3 s' \( L( U& f1 Y9 Q5 H事务模型
（1）经典事务模型又叫平面事务模型（JDBC） 事务不允许嵌套

（2）嵌套事务模型



事务的两种方式
) s7 Y, V7 k- h$ f- B3 s: ~（1）声明式
. @  R2 k: |" C% C1 d3 S
在配置文件中设置以下6项

（１）.required
+ s4 H, J# J% X9 a/ m, A5 t4 r' e
2 L2 Q/ X: C: v- H如果客户端没有事务　在bean中新起一个事务

9 w9 o/ C% V4 P- O" ^# [. E4 d如果客户端有事务bean 中就加进去

(2)、 requiresNew

不管客户端有没有事务服务器段都新起一个事务

如果客户端有事务就将事务挂起

(3)、supports

如果客户端没有事务服务端也没有事务

: ^% t0 r5 G1 @如果客户端有事务服务端就加一个事务

(4)、mandatcry

, n  g3 D, P& e4 f2 y7 C. U- T2 A9 e如果客户端没有事务服务端就会报错

2 a( K* Y7 A, m. c; F  Q如果客户端有事务服务端就加事务

(5)、notSupported

不管客户端有没有事务服务端都没有事务
$ y% s  ~) f/ I5 c
如果客户端有事务服务端就挂起

  l+ E( u( w' Z2 @(6)、never
3 E8 @  W* R7 u3 Q- j8 R( N
' V+ h% Q4 k! C$ T. R! Y/ ?4 A不管客户端有没有事务服务端都没有事务

如果客户端有事务就报错

（2）编程式事务

: b; Q* C3 u* F" d; ?5 A) cJavax.transaction.UserTranscation

JTA 事务可以精确到事务的开始和结束
. p+ I1 Y2 W  b, X' q+ V


事务的隔离性
7 G* z. d' V' zRead-uncommited

读取未提交的数据（基本上没有锁）脏读，存在不当读取的问题。
" [: _) M& f2 Q& ]
9 t* r# q& I5 l, _Read-commited

读取已提交的数据（行级锁）
" t( G& j$ e3 M( Q2 Y
无法读取已经写入，但没有被提交的数据。
8 K& S6 ^9 w, o6 S
Repeatable_read
4 V8 Z4 Z! T! w6 s
读取的数据不允许修改或删除

3 N5 k3 q  e! _$ a不可重复读（行级锁+不允许修改/删除）

Serializable

0 v$ G2 a! T# ~6 n6 f3 x幻影读（表级锁）
) Y7 @( j" M7 M0 R# n4 ?" |% k
8 `* T' {" P' u& c) C8 x0 M2 g
" ^# j9 }! v! m& h3 l( H& Y0 t
0 q- x' r! M3 B. {5 ystruts
开发流程

0 K5 A# B' }- ?' ]( t/ F2 L: {8 J1、创建表单
! C4 s. I+ @6 Q9 D
2、从表单中获得输入
( F2 b% G" I4 B$ W1 A7 K
3、处理输入（业务逻辑）

( I7 ~' |  S% K4、根据动态输入改变输入流
" A& {  c/ W: _0 m, ^3 Z0 c' C
. Q( q4 |5 @( r/ C4 @要完成上述四步，我们需要创建

% [+ [3 P* L, ?% b- z" N* G1、一个ActionForm

6 M2 \+ C; w" i2 s( p- t2、一个action
; x) X  @0 R% L. K. I
3、一个配置文件struts-config.xml
) `" B; X; g) q0 I4 l1 c: s! Z. ~
' {; q0 Y' C; N0 t0 [0 O5 U4、创建页面
% r" V9 W& J8 C5 J0 O4 f
# H6 A4 {' K- o4 }: o" ~& z创建ActionForm
4 V2 i5 Q; W/ m1 i" n
. @  k$ \& z& }# c2 B+ p, [1、写一个类继承ActionForm

/ z, y: B/ G2 l9 t8 B2 x2、私有的属性
! e9 q7 Q/ K# i5 U  \/ Z% s
  t' b; X* v. D. |7 f& _+ n3、相应的get、set方法
6 |9 A- u1 G5 z% K: J( p4 Z# ?8 H
0 `2 ~. ?. m* ~* C4、重写tostring、equals、hashcode三个方法

创建action
* f2 f, Q) _3 e5 [' G5 J" \
6 N3 `3 k- s0 r+ m1、写一个类继承Action

' d; x- w* M, ~& ]: d2、实现一个公有的方法（回调方法）
; B) [7 s" _! e6 @, r# K) n
public ActionForward execute(ActionMapping mapping,

" k7 h7 d$ @% R; C  `$ IActionForm form,
% j6 L9 q) E6 H
HttpServletRequest request,

HttpServletResponse response)

7 @3 k! J6 l8 X0 H: X8 S( n6 S6 C, ~{
1 W2 M5 {, @4 t
//1.收集参数
1 L/ b2 q$ Y) ?7 b: E$ z
MyActionForm myForm = (MyActionForm)form;
) u/ y1 d" A$ W2 N& U: X3 T
& T/ J" M/ @  o# M4 K0 F//2.组织参数

* ^' Y7 _+ L) \8 P. W

. G, P# B1 p+ V5 E//3.调用逻辑层

1 {# ~# j1 u8 }( y4 t* xboolean flag = true;
* u3 l. }3 T7 P/ F2 ]1 q: B4 Z
//4.根据返回值来跳转到相应的页面
$ T" N8 o% ]; P- [8 j, o3 z
ActionForward af = new ActionForward();

1 V: K- k: ^& k, s  U, x: d9 Qif(flag){
8 @. G/ }8 U! u- _, J4 d
0 b& x8 S- o$ Paf = mapping.findForward(“1″);

/ P. t* A3 P, B% R% m}else{

6 p3 L3 N' P8 F9 r; ?/ Waf = mapping.findForward(“2″);
! E; y( L6 Y4 [
; z. f* ]9 a8 n5 ~, ?# c) j}

8 p7 s5 |5 q& D1 q2 M. @* B7 {return af;

}

配置struts-config.xml文件
! d2 W1 T$ M# A! M' Q
1.<form-beans>
  i- b. ^- z$ \( h1 Z3 ^$ w
% V6 F; @2 W4 U8 |+ f2 a7 Z$ L<form-bean name=”myActionForm” type=”全路径.MyActionForm”/>

<form-bean />
. E6 d, \5 R/ p7 _
, `! z! q! X3 m2 k7 n</form-beans>

0 J% B, P6 v" v0 w3 M" |. M2.<action-mappings>

- N1 s# F- c$ d" w8 u- `* P<action path=”/sll”

1 Q/ v+ I! D! |0 U( f% Z8 T$ L; Uname=”myActionForm”
! W# i3 [& M; {9 R: m5 d
type=”全路径.MyAction”

scope=”session”

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

<forward name=”1″ path=”/1.jsp”>

4 G0 n& C% ]  R/ B8 B<forward name=”2″ path=”/2.jsp”>

) J- P# ]( |' ~' l% ^+ S4 u# D</action>

</action-mappings>
; g& K& N7 f3 M0 M' J
步骤:

1.创建一个空的web应用
& a9 X* \, k- u+ i4 e; {- Z
. e9 H- Q6 r' u2 p2 g! B  Z2.将struts的包放到lib文件夹下
9 S9 K. q  C) V  t' h4 i
' L  Y8 R# v5 H+ I! u3.将.tld文件文件和struts-config.xml、web.xml放到WEB-INF的跟目录下

4.配置struts-config.xml文件和web.xml文件

5.在页面引入tag文件uri
/ z+ |' {- t7 f% I
- y0 {! p, L) X4 X  S; FSTRUTS运行机制
& a, x  x" Z: _# `
1、界面点击产生请求
: f! r/ N! v+ ?2 u. }
+ U5 h% A) A/ p7 v, ?  ?2、容器接到请求
/ n( S5 _: ?; L3 g4 `$ ^
3、匹配web.xml文件中的*.do来调用ActionServlet
  B, b5 {6 v- {* @4 o" J
4、ActionServlet的处理
5 k1 X- A+ B  o+ \; {
, f! Q8 R7 ]5 _1 Q% g; [4.1 读struts-congfig.xml文件形成ActionMapping

( |% }! G; ?9 Z4 @+ ^& O4.2 通过path 来匹配Action类，通过Action的name属性来匹配ActionForm类
0 T; Y' Z* ~* y6 ^5 [5 x4 a. C
4.3 通过反射机制来给Form添数据
; X; M  v. |7 y: Z3 t" |2 e
5 ~1 x: _% D& Q5 n4.4 由ActionServlet转调Action的execute方法
5 @4 Z, N6 x, I' {" Q% |% T# R
4.5 得到execute方法的返回值，跳转页面
& x1 C, g# j* i8 ^$ U( c2 l
! a  I0 K$ r1 q: L/ U$ D& y/ K4.5.1 RequestDispatcher

2 [( m5 b0 z+ X( u& O4.5.2 response.sendRedirect(“list.jsp”);
  d* d! J' d2 V

; t! l; _7 C- C+ M
进入execute方法

/ l6 Q; J& o: C0 m1 收集参数

- D$ s9 y- p0 j4 X( H" L( _! Q2 组织参数
, T3 i# X/ ]$ m. H$ Q1 L: _
3 调用，逻辑层

  u% K4 ^! B: B) U  |3 D0 y4 返回值

4.1 选择下一个页面 （ActionForward）
( i5 T( G3 u! q2 I# w6 x6 {
4.2 把值传给下一个页面
7 N+ b& t+ p5 L' U7 s3 D3 ~  U


比较struts和struts2的不同

Struts

Struts2

. _( ^2 Q6 K8 a, s) [- U6 C! Y' W组成        五个部分：ActionServlet，ActionMapping，AtcionForward，ActionForm，Action        十个部分：AcionContext，FilterDispatcher，ActionMapper，ActionProxy，Configuration Manager，Action Invocation，Interceptot，Action，Result，Taglib
url        .do        .action
分发控制        AtcionServlet        FilterDispatcher
收集参数        利用JavaBean技术，将数据封装到ActionForm的子类中；
3 g8 H! v! e4 l8 L& x5 s一个Action对应一个ActionForm的子类

使用拦截器将数据封装到值栈中。
使用域模型，一个Action对应多个值栈中的Model

; V( B3 _4 s0 s% B读取配置文件        ActionMapping        Configuration Manager
拦截器        无拦截器        执行Action前后有拦截器
返回页面        将字符串封装到AtcionForward，进行跳转页面        Action中直接返回字符串，通过Result跳转页面
页面跳转方式        两种：dispatch，redirect        三种：dispatch，redirect，chain
- w! {% x* \; Z# w, M  J$ c: S值栈        无值栈，Action通过在request范围内设置属性，向jsp页面传递数据        有值栈，Action和jsp页面通过值栈传递数据，jsp页面通过OGNL取得值栈中的数据
配置文件        struts-config.xml        struts.xml
中文问题        不能解决（需要使用filter）        可以解决中文问题：
1、在jsp页面添加Meta；

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

admin

其他开发工具和技术
Ant
Ant是基于java的批处理工具
& n: E7 F% r3 \/ V
一、配置ant的运行环境
' ^1 X: a  E3 J' p0 I' I
1.将ant的bin目录添加到path中
/ w+ [9 r' ^2 }/ Y" V; Z7 f% ~
2.配置JAVA_HOME
2 c8 [$ B0 I$ F0 k9 O! \4 G7 ^# H
+ H) H# l; C. E" `- V" F% K3.配置ANT_HOME
7 M( M# @% O; I
二、配制build.xml文件，该文件放在应用程序的根目录下
5 C3 p+ F* {5 c# Z
( q( F. h# a5 F4 q7 B0 x" o8 B编译java文件

/ W; h3 i& J9 D执行java文件
' l, V, M) N( b) d3 {
copy

删除
; A1 ]# a( b% a8 U% r
6 e2 }! a; |- Y3 r打jar包
5 j* u& `1 j3 F: Q. [0 c
' v8 b/ x2 Y3 T根据注解生成配置文件

. R7 I/ @* Y- z2 T* @Xdoclet
通过注释生成一系列文件的工具（txt、xml、java、html等）
6 c- H, y! A- C$ I5 W1 N
xdoclet本质是摸板技术+字符串的替换

1.在java文件中写符合要求的注释（将hbm.xml文件的内容搬到java文件中去写）

1.1 在类的上面 写与表的对应
% H7 K' Z: W5 T: N9 J! L
' V0 b, E. Z& ?/ x7 O1.2 将每一个属性的注释都写到get方法的上面
7 X$ p' S, m. G7 t9 A  l$ c/ [
2.在ant中引入相应的task来驱动xdoclet
' `- \- H# e% b+ S7 `6 L
% E9 K4 u. F9 H. O4 n: Q
# p  a; v4 [. Y: l# y: u
log4j日志管理
1、是什么？

) [6 y9 y1 I1 K6 O. g0 a在开发期间用来测试、对整个日志信息进行管理的工具

2、功能

1.控制输出的目的地

2. 控制输出的格式
; M! {2 a; R# Q6 d$ a( V
' ~. s+ f) y& {' P3 r  l/ ~$ M3. 控制输出的级别

" W8 y2 ~2 O* [7 [- C6 f3、日志的级别

% [' u% a2 z* e3 {6 q1. debug 调试

2. info 给用户的提示信息
2 ^0 A' c; q1 u) Y2 Q
3. warn 给用户的警告信息

4.error 给程序员用来调试

Debug—-〉info—-〉warn——–〉error

* K1 w! G; W7 x, `* t4、配置

7 _5 C6 z! t6 K( b' e7 z* a8 B1.配置级别

$ h9 I( a$ y! A0 d- [7 ^$ D2.输入源 （控制台和文件）

3.可以进行分包控制

Log4f.logger.包结构 = 级别
+ N2 \6 a5 w' L- f% F( y+ ?
) V5 T: o3 m+ C( ?$ I0 i- ^5、使用
$ w6 v! {! S2 j$ }) }  A3 v# ^  ?
' i7 m6 N% c7 d! T% \- }3 b7 vLogger log=Logger.getLogger(Test.class);
0 F1 Y: n- D9 A, k8 L9 U2 l
; B8 X) z# ^0 y4 w) w% }    public
void t3(){
1 ~1 G( i& \# z4 M3 O* E
! [: V. a5 z. [6 e+ t5 s. A        log.debug(“this is debug”);

  M* h3 J( H- c5 o2 B        log.info(“this is info”);
+ T( v' t/ n! f
( N4 X$ m4 d5 ~( g- l9 n  b        log.warn(“this is warn “);
+ r9 x7 u5 N7 y1 i
2 x# b# d1 ^8 x) n) Y        log.error(“this is error”);

& Y: C2 v2 I( H" h    }

Junit
1.是什么？

单元测试的框架

2.怎么做？

* e6 |$ O" U2 [: Q& |, M+ w1 G写一个类继承TestCase
' ^: J) E& N# N9 E
测试的方法一般都以test开头并且没有参数
; P( I$ e- g  u
在测试方法前执行的方法public void setUp( )
8 p7 i: j! S& B# V6 ]3 }# A* S9 w: n
2 G. e" r6 B1 ^% U5 d9 i( m在测试方法后执行的方法public void tearDown( )

error和故障的区别
/ `3 I0 p7 H1 d8 K9 }$ {0 W
error ：代码有问题

故障 ：逻辑有问题与祈望的值不相符合
5 Q" Q, c& T! n* S
生命周期
4 {6 o. R& d; k
# [0 b$ z% t# w" V+ |1 V0 ], ~测试—〉SetUp（）—〉testXX（）—〉tearDown（）—〉结束；

0 V4 m8 t" W. E- F$ aTestCase套件

public class MyTest{
+ M% T* l) r- a. O* m
        Public static Test suite(){

TestSuite suite = new TestSuite();
) m/ [9 K  O( Q  q2 f  w
suite.addTestCase(Test1.class);

suite.addTestCase(Test2.class);

}

' t7 x# G1 U3 {4 F& F}
+ U0 W# }& r; _, y9 X
- \& I& v* D1 o$ s- A" o$ V

0 r6 O& J: ]& j6 b# N1 AAjax
是什么？
AJAX即“Asynchronous JavaScript and XML”（异步JavaScript和XML)。是一种创建交互式网页应用的网页开发技术。
5 u0 z3 Q) M5 M
无刷新页面。

9 S) q) ]! E+ ^; L6 b; y有什么？
& o/ r3 R* g7 J5 O, oAJAX是多种技术的综合，包括JavaScript、XHTML和CSS、DOM、XML 和 XSLT、XMLHttpRequest。

) _0 {% Z  B1 ]* T8 Z能干什么？
使用XHTML+CSS标准化呈现；
使用DOM进行动态显示及交互；
  ^' Q9 v$ v3 f. I+ m使用 XML 和 XSLT 进行数据交换及相关操作；
. W: |3 V9 x, V8 c5 X使用 XMLHttpRequest 进行异步数据查询、检索；
5 C% w2 a: |# m使用JavaScript绑定和处理有所得数据；

传统的web应用允许用户填写表单(form)，当提交表单时就向web服务器发送一个请求。服务器接收并处理传来的表单，然後返回一个新的网页。这个做法浪费了许多带宽，因为在前後两个页面中的大部分HTML代码往往是相同的。由于每次应用的交互都需要向服务器发送请求，应用的响应时间就依赖于服务器的响应时间。这导致了用户界面的响应比本地应用慢得多。

( m* ?& C% H8 P& @' l$ p. G- W- B与此不同，AJAX应用可以仅向服务器发送并取回必需的数据，它使用SOAP或其它一些基于XML的web service接口，并在客户端采用JavaScript处理来自服务器的响应。因为在服务器和浏览器之间交换的数据大量减少，结果我们就能看到响应更快的应用。同时很多的处理工作可以在发出请求的客户端机器上完成，所以Web服务器的处理时间也减少了。
, i1 R0 a2 C0 a- I7 ~
使用Ajax的最大优点，就是能在不更新整个页面的前提下维护数据。这使得Web应用程序更为迅捷地回应用户动作，并避免了在网络上发送那些没有改变过的信息。

# l' g, B4 i  n! R对应用Ajax最主要的批评就是：
6 x0 P( Q$ Q8 x1 v9 @* n+ _1 它破坏了浏览器后退按钮的正常行为，就是用户点击后退按钮后不能看到之前的数据；
2 一些手持设备（如手机、PDA等）现在还不能很好的支持Ajax；
3 用JavaScript作的Ajax引擎，JavaScript的兼容性和DeBug都是让人头痛的事；
4 Ajax的无刷新重载，由于页面的变化没有刷新重载那么明显，所以容易给用户带来困扰――用户不太清楚现在的数据是新的还是已经更新过的；现有的解决有：在相关位置提示、数据更新的区域设计得比较明显、数据更新后给用户提示等;

怎么做？
<script language=”javascript”>
. T3 q! b; p, g% f3 `# Y- E; {
  E% z& _- \$ L9 c: z& evar req;
# ]; d  e' D. S
function add(){
0 G$ F0 S- Z2 Y) m  S* @) C" @
* _4 k( P/ i1 ?) w//1:创建用于传输的对象

req=new ActiveXObject(“Microsoft.XMLHTTP”);

' }1 Z( u7 L* |4 k4 _. j# K// 声明返回后，处理数据的方法

req.onreadystatechange=manage;
2 q4 F% `( w7 V" V0 V6 M5 y
, i( {! E' V, l( F1 i5 P//2:准备传输的内容

0 e; e) i3 d! C5 q/ \var str=”test1111″;
" c1 X$ u; Q: J* j
//3:发出请求
8 a/ i  x" x) h, e; ]
req.open(“GET” ,”/others/ajax/test/t2.jsp?str=”+str);
: y1 i: ?# p3 e3 H; v/ I+ i& p& J) F
$ j" e5 y2 `, V5 W- |, X' }/ sreq.send(null);

}

( _/ s: `* B- T5 _, A9 @( D//4:接受返回并处理
2 X( @" D$ q; ?, o
function manage(){

if(req.readyState==4){
  T! Q( v$ w, _( W# S; `& X, D
2 D( O% f) e2 p( g) G: g6 Y2 ualert(“r==”+req.responseText);

% J1 \' R- z- l/ l, t- g1 f: O}
1 \$ T4 r  `- ]' F7 r6 ~# r& t" n
}
2 l/ A# ~$ H! V- F, B, M  ?. J: J
4 z( h* d$ B# D# @</script>

readyState的取值如下：

* @) _7 k" X* R( @! D# T　　0 (未初始化)
. x9 x. b7 ?, @$ x: d+ n
/ O3 k3 Z( R3 K3 T　　1 (正在装载)
% V; W9 z% y+ j2 A" l& k
　　2 (装载完毕)

4 S  J( z9 u, {9 f　　3 (交互中)

　　4 (完成)



原理
Ajax的原理简单来说通过XmlHttpRequest对象来向服务器发异步请求，从服务器获得数据，可以是xml格式，也可以是一个字符串，然后用javascript来操作DOM而更新页面。

Dwr
是什么？
DWR（Direct Web Remoting）是一个开源的类库，可以帮助开发人员开发包含AJAX技术的页面。它可以允许在页面中使用运行在WEB服务器上的JAVA函数,被调用的JAVA函数就像是在页面中JavaScript方法一样。
/ T: Z# M/ w% S' B9 w- g, Z
有什么？
它包含两个主要的部分：允许JavaScript从WEB服务器上一个遵循了AJAX原则的Servlet中获取数据；另外一方面提供了一个JavaScript库可以帮助web开发人员轻松地利用获取的数据来动态改变网页的内容。

9 _% d; {: U# e6 l3 G( B

6 i7 B' r" h  ~0 f能干什么？
动态地把java类生成为JavaScript，感觉调用就像发生在浏览器端，实际上代码调用发生在服务器端，Dwr负责数据的传递和转换。这种从Java到JavaScript的远程调用功能的方式使DWR用起来有种非常像RMI或者SOAP的常规RPC机制。
* |2 ?& y: f/ d


怎么做？
+ `( S* F' \7 A# G6 b" a7 d' R① 编写配置文件
3 X* G, s6 {' e0 C
web.xml
: L  x* S8 X) @) ]8 d! H2 g
<servlet>
" l. g; T! @% B" h+ [: w6 V/ @
9 _% n) f9 V# e- ~1 |<servlet-name>dwr-invoker</servlet-name>

<servlet-class>
" [' X# C$ p  l/ h. W% _
org.directwebremoting.servlet.DwrServlet

) W% _3 N* N4 E" b+ P2 u</servlet-class>
: W9 b$ y  R1 b, I5 K5 T% d( R0 U2 A; E
<init-param>
! A7 W% q% U' N' b* e* D! ?. U
5 ~0 H: p1 \% K, H<param-name>debug</param-name>
4 k/ N  a5 E+ H) {% f
<param-value>true</param-value>

</init-param>
1 V0 E% w8 }% I+ u/ S  P" u
: a0 @" }( j/ a. V! R6 q7 b3 b</servlet>
) a, V. b" V/ k# ?4 }: _. r! k" n
<servlet-mapping>
0 O5 o$ o9 N0 d( v4 N
5 |$ G- l# {& T9 o<servlet-name>dwr-invoker</servlet-name>
- d2 y: X- h2 r1 O& ]1 M, W+ t
<url-pattern>/dwr/*</url-pattern>

2 {: b' M$ |/ Z0 A; k- N. X* L</servlet-mapping>
; W" ^! X# @8 }! d, ]- `
9 f4 z' n. G- B; r. o6 ?dwr.xml

7 @% q, o. Q. c+ H$ \  |<allow>
1 a: B9 |/ y9 Y6 w, E! d* ]2 m  m0 |
<create creator=”new” javascript=”kc2″>

<param name=”class” value=”dwr.Service” />

</create>
, Z9 A/ j' _2 ^& G2 Y" ]5 @
</allow>

9 ~; M) B: M( x( _②编写service
+ E& Q2 v% F0 B1 [  R. a$ ^1 R
- j6 O2 ^4 j7 R( F+ S  bpublic class Service {

3 k. g2 `9 E! Y2 T7 \& G% n4 m. R- Z% F! bpublic String sayHello(String yourName) {

6 j. R. O: L% t3 A  L//可以是访问数据库的复杂代码
' b/ `/ `2 i3 W2 N% M7 s& i
; l+ @3 ]) t/ U1 }5 Y) h' ireturn “Hello World ” + yourName;

}
+ n# T3 F$ @1 ^1 k6 K) K
9 R$ ?0 u; ?, h$ A}
& {, U1 K& R+ _" a7 S
③测试DWR

  |( F. n; N" C9 S0 B) \, e, ?将代码放入应用服务器（比如Tomcat），启动。
4 S8 j9 D1 q7 ]0 [3 D
$ p: m6 r/ M5 I4 ]# q: M: n$ w# q& L然后在地址栏输入http://localhost:8080/你的工程/dwr

④编写jsp页面
5 e* q, [9 o3 X' ^9 c6 c
1） 要引用3个dwr的js，其中engine.js必须要，如果需要用到dwr提供的一些方便的工具要引用util.js
. C! d, @! t2 @+ N$ Q
2） 然后还要引用dwr自动生成的js，dwr/interface/service.js，注意js名字要和dwr.xml配置的一样

- w7 ?4 F1 {+ M( ~) S2 h3） js里的service.sayHello和java类的那个有一点区别，多了一个参数，用来得到返回的数据