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

admin

JEE
简述JEE
, u; r$ A  _! E1 O/ W* {JEE　： JAVA　 PLATFORM　 ENTERPRISE　 EDITION

JEE是一个规范集；
) g" N+ y; v/ a, P! S9 o. H! s: x
JEE是一个框架集；
- g3 J0 Q; f9 i, M  z
; Q' e# T5 J/ J0 J# g# ^" RJEE是一个技术集或API集；

适用于创建服务器端的大型的软件服务系统
! M) x/ ~  {7 t9 b% \0 z# C+ q
' h& m% _+ A9 D- [5 X
0 \8 v1 ^" I$ m# v
( e* T& \9 a# V5 \- @- Y& j- xC/S B/S 模式
+ D, d9 v& ]* C; E- ^* jC/S client/server即客户机/服务器模式，客户端也参与程序的运行与计算（富客户端、胖客户端）
0 V, V, m0 z7 z* f2 E
4 ~$ O' g/ }3 u; ~( a3 ]' U8 qB/S border/server即浏览器/服务器模式，又称为瘦客户端，客户端不参与程序的运行与计算

" r, r7 L1 O' K4 K0 E+ z
6 s# ^  S0 C. t' n6 Q0 j7 F- C  L* K( ?
; U( E0 C" f7 g企业级应用（大规模的应用）的特点
" e/ H# r$ n/ Q' O1 F; r# p1.生命周期长、稳定、可靠
, _  Y9 F2 M* @# S& w' m4 ^
2.组件往往分布在异构的环境中，能够跨平台
% c  V, r+ `0 [5 l8 Y# I  V3 E
3.维护性、扩展性、重用性

4.有事务、安全、线程

- Q6 R* U& s+ [& H

什么是业务逻辑？
依照业务逻辑划分模块，
- l$ k3 k  g, Q5 I3 U  l! |' \: D1 f
0 p) e4 E. Q) B' J$ C6 e) h5 x& o所谓判定业务　就是具有以下特征：
7 T* o3 m& X( ^5 t3 a! O
: j9 {6 T. r2 g% ^; y1.业务流程
; R& A/ y% _( i3 y7 b
2.业务判断
" y, \& G8 c/ A5 r3 q
' \# s9 B! o9 J+ L- |1 K3.功能组合
- m5 H5 X( z) }; V4 }

8 U7 k0 }( K+ Y5 A
# p% k2 c0 e$ d# B+ [* Q) o平台（角色）的划分
. X% b0 |8 W) A' ]  l, K1.平台供应商。提供满足API集实现的厂商（BEA weblogic IBM webshphere）
+ ^8 g, s( e( \& X+ z6 u3 A
2.组件供应商
7 |/ _5 O4 v6 r/ O0 U( v( P
3.组件装配人员

8 P* g8 m7 e7 _. J1 e; y4.部署人员
) V/ r5 j; y6 B  z$ t
5.系统管理人员

6.工具供应商 提供开发组件所使用的工具（Jbuilder、eclipse）
1 \1 ~7 R% b- D5 F4 |
( o2 t% l' ?+ B8 V! K' f$ y! I- E

/ q8 V% u: V+ f, w' F! V. t  R4 zjava技术分布（设计架构 模块内部设计）
( J  N3 r" c: B: B- [- H1.表现层 Servlet、 Jsp、 JavaBean、 Taglib

, p$ \9 P: l% A4 S! q$ u7 X8 l2.逻辑层 EJB(SessionBean)

3.数据层 （　JDBC 　EJB（EntityBean））
( k/ |* z4 L: G; R- F, c% X
" \9 t3 @2 W. j" L6 q1 j# t/ G4.服务 JTA（JAVA事务架构） JTS（JAVA事务服务） JAAS（JAVA授权与验证服务）

" [. C; c; ?8 y8 b! o4 _; Z$ c5.分布式通讯 RMI（IIOP）+JNDI 、JAXP（JAVA 的 XML 架构）
7 e8 b$ Z  B5 V' H9 N# l$ [
JAVAMAIL（邮件服务）、JMS（消息服务）、IDLC、JCA（JAVA连接器框架 （成））
) r; d8 |6 K$ C- M2 n2 N3 X3 G
/ M' k5 ^$ N' v' K, G7 N/ U2 Q8 v: [
! J! [# s6 N" O/ p* t
$ c# A% D8 p7 f# N, B+ Z" N- ZJEE的体系结构： 是一种组件的体系结构
1.组件 ： 能够完成一定功能的封状体（独立的功能的集合）
1 o) D$ S6 z! k; ~; f; G
* F. i( |+ }# d! ], V不能单独运行，必须运行在容器上
. q3 X- w. b# D  ]9 ?( }2 c
- o' }6 i9 I/ Z1 D. p分为两类：web组件、ejb组件

4 H6 }8 ?; b4 T) @2.容器 ： 提供组件的运行环境，并对组件进行管理（一段程序）

7 q; _$ I7 O8 o- I0 |7 `2 A管理组件的生命周期
  [9 g4 Z4 m; G* W/ d
不能单独运行，必须运行在服务器上

程序（组件）通过上下文来调用容器（context）
/ K" {% @2 V: B" d" L
: `4 n& a! t# O; @0 b组件通过web.xml向容器描述自己，使容器能够认识组件

容器通过回调方法来调用组件

分为两类：web容器、ejb容器

3.服务器 ： 提供容器的运行环境，提供大量的JEE基础服务
9 K( }2 w9 _; t" }% u( B
  d" Q& g9 o$ cweb服务器（只提供web服务）

jee服务器（提供web、jee服务）

" P  E) G( I7 `. A$ V4 |

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

4 k# H5 j& Y6 \: ^7 m1 D5 Z

& N  u' ]9 S. q0 T5 U5 ?6 _, eＲＭＩ远程方法的调用机制
$ M5 k9 W/ l! y0 P$ q例如：Ａ主机有Ｂ（）方法，Ｃ主机有Ｄ（）方法，Ａ　想调用Ｃ主机的Ｄ方法


0 A7 a3 r# D: p7 F  W% f+ m/ ~3 P
+ r9 Q/ R+ @3 ]9 P. \9 @  J" m! r
& \' E5 e5 p7 Y. O; n5 ?
学习方法
9 y( Y$ r4 V0 D" A, R7 U7 G1.规范（熟记） 2.熟悉API 3.多练 4.多想

admin

Servlet

•     描述war包、jar包、ear包的结构
  ; E6 K) V. P* I* E+ I
  ( Z) }8 ~# `  t! k5 F" i- }; b3 \9 `
  

war-                            web文档压缩包

—WEB-INF

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

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

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

jar-                             java文件压缩包

—META-INF

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

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

–META-INF

—Application.xml 配置文件

–*.war

–*.jar

• 什么是servlet？servlet主要做什么？
  1 K; h/ \$ V  E- }
  
  2 {% Z+ J; D+ ^. |! @( P

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

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

8 X2 `2 C2 q9 f# x

• servlet 与cgi相比的优点？servlet的缺点
  0 J( R6 K& C0 u- c
  3 Y# Z: Q* r; W3 N; {' W) D
  % T* \/ Y4 d. F( q6 b. u$ I

优点：

性能（线程比进程更快）

可伸缩

Java强健且面向对象

Java平台独立

缺点：

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

• 常用的servlet包的名称是？
  
  
  % G; s! h# u0 f7 v

javax.servlet

javax.servlet.http

4 w8 ~/ _% n# w, j5 P/ k( b

• 描述servlet接口的层次结构？
  ) J$ M0 ~$ f$ N  [! N
  1 d! L0 `" n- w' b+ T
  

Servlet

–GenericServlet

–HttpServlet

–自己的servlet

ServletRequest

–HttpServletRequest

ServletResponse

–HttpServletResponse

• 对比get方法和post方法？
  
  
  

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

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

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

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

• 归类描述HttpServletRequest接口都完成那些功能
  & f6 @5 B+ R& W
  
  
  • 读取HTTP头标
    7 a$ i, J6 a4 r% O' p! o
  • 读取cookie
    
  • 读取路径信息
    ) m' E- ]4 u- i  h
  • 标识HTTP会话。
    
    

) l6 k6 ~3 {" \7 l" a

• 归类描述HttpServletResponse接口都完成那些功能
  
  1 O7 Y9 |7 O% g7 }1 \2 S
  & f! [9 i) Y' V& w
  • 设置HTTP头标
    
  • 设置cookie
    
  • 设定响应的content类型
    
  • 输出返回数据
    
    9 |. t# b# l2 X* J7 ^4 N( [# b

• 描述service方法所完成的基本功能？默认是在那里实现的？
  " z# H9 f7 F" g+ |! x2 g/ }# ?
  
  

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

实现：默认在HttpServlet类中实现

; A1 f* v' S! Q1 S/ [" s1 G

• 如何开发自己的Servlet？描述应该做的步骤和每步需要完成的工作
  " T3 `6 Q- W9 ^* |5 E
  + B6 z7 F1 U' S
  

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

" z# {* P: R* ]* t

• 为何servlet需要部署描述？
  
  
  

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

• Servlet基本的描述应该是？请写出来
  
  1 D* x3 k# x. R! f: J; t$ u7 d) G+ {
  5 i. ?/ s" c  o& ?3 l! F- k4 F

% K# \* d3 H: ~' ^- s6 P7 ?

<servlet>

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

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

</servlet>

<servlet-mapping>

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

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

</servlet-mapping>

• 如何在html中使用servlet
  . U: P6 B" w7 |. U$ z5 j
  & [  q3 i; y& Y: [; E3 {. W
  ( C/ C/ ]" W4 B; T# B( W: I

FORM标记

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

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

语法：

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

{HTML form tags and other HTML content}

</FORM>

• 如何接受request中的参数
  
  # ]+ L3 P, x# K* {1 {7 _String userName = request.getParameter(“userName”)方法
  
  

• 如何接受request中header的值
  
  
  / j% R0 V3 J+ `

request.getHeader(name);

request.getIntHeader(name);

request.getDateHeader(name);

request.getHeaderNames();

• 如何输出html
  
  
  : e4 V- ~2 @1 Y1 z3 ?; _4 m

PrintWriter pw = response.getWriter();

pw.write(“<html>”);

pw.write(“Hello”);

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

• 如何设置输出的contentType
  
  $ P: u8 f4 u8 c3 t  |' c
  

response.setContentType(“text/html”)

• 描述servlet的生命周期？
  
  
  

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

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

6 ~4 Y/ H2 z7 c7 F% ~  b

• 描述init,service,destroy方法的功能和特点
  
    H- |& h5 V, y$ E8 z
  8 k8 k" T' ?1 K6 G! L. N; h

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

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

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

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

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

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

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

7 R! R: o1 C; g( x- i, z

• 什么是回调方法？有什么特点？
  
  
  

由容器来调用程序的方法

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

• 如何设置初始化servlet的参数？
  
  在<servlet>中添加如下配置
  ; v9 W8 [6 y) X2 Y& _7 Y+ ^
  

<init-param>

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

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

</init-param>

• 如何获取servlet初始化的参数
  $ c2 s) r7 r0 n4 \3 p7 H) y7 D
  2 z* @- G! Q) T# Z
  

public void init() {

greetingText = getInitParameter(“greetingText”);

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

}

, z0 P% `& p8 H6 p4 {5 p) U2 U

• ServletConfig接口默认实在那里实现的
  
  4 T% M1 x$ w- b% \$ y
  " Q' t# t: v9 I* K+ W

GenericServlet类实现ServletConfig接口

4 k! Q5 C$ Z* g$ ^5 x6 o+ X! |

• 什么是ServletContext？有什么作用？
  " P) g( c. p4 G$ r, ^7 g% t1 n
  
  

Servlet上下文

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

• 如何访问ServletContext接口？是在那里实现的？
  
  0 T3 P& j  q4 K1 o6 J9 T
  % z% n6 O  |# `. {; [4 I. s* g

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

GenericServlet类实现了ServletContext接口。

7 e4 o6 a, L# F5 a. V6 m0 q

• ServletContext接口的功能包括？分别用代码示例
  ' @2 u, O1 C+ n  b
  
  

只读初始化参数：     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的参数？
  
  
  ; E  a- A  L# n! O2 r# D. u

<context-param>

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

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

</context-param>

. v3 l: @) A& f6 N. c0 f# j

• 如何获取ServletContext设置的参数值？
  " M; ?$ j+ \7 }" n3 s
  ( B; u" E1 h$ ^  x
  0 p( y$ U& @% x, {8 J2 k

ServletContext context = this.getServletContext();

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

2 ?2 @# X3 V3 p6 h  P! B

• 描述Web应用的生命周期？
  0 L3 U) `% ]) @- O  G7 {- D) }6 G8 G
  4 t5 y+ k! P* q6 D
  

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

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

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

• 如何用代码实现监控Web应用的生命周期？
  
  1 e+ l6 _; a3 y7 `$ j' W. Z1 t3 |
  4 A; I" K* Z! }
  

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
  
  
  400 Bad Request//错误请求
  401 Unauthorized//未被认可
  404 Not Found//没有创建
  500 Internal Server Error//服务器内部错误
  
  

• 描述Web应用中用声明方式来进行错误处理的两种方法
    u: Y8 D8 E3 ?5 ^( A1 D( m( h
  5 c- p% I0 ~7 o# b" S
  

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

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

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

• 描述记录异常日志的方法，都位于那些接口？
  . u- t7 c' q5 u
  
  , w. z9 n1 }( n3 ]  K

GenericServlet：

log(message:String)

log(message:String, Throwable:excp)

ServletContext：

log(message:String)

        log(message:String, excp:Throwable)

• 什么是会话？
  1 a  j. J- O) p' P. T
  
  

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

• 如何获得会话？
  $ q" o& G/ `! l- t. Z
  5 z4 g7 q- s& u) E9 P8 I& F
  HttpSession session = request.getSesseion( );
  
  

• 会话Api的基本功能？
  
  7 k0 {! z9 \  m) }
  ) A2 L) R4 K8 g& ~. @

getID() :String
- A, [- w1 c+ p* w. C

    isNew() :boolean
6 w6 }" ~- _+ r, y4 ]' }3 Q

    getAttribute(name):Object

    setAttribute(name,value)

    removeAttribute(name)

: A/ I% @* B& V) k. w

• 如何销毁会话？
  
  
  

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

<session-config>
0 I3 i- w- |( `  Z# r6 k, P' \+ r

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

     </session-config>

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

invalidate()

     getCreationTime() :long

    getLastAccessedTime() :long
+ H( q) k, p  N0 j

    getMaxInactiveInterval() :int

     setMaxInactiveInterval(int)

• 描述会话保持状态的基本原理
  
  " K1 A) M/ V1 I' |3 Q+ G$ g  J' d
  

- T$ s! z# f! F: D+ r. z( H

    client server

  b( {( a% p4 {1 t1 E6 w

request
4 U. e7 i: {8 A, E

response (sessionid)

request (cookies)

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

% t7 L6 U4 e8 Q3 c8 ?

• 请描述session和cookie的异同之处
  
  : l- G6 i5 t$ u) h' @7 K1 V/ M
  

: C& z  O6 ~" r. ]
3 F: f( E' ]+ m( c9 S9 Z

• 如何读写cookie，代码示例
  : e3 c3 d5 C3 y0 o' ^, |$ t
  ) Z/ F4 Y2 u" S# u) M/ l
  

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

response.addCookie(c);

读：Cookie[] cookies = request.getCookies();

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

            String key =cookies.getName();
) Y( }- Q+ O0 I. q' p

String value = cookies.getValue();
3 U; f& n; Q# v8 b

System.out.println(“cook”+i+“:key=”+key+“,value=”+value);
1 M! v! d/ i* j( ^' f5 Z) ~

     }

1 x2 h* @" T0 V3 h$ \# s9 T

• 什么是URL重写，如何实现，代码示例
  
  
  ! D! c9 m6 S* _6 I0 I% R

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

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

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

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

, Q- z, G& K* Y9 ]

• 描述web应用的4种认证技术
  $ T% m5 Y& b: E
  + d0 ^, U! L/ K0 ~9 W! L
  

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

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

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

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

• 什么是授权，什么是验证？
  : A: Q9 l/ f* E3 g  D' ]) g: Q
  
  

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

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

• 什么是HTTPS
  
  3 }! x( E3 y" Q0 p: v1 u  y
  

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

. t3 D, m; ?& ]" o7 z0 S

• 什么是审计？
  
  ) z7 V* ~1 R2 f+ J: N, N. p
  

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

• 如何实现声明性授权
  ( q4 ~& y, G# {' G7 o3 g; L9 G9 v
  
  

1、标识web资源集

2、标识角色

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

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

在 web.xml里配

• 描述servlet并发问题？
  
  
  1 w. f# U. J# o1 l) B" y4 \

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

• 描述Web应用中的六种属性范围
  
  
  2 J, U6 X1 }7 |3 c

局部变量（页面范围）

实例变量

类变量

请求属性（请求范围）

会话属性（会话范围）

上下文属性（应用范围）

+ F  {3 h3 W7 Q

• 指出上述六种哪些是线程安全的
  * K; @0 i. Q/ N& T
  
  8 y! z6 |; a8 ^' X5 n( ^

局部变量和请求属性

• 什么是STM？如何实现？
  
  4 ^  Z4 w* n0 x6 K' p- T. f
  7 {( p1 Q) G; f: v% ?) h

SingleThreadModel接口

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

9 S1 v! I" i  G6 |+ Q' F& y

• 如何实现并发管理？
  
  % _" P2 N/ d& q1 j$ w7 }
  8 D- K6 Q+ \9 [- t1 j2 F

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

使用synchronized语法控制并发

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

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

admin

Jsp
+ o. E9 I+ j8 Z- e6 W什么是Jsp?
Java Server Page    结合java和html在服务端动态生成web页面的技术
6 S7 _! Z: |1 U! u
, s" o! j9 M# w& R+ r

描述Jsp页面的运行过程？
# a8 p3 C0 p2 |第一步：

2 A4 b+ f" q  \3 i& |' R+ r请求进入Web容器，将JSP页面翻译成Servlet代码
4 @! x/ C5 ~% l9 t* l
第二步：
, O- l% e7 ^: E$ j: v! m
编译Servlet代码，并将编译过的类文件装入Web容器（JVM）环境
: F6 H; ~: j0 N
2 ~! ^* a8 c8 d: e第三步：

4 |7 W/ Z, x+ m- M& O: ]( W" B2 |Web容器为JSP页面创建一个Servlet类实例，并执行jspInit方法
1 l. o7 z/ V) Q1 [% A
第四步：

Web容器为该JSP页面调用Servlet实例的_jspService方法；将结果发送给用户
3 `4 N8 d* [4 K9 {6 {* a( O# D

, R- t9 Z0 n0 F  t# q9 z
9 [& ], b0 i* @% a/ d5 R7 N+ @描述Jsp页面的五类脚本元素的功能、写法、并示例
/ @5 z/ d* ^, _2 O: B注释 <%– –%>
( u: i" f" j, k& B
; I! ~1 ]& S$ F3 @5 w<HTML>

6 J; g2 e  L- _% [5 h9 ^<%– scripting element –%>

6 @/ _; H2 d/ H; {</HTML>

指令标记 <%@ %> 指令标记影响JSP页面的翻译阶段
( y) G% l! U8 d5 f, t3 t
2 L' [/ ^( `- D! \% v<%@ page session=”false” %>

& k: k9 M2 F0 P8 H声明标记 <%! %> 声明标记允许JSP页面开发人员包含类级声明

+ j2 z' o' E8 K<%! public static final String DEFAULT_NAME = “World”; %>
( B0 d" ^8 q3 q0 K3 j
    脚本标记 <% %> 脚本标记允许JSP页面开发人员在_jspService方法中包含任意的Java代码

; Z( E* r: G  T' w$ K% m: i; ^    <% int i = 0; %>

, S+ k. h  l, ?! ^, A# h表达式标记 <%= %> 表达式标记封装Java运行时的表达式，其值被送至HTTP响应流 <B>Ten is <%= (2 * 5) %></B>

6 y+ x2 k/ [' [
& K8 i, S( W- V' z) r
描述Jsp页面中的注释种类和写法
8 o1 C! S) ~) r( `  U& ^: J9 z! cHTML注释
) X0 k* ]9 P) q% ]: R
<!– HTML注释显示在响应中 –>

JSP页面注释

<%– JSP注释只在JSP代码中可见，不显示在servlet代码或响应中。–%>
' F# R3 E" Z. W& n2 d0 I
7 D1 B. Y* {: u) U( N. pJava注释

2 e. O+ ~) n* [/ H, S' o6 e  O, P+ z3 Q<%
2 G8 E2 b+ a7 \/ n+ S4 u5 K; B. J
* K7 G+ s( {7 K* T' `; q# D# |1 i/* Java注释显示在servlet代码中，不显示在响应中
/ K( m1 ]" t+ w' I3 d- U+ l. X! a3 g
1 B% o' z, k- O$ r0 z' L. t*/

( O! f( b' T4 w/ k0 D; r; c%>
, v8 }6 @5 W0 }# @  e) B
9 ?3 \5 i6 w" m& e
+ u& A' ^! L: ]
描述Jsp页面的指令标记的功能、写法、并示例
3 W; w) u$ i( l) o4 A* D5 p3 B指令标记影响JSP页面的翻译阶段

<%@ page session=”false” %>

. |* X. h0 j; R<%@ include file=”incl/copyright.html” %>
+ y1 l/ @9 q- p8 [
<%@ taglib %>
3 _  Z7 I" F. a" K' v
+ y. V( K: T+ p; \
3 w5 d* O3 O+ h' q" P5 h
描述Jsp页面的声明标记的功能、写法、并示例
4 i+ B7 H0 ]- [6 c5 v" w  @声明标记允许JSP页面开发人员包含类级声明

5 |3 Y& O; {& c3 |写法：

<%! JavaClassDeclaration %>

例：
4 G: Z3 i- t1 a$ a& F5 d* B
9 P/ c* A  u0 T2 E$ c<%! public static final String DEFAULT_NAME = “World”; %>
  q9 }1 {/ x/ A8 k
<%! public String getName(HttpServletRequest request) {
7 W* X% ?0 i6 E5 A+ {/ w7 b( B, s
return request.getParameter(“name”);
% Z1 \: B) \6 _$ \: c
}
& w" \* U% z! K4 C
  J( a' V6 g# Y%>
6 C* d+ {1 D+ |' C, W" h% e7 k5 j! t
8 ]$ o3 J$ M1 o" p$ e0 K<%! int counter = 0; %>
6 a0 r3 A; F0 V4 E8 r/ x( C2 t
$ o8 @+ v; Y. k: {  ^

; M# i. Y/ h8 Z8 P& x描述Jsp页面翻译成Servlet的规则
jsp中的注释标记被翻译成Servlet类中的注释

+ Y; y* i0 p% ijsp中的指令标记被翻译成Servlet类中的import语句等
* d8 @; B4 A: j7 j$ F& \
; b! _' X3 p, X  Z6 A3 Djsp中的声明标记被翻译成Servlet类中的属性
& ?- I% E9 F! \0 n8 d: T
jsp中的脚本标记被转移到Servlet类中service方法中的代码

jsp中的表达式标记被翻译成Serlvet类中的write()或者print()方法括号中的代码
8 y: T% }- m' @5 w, S* a! j


. S: v8 j0 u* U描述Jsp页面的九个预定义变量的功能、用法、并示例
request 与请求相关的HttpServletRequest对象
6 D: @1 \( L; w+ h' h/ P  n
response 与送回浏览器的响应相关的HttpServletResponse对象

  \" n, t" z, w  O, i5 iout 与响应的输出流相关的JspWriter对象

& z7 j- j% M5 @8 r2 ]    session 与给定用户请求会话相关的HttpSession对象，该变量只在JSP页面参

与一个HTTP会话时有意义
. {0 ?0 X  U) I# o$ f
    application 用于Web应用的ServletContext对象

7 P: w3 A1 l( P0 r% P/ @- l. C2 Hconfig 与该JSP页面的servlet相关的ServletConfig对象
/ p: A% O7 b" I& ^+ }; ]
8 p) ?9 T) Y0 s5 {. CpageContext 该对象封装了一个JSP页面请求的环境
3 a3 j# D" o+ H7 e; \5 r
page 该变量与Java编程语言中的this变量等价

    exception 由其它JSP页面抛出的Throwable对象，该变量只在”JSP错误页面”中可用
+ f& {. l2 j) v/ {( S
: j; X. b5 Z% n. {, z7 g% R% X! _

page指令的功能，写法、并示例，并描述它的如下属性的功能和用法：import、session、buffer、errorPage、isErrorPage、ContentType、pageEncoding
import import 定义了一组servlet类定义必须导入的类和包，值是一个由

逗号分隔的完全类名或包的列表。
( I8 p& J* D$ F# o: ^; Y
session session 定义JSP页面是否参与HTTP会话，值可以为true（缺省）
- K) m: ]# r2 e: G0 Y5 u/ }
或false。

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

none或Nkb，缺省为8KB或更大。

" M4 I) h3 \% V$ G, S0 h! zerrorPage 用来指定由另一个jsp页面来处理所有该页面抛出的异常
& M$ c+ w, c, e0 l7 o
isErrorPage 定义JSP页面为其它JSP页面errorPage属性的目标，值为true或

0 d& j, T+ u  h  x" lfalse（缺省）。

ContentType 定义输出流的MIME类型，缺省为text/html。

" b8 g  ~3 w, ^pageEncoding 定义输出流的字符编码，缺省为ISO-8859-1
5 o  |3 M% P  V0 S4 F: w$ j

( E# B: Y+ G0 z2 a
. M# L+ b0 t. `  d1 \( J描述MVC各部分的功能？MVC的优点？MVC的缺点？
" b' _8 i6 ^7 v( I: k1 L$ c- ]MVC各部分的功能：
1 K, n; q% d; \, L2 |/ o: W
Model（模型表示企业数据和业务逻辑）

# J1 \1 \) m6 F: `8 N% S封装应用状态

- C# ?+ ^  n' ^# k2 u响应状态查询
9 v/ p' y+ \! t  N
暴露应用的功能
0 {7 Q4 b( G4 f2 \0 D% q
Controller（控制器接受用户的输入并调用模型和视图去完成用户的需求）
- g7 j& v* P4 g$ x& N; R
验证HTTP请求的数据
. Y* ~' k- f! G5 {3 _
将用户数据与模型的更新相映射

选择用于响应的视图

View（视图是用户看到并与之交互的界面）

# s) k+ W* N) J1 e, @产生HTML响应
" \& q7 ]9 f( ]3 ]. u
5 x. Y* _: L, \+ v9 \! d请求模型的更新
: z2 }& `+ b2 Z5 @( Y
( f0 y, P! }/ F# A; `提供HTML form用于用户请求
1 e3 c! M  H9 j+ s3 K2 D8 x
7 h3 i, l* r: b. A9 DMVC的优点：

1 E4 }+ t4 N, P        低耦合性：视图层和业务层分离
% z9 D: J3 X+ f5 [
: |1 _% }; a. m) _1 b6 x' m$ Y高重用性和可适用性
: L; {& K3 d9 c3 e5 c- V9 c6 X
4 L6 _2 L% M! W9 g8 E' y" L较低的生命周期成本

: q0 ^9 s+ l& O0 K: @$ o快速的部署

可维护性

) `: m7 m& r3 h/ z有利于软件工程化管理
" d8 r! l  c, P, q% w1 ~; U& W8 T
" j; `$ Q  i3 `8 `提高软件的健壮性
  X/ v/ f$ y1 b+ ~8 g% c- V! t
, i3 ?+ I1 v& [" z* X  S- V# RMVC的缺点：
7 G, z- p& c, Z. I9 t
# A, ]2 W6 w; N* m9 K, K' A2 Z" |        工作量大，增加工作的复杂性，MVC不适合小型甚至中等规模的应用程序



什么是Model 1结构，以及结构中各部分的功能
1 I$ h  s" Y0 W, Q3 a结构：jsp+javabean
' I! I) D2 E  a' t% ^
5 \' ?; x' s, M5 W( DModel1中使用jsp来处理web应用中的视图控制部分
6 w/ _+ M. C, U* F
- y, V* M7 \9 c# M2 S/ b3 T, `Javabean收集参数


8 L" K6 Y) W0 k4 d( Q# X
$ O) l- U1 A  y! {: y6 M; G: B什么是JavaBean?
, i( R+ R# s% X1 n# U用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。
( l5 q; h1 |: Y4 T
. A2 s" G) q4 d/ |  J

JavaBean的规则？
使用get和set方法定义属性

$ d* E) `* u1 s一个无参构造方法
5 x+ P) B0 v( \7 ?
- O, I7 D: G$ P5 m+ j2 S无public实例变量( 所有属性私有化)
" i9 V: D# c+ m' e- {, D: S' D6 \
9 ]) `7 p, T6 ~8 M

$ c8 c2 \" x6 \# L. F3 H) s4 ?/ \) k什么是jsp标准动作？包含那些？分别都是什么功能？如何使用？
JSP页面中使用类似于XML的标记表示运行时的动作
3 r, w, ]# B) ~( ?. j
% ?9 e' o6 G) D( }, o. h! ejsp:useBean

4 G6 }# h3 k& A5 @jsp:setProperty
4 v  Y8 J/ ^  m/ h  L( N( h5 g1 Y
& ?8 u) ?+ p; a: s1 b7 \' djsp:getProperty
& C# ?& ?# b- [5 r
jsp:param
/ E9 h: e8 N$ `6 j
jsp:include
% u& c6 T3 O7 h: K
jsp:forward
, z" ]& `* I7 f! h6 P* r


' Y* I  ~; j% a用代码示例如下标准动作的使用：useBean、getProperty、setProperty
# P& `9 }' S+ |# F7 k<jsp:useBean

id=”myForms”
# B2 W- }# V' R3 e/ X0 R9 i
) F: o3 J" w. x! c/ {- X, bclass=”com.base.mystruts.forms.MyActionForm” scope=”session” />
: Y- Z& [+ I* G8 U/ }* t9 Y
    <jsp:setProperty name=”myForms” property=”name” />
8 C7 M, X' i3 v, d9 c# M# x9 }/ ]
<jsp:getProperty name=”myForms” property=”id” />
! B2 q) j; h  H
* g9 W$ G. J7 `6 s( F

" b2 b- u% Q6 |/ s$ @% C描述说明Bean的四种scope
) F+ o& q2 N% |2 opage

+ o3 K& ]/ H. h  m% s( L9 Erequest
9 l) e2 `  S- _$ l& ]% S$ A# L
session

application
( s3 E4 @: H4 N5 k( T


描述说明页面上的字段和Bean中属性的对应规则
id 指javabean的变量名
1 S( V4 q+ [/ X& D. \8 l
class指javabean类的全路径
7 N- p( L8 a7 r
scope指javabean的应用范围

name指所用到的javabean的变量名

9 O, G' Z$ V% c6 c. R2 x7 V0 [9 O    property指javabean中的属性



* h  R- v' I, u: v( F描述useBean动作的处理过程
使用id声明变量
( |- ?# q/ \7 U
试图在指定的范围内查找对象

( J6 i  ]6 V( s' l4 _9 D如果没找到

' t2 k; D* V+ j/ I创建一个类的实例

执行useBean标记体初始化对象

如果找到
$ K$ @6 o& S0 L* w  g7 t+ |
. H8 i' @1 K: j, Z9 p$ E' _$ V: ~     将对象转换为类指定的类型


% O5 F2 M! D3 S9 ]' m: `  A2 j
描述forward动作的功能
使用脚本代码处理请求时，可用jsp:forward 动作产生一个不同的视图，
7 {6 i3 N6 B. z8 b9 s
使用同一个request：

& \4 D! w) N% F8 M

  d  `) ^; p" @9 t3 D什么是Model 2结构，以及结构中各部分的功能
jsp+model+servlet

Model 2架构使用MVC模式，JSP页面充当视图，Servlet充当控制器

Servlet控制器：
* N* p, a1 W- B/ x7 A. E- _
验证HTML form数据

; s" `% j% F# ^" o7 v0 ?0 k0 Z+ N3 z调用模型中的业务服务
+ Z/ m/ r9 J; U( D& I$ \8 S
" @: S1 e6 E4 J* `7 W存储请求（或会话）范围内的域对象
$ `9 F1 N1 b4 f) y( f; y7 n# X* m
  B; |, V. ^* b( a- H1 x/ d选择下一个用户的视图

JSP页面视图：

使用用户界面（在HTML中）
5 y1 @: N4 X+ x  ^$ Y0 O6 I8 g9 p
        访问域对象
* y+ g- F' W5 E- l" e, d


如何获得分发器？分发器的功能？
: {5 p7 ]2 F  [: U' ]2 B0 k上下文对象中的分发器：
: l+ u2 Y' ^2 }8 b/ i) R
) J. i; e, K) Z4 \( \% jServletContext context = this.getServletContext();
! d" a1 q8 ]# |* |. X+ o
RequestDispatcher servlet = context.getNamedDispatcher(“MyServlet”);

servlet.forward(request, response);

请求对象中的分发器：

RequestDispatcher view = request.getRequestDispatcher(“tools/nails.jsp”);
! w1 M5 @! g) I6 Q
7 N0 Y' f8 k- t. q6 a7 D; wview.forward(request, response);
! W: u) S6 L9 q
' e+ D* w/ A/ l4 V  n+ P6 i$ F) w可以将请求转发到另一个jsp页面，并保持请求的传递性



! b: F3 x- |$ g; B% OJsp中页面跳转的两种方式？
% [2 X: s. O# J* y使用分发器跳转页面
3 L; {  P/ R# E; H1 xRequestDispatcher dispatcher = request.getRequestDispatcher(“url”);

, Q( w3 N$ b% O6 m( [- tdispatcher.forword(request);
- D5 {& R7 P% l  G3 @
# B3 q9 ?% V9 T/ u5 P    特点：保持请求的传递（上一次请求中的数据，在下一个请求中仍然可以得到）；

8 R9 N% |5 N# G% b3 i        转发的页面只能是同一个Web应用程序的其他Web组件

使用重定向跳转页面
response.sendRedirect(“url”);
2 A; U: {1 G; v7 @, ?$ [6 @) e
/ K6 j7 X' x3 M" M. @    特点：产生全新的请求，（上一次请求中的数据，在下一个请求中不能得到）；

6 \/ R6 p: B$ B        重新定向的页面可以是任意的URL


! O+ U! i# a2 b0 w# h, [
- O6 N6 i& B! G5 g/ |描述Jsp中引入另外页面的两种方法，并比较两种方法的特点？
/ M, k; s# G( _0 k/ w<%@ include file=””%> 在编译期间把另一个页面完全嵌入这个页面,可以说是一个页面

1 n& y' x5 y+ w8 L# H& }在这里可以共享变量
) v# G  W2 E: V7 V
/ J* P( W& O  p1 _, c8 b; {5 v8 G<jsp:include page=””> 动态的再运行期间把另一个页面加入这个页面,可以说是两个
  X# h/ t3 ^4 d" ~- z" ^
页面，不可以共享变量
) n0 m4 m7 M  R1 V4 p7 q* d
8 C: _& y& [& |8 G, g! Z

- T7 O" w6 g% s6 {& }! \. Z4 U什么是自定义标记
自定义标记库是一个Web组件，
' Q0 b' H+ T' ~3 @* g7 S
包括：
: p. [# j1 o5 T
一个标记库描述符文件（*.tld）

  Q0 X! C, ?+ O( R5 F0 q4 }6 G4 `所有相关的标记处理器类(*.jar)

* q: y. Q8 B: G" E( x

描述使用自定义标记的步骤，以及每步详细的工作
使用自定义标记前，要拿到.tld和.jar两类文件
" s) `" _. J" Z8 i, h5 l# _5 C
把.jar文件放到WEB-INF的lib里面。
6 b6 b  x3 j% c+ ?3 j" Y# t/ C把.tld文件放到WEB-INF根目录下。
在web.xml中配置。
<taglib>
8 }; r+ R3 k/ X3 B4 V
( K& \2 n. e! U2 _! |9 x<taglib-uri>http://java.sun.com/jsp/jstl/core</taglib-uri>
5 U7 b) r7 h& `" Q2 p
' G7 k% d& U/ f: j     <taglib-location>/WEB-INF/c.tld</taglib-location>
- V; ]- u) u# j) |& t4 Q' S
</taglib>
  y. c+ [) i$ J0 t$ t, S6 [
在页面中引用。
<%@ taglib uri=“http://java.sun.com/jsp/jstl/core” prefix=“s”%>

  v  \0 S( b: h, ruri必须与web.xml中的uri对应
2 @# I5 W5 x  W0 H! _9 }) @- Q
prefix是前缀，用来区分是哪一个taglib

0 |0 b  [, W3 l- j: S/ k使用标记
格式：<prefix:tag名称 属性>

<s:forEach >

admin

在tomcat下配置数据源
1、服务器与数据库的连接
7 S- W; A0 Q% ?9 Y! J
: c7 v* _8 O0 G4 s+ p配置server.xml文件
4 }3 ]+ }1 ]4 Z5 P, v: H
1.oracle
0 A+ H9 ^1 N5 D4 x5 {2 d. B6 q
4 w1 N2 t6 H1 V8 L9 e$ W* M! x<Resource name=”jdbc/company” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”

% H: Y8 n9 Y4 N% A9 _                        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”

) ^/ ^& i2 j" l3 Y/ M* P7 {url=”jdbcracle:thin127.0.0.1:1521rcl”

driverClassName=”oracle.jdbc.driver.OracleDriver”

username=”aa”

password=”aa”
0 w) d9 G! d& N( Q
  C! j: ?% ^3 L% lmaxActive=”50″

+ T' C' E4 |7 B8 hmaxIdle=”10″
( ~1 h! |8 [; P2 r: \9 k% \. ^9 s/ U
' l) o6 s0 `/ A7 Y% k- c  vmaxWait=”-1″

% Y( A) ~" c5 L, @/ F1 @/>

2.sqlserver

- V- p: E3 z$ K/ I4 Q: D/ B( _<Resource name=”jdbc/webpage” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”

  _# M1 [/ ^  y& z        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”

url=”jdbc:jtds:sqlserver://localhost:1433;SelectMethod=cursor;

DatabaseName=webpagetest”

# J) o7 S! `/ f- M  B" M0 adriverClassName=”net.sourceforge.jtds.jdbc.Driver”
! d* ], K; B& v8 f+ q  E, p  e' s
username=”aa”

password=”aa”

maxActive=”50″
/ @7 f/ e3 f4 o" p9 g8 {2 O
& H) ], t% a/ e3 v# lmaxIdle=”10″

) g, f3 j- H$ [maxWait=”-1″

/>
9 [2 D# c' I9 [! E
2、配置自己的web应用的xml文件
/ \8 }1 J1 i! G0 X
+ c1 v5 F' U& j) a) K& b: k

( A# c  b& H$ F3 K<Context path=”/eb03web” docBase=”F:/workweb/eb03web”

privileged=”true” antiResourceLocking=”false” antiJARLocking=”false”>
/ c5 H6 n6 F! [! o' w
' l- \. k7 M* ^! r, W6 J7 Q  {<ResourceLink global=”jdbc/company” name=”jdbc/company” type=”javax.sql.DataSource”/>
. j. F$ a# ^( T  C
</Context>


7 g6 r$ F# \  {9 r. [  \( N
3、配置web.xml文件
& I  V9 ^  Q) U! B
! W. `: `/ x+ W与服务器建立连接
7 q0 f4 L# n! q( [; ^
<resource-ref>
- t, r9 h$ M. t3 [3 }. N
<res-ref-name>jdbc/company</res-ref-name>
% s! c- U' Z9 O& K  L; ]
1 h+ D# b5 A7 r$ ?<res-type>javax.sql.DataSource</res-type>
" ?7 R: u  h& J4 m$ {# `$ u( M
<res-auth>Container</res-auth>

</resource-ref>

4、在应用程序中不直接与数据库连接，通过DataSource连接池建立连接
! d5 y, ]" Y4 o, e& @3 r) X
0 |6 u& E- S# c  Q* _4 f5 I//1.在程序单独用时设置系统的属性，在tomcat下可以不用配置，
5 {% \/ C3 P: P5 S1 r6 Z3 G* A) x; \) Q! t
System.setProperty(Context.PROVIDER_URL,””);
7 ~: e0 F6 Q& F% P- Y2 r
System.setProperty(Context.INITIAL_CONTEXT_FACTORY,””);

! {9 F  y3 s9 m7 [//2.创建一个上下文对象
! d8 v: }5 ?/ h0 V8 X+ X( k% b7 B5 v
* H% |) v, v0 G9 y" y: Z+ {; CInitialContext context = new InitialContext();

//3.通过上下文对象在连接池中查找DataSource

/ G. ], s7 T& l$ IDataSource ds = (DataSource)context.lookUp(“java:comp/env/jdbc/company”);
/ a  }, T# T6 V& D, [8 B* Z
$ ~6 B& s  c) g1 I" M, M- ~+ U//4.通过数据源建立连接

ds.getConnection();

admin

ORM对象关系型数据库映射
, Z3 i2 `* Y& W. ~% K(Object Relation Mapping)
" f' w. C0 u6 B9 B& s5 D# @/ B
一、映射的特点

/ V* X" t6 @* J# N$ k1 k- l1.一个对象可以对应多个表

2.一个表可以对应多个对象
7 K5 s3 S: y0 q
3.对象和表的关系不用完全对应

4.对象的属性的名称和表字段的名称可以不同

& L' O0 z5 L6 y1 _5.类型可以不同，但数据类型之间可以转换

6.对象中必须有主键，数据库的表对主键无所谓
5 P8 u1 X$ X1 Q3 [
& c; j# r6 B1 x7.数据库中有主外键关系时，对象中可以有，也可以没有


$ w) d' a3 c5 u* n  T0 G
4 n' c  B4 ]- V9 W1 ^2 U二 、有一个映射的描述文件————>xml
* B' h) _% Q! L  m% [2 v% @
) o6 |7 k/ {" x/ h7 L5 n. q9 P三 、怎样实现描述文件————>一段程序
0 D% w( S' c! L  g% V8 e. c
" p9 c  e% x: s4 i3 w对象 映射（mapping） 数据库
% |$ i0 P% f; b8 n6 Q
user

id=11

8 O$ a% q. c  `6 e1 wname=”张三”———— > (1) —————> tbl_user(id,name,age,tel,address)
& _0 u  a% m$ |( Q
" j* d6 V" I9 X; w5 q0 h  Aage=25 <————(2) <————

) u4 E% i& ^( J2 p) ^- n
! a* @3 ^5 b# m$ j5 m$ w
5 a/ n5 b0 Z9 U7 {8 e(1)从对象映射到数据库

- R2 P. F; b% f: u1.JDBC
% Y- H% M+ s1 J8 l
2.根据描述文件来动态拼接sql
( P9 [' I! i! }0 S5 T0 s+ }
3.执行，添加到数据库中
3 w% y/ e# C8 d5 v$ z
! G7 {# r* l- ?: N8 T0 f

; k" m8 ?1 K+ @(2)从数据库中映射到对象
; q" ]. Y/ i0 w9 j8 [; _: h
0 e# V5 P, H5 r! ^1.JDBC

2.拼接查询sql
2 z& u6 P6 \6 ~
3.ResultSet

/ V0 {0 X# e$ H2 X4.Model
5 L7 b! E9 T) @% C% N& A& B


3 J9 P8 [2 f$ g% Q* C+ Ohibernate
9 b# ?6 f+ O' E+ f/ Z+ T开发流程：

) A8 _; k$ ^9 O6 l( l( J( ]是什么？
: X9 I+ t; u) z2 o) jhibernate是一种基于orm 的轻量级的框架

# C2 l. a/ e& I4 g3 R

& `/ o: X* E$ {) I有什么？
1. session 保持连接状态（依赖事务和连接池）
. ~+ l9 Y4 Q7 P$ x% J; [; a
2. Transaction事务
7 q$ V( q$ b* U7 ^1 T1 E
3.
1 G' j! V( [1 o- l4 [) eConnection Provider 连接池

6 k5 A4 P/ x. ]/ t! P

能干什么？
1.orm

2.提供操作数据库的接口，简化数据持久化的编程任务

) ^$ f' e& g( _
5 K# [4 E' O2 M1 v( i, _. {
怎么做？
* c9 g, X: N7 e; N7 X5 t1 Z; [1.搭建hibernate的运行环境，将hibernate的包和hibernate所需要的包拷贝到lib 文件夹下

% p9 n6 [' m3 X, r6 N$ x" }2.O（vo）

% w+ n# o, n5 W% P5 I  @3.R （关系型数据库中的表）

4.配置文件
8 W3 b4 b+ h; ^! e6 L  l  [
4.1 cfg.xml 放在classes根目录下，默认名字为hibernate.cfg.xml
% j( X  d1 w3 F
a.与数据库的连接
) j4 D2 S' `( S8 h6 b6 }5 N
) B6 N; F$ r" m7 e1 q) J, }b.可选配置
* i; ]/ c5 `% g: G" o) Z0 m5 X# V5 L
" J8 X2 B  ?" _: c3 Oc.映射资源的注册
/ }! A( c2 E" D- R
( [: ^3 M- b, y2 w' o4.2 hbm.xml文件 名字与类名相同 并且与类放在一起

a. 对象与数据库表之间的映射
1 t* b& j6 ?& |) @) _
b. 对象的属性与数据库表的字段之间的映射
# \. I/ u+ b/ `" N7 d
c.组件之间的映射

d.对象与对象之间的关系映射
; ^2 f. \$ z- F- ^( ~0 u' v
+ J9 O2 z0 p5 p! j, B/ j5、客户端
0 S; D% h4 p( w0 V
& O" G0 g7 `2 s, j5 i# @1.得到SessionFactory

1 C$ t* v% k9 A2.通过SessionFactory 工厂来创建Session实例
- P! h- k3 {. t1 v4 W! a7 n
3.打开事务

/ }  \$ Q4 N5 p+ r8 c2 P$ o4.操作数据库
% E% _( i7 z" a+ ]" o
5.事务提交
% a; @6 I% V( P- S  y+ y
6.关闭连接

8 z& q8 m  k1 l  i运行流程：

整体流程
1.通过configuration来读cfg.xml文件
1 ?6 S# y; `, G, J+ t: R5 K
' M* x9 Z1 B, g& [2.得到SessionFactory 工厂（根据数据库的连接来创建sessionfactory）

3.通过SessionFactory 工厂来创建Session实例
, _: U, d; O/ r: L. B! v; {
+ i" D4 A% W& g- ]9 R/ m4 N4.打开事务
0 e+ N* L; V, @! r0 F
5.通过session的api操作数据库
$ v; e0 {" X. y) K
5 `* N; e' s) |& |8 H6.事务提交
. F$ j, D0 F1 B- Q
0 B% L# N' z# X! l+ B* x9 T" T- r7.关闭连接
! n* @' X, r& c- b: _5 K( Y

- d* ]" P# l- s4 l! \  G9 b- h2 d1 a1 L
- J" O& Y) f9 y+ N# A% rsave
; L' I! T; z& Z4 j, ~) s5 e$ i1.to—>po
8 Z) e/ M/ e/ q% @7 g' G
2.根据model和cfg.xml中映射文件的注册来找到hbm.xml文件

; A+ g: f' B3 {' I8 Q: _3.根据hbm.xml文件和model来动态的拼sql

8 p% P; \! s/ f% x2 q5 S5 _4.客户端提交或者刷新内存
7 j0 N2 g" i" W6 I9 ~$ k
/ r! v1 H- N) q, X2 V) c; {1 p& M# s5.执行sql，值放到数据库

3 t) W7 x+ c% [# F4 x" T
7 m1 `) [; p5 W& b, }& S/ n
update、delete
# U5 M2 z+ M/ W2 R0 D! Z2 e( [1.根据model 的id在内存hibernate的缓存中查找该对象
: u0 v9 S% K$ z+ Z
如果内存中没有就到数据库中查找来保证对象的存在

2.根据model和cfg.xml文件中映射文件的注册来找到hbm.xml文件

3.根据model和hbm.xml 文件来动态拼sql
8 u- J' c8 t% a' w% G' e
4.客户端提交或者刷新内存

5.执行sql


9 ~6 R! n6 ]% k' i& }5 g
& A: N- E% w- `" lQuery
( l% S0 X; ]$ c7 F% b3 K+ bload

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

, z; b4 D( k; l# A2.判断id对应的对象在缓存中是否存在，如果存在，就直接使用，如果不存在就进行下一步。
' l- R; r5 n5 U+ a
3.用id做为查询条件来动态拼sql

4.执行sql 查询（先在内存中查找，如果没有找到（会抛出例外），就去数据库中查找）

/ c% p& Z, R0 l+ D( r0 n5.返回一个model类型的对象

, Z; e$ U2 o6 H+ _; a1 \get

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

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

3.执行sql 直接在数据库中查找，如果没有查到就会返回null

( f+ G7 u3 y1 n. S; fquery

1.分析hql语句，得到model的类型

) Z0 B$ O2 O* |1 K( ~7 `2.根据moedel和cfg.xml文件中映射文件的注册找到hbm.xml文件
- D! _: r3 b# S& a
8 `) {. W# G% D9 r4 u% d3.根据model和hbm.xml文件来动态拼sql
7 s' }) u' y, x6 F
4.执行sql查询数据库

5.返回一个resultset
! e( J- J* {( F/ M# p5 P
6.循环resultset的值，放到model中在放到集合（List）中
. |5 |, R+ p0 F
5 Q- F) N! S2 C5 a. C  W/ z3 ?

谈谈hibernate缓存机制

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

$ n& x* v* ^* T  A& x# e. Q

+ c( U! Q; ?$ x! `hibernate使用的是二级缓存，有两个级别，分别是Session，SessionFactroy级别，一级缓存是Session级别的缓存，Hiberante来管理的，这个我们一般不用管，二级缓存是SessionFactory级别的，可以进行配置和更改，加载卸载，就是我们平时用的hibernate配置文件中的配置SessionFactory的属性。
" p- O9 r4 J9 P! v6 C

& w' C( N4 {. e8 v; P% B* Y% I9 F
& W4 A1 a' y: s2 g- y' w对一级缓存中的session事务进行数据的预存取，数据在各个session的上下文中存在（单例），当session关闭时，就是session.close( )，整个所有session范围内的数据全部清空；二级缓存默认的情况下是不开启的，如果开启，数据库汇总的所有数据都先copy到二级缓存中，这里要注意的是，一级缓存是每个线程下创建的session缓存区域，可以是多个，二级缓存只有一个区域 ，画个图比较容易理解。
. h! s* j8 Z  Q4 ?; N2 w+ s
; Z( k* P3 j# \  E! k( W1 ]9 W) ~

( C' E6 z7 O9 P/ `, d; ^! M$ b| 一级session缓存| | 一级session缓存| |一级session缓存| |一级session缓存|

9 `1 Z: R% k$ d( q* d+ k$ k0 {: O| | | |

5 `5 Q) X( j/ y0 G" h# N" Q6 ?| | | |
% R4 ~! {0 i5 p5 O) X6 Y. {
& d' M) ?- z. Q9 T0 Y; y—————————————————————————————————
$ j' W' X1 H; G. V! B
sessionFactroy级别的二级缓存
/ n" p& s4 a3 K7 B
——————————————————————————————————————-

|

|

|

& u8 i. W: r5 \, b9 m5 Y/ |——————————————————————————————————————
% N3 B' b, j$ L4 ^' f. ?5 V
DB
. R6 _" G8 ~- W( z0 F6 S) U
8 G& Z% m( l! L, T2 b0 q—————————————————————————————————————–
: o/ j5 f2 q/ ~% @( q0 [

admin

Spring
% S4 C. H3 L7 _4 I

• 是什么？
  
  3 J5 |/ W3 u2 H

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

0 N( l3 J) m0 h  n, `

• 有什么？
  , T4 n% I' Z$ y9 d- A9 ], O( Q
  

每个包的功能：

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

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

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

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

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

AOP ：面向切面编成

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

. M: n) D! u4 \3 P9 c/ w

• 能干什么？
  
  : Y7 b& Q1 \' k

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

. l; I- Z; V( R8 ^- K. J7 I+ T$ T

• 怎么用？
  
  
  • 搭建web工程，引入spring的jar包
    4 C2 [  s% R+ Y" q
  • 在web.xml中添加如下配置
    
    
  
  2 ~. R1 B9 H9 K+ I- J. C
  

            contextConfigLocation
8 l" C- I. A' i6 T' O

            classpath*:applicationContext*.xml
& |0 U9 S) L% ~  z) v6 ?$ r' Q

   

        
& L% O- S7 ?8 T

            struts2
. S- `( K9 C2 Y7 C1 H

            

                org.apache.struts2.dispatcher.FilterDispatcher
6 |5 l; m1 Q& k& {

            
! K0 w5 Y! X8 y5 y. T

        

        

            struts2
  `- t# h" |& K2 c6 u

            /*
6 {! {8 x" Z3 y% F2 O

            

                org.springframework.web.context.ContextLoaderListener
+ [! Y- A( ]- y8 |( r; I

            

        

• 部署
  
  

' f6 N* s5 [" |$ E! n$ P

• 容器和bean
  2 E' L" Q9 \) Y2 w. ]9 y. n

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

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

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

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

• IOC控制反转
  * O+ G/ H  R3 W- @% [7 d/ Q
  2 D* y% {6 u1 a, N% l2 [+ _, k) a, o
  
  0 U# u3 Z& j  O) c- X9 E
  " v" _( z# b( ^& I5 B" Q
  从前的应用程序想要得到A的实例他会直接主动的去拿，当用了sping后，应用程序由主动的去取变成被动的等待，由spring来控制应用程序所需要的对象
  
  
  • IOC的优点
    ! p1 o" U6 T; i% T
  1.可以通过IOC来获得实例
  2.可以通过DI来获取注入的资源
  • 配置IOC的原则
    
    • 一定是可变的资源才采用依赖注入
    • 一定是层间的接口或者是模块之间的相互调用才采用依赖注入
      

5 u) W. ~7 d- L+ H4 W8 j/ R3 |

• DI依赖注入
  5 y" I8 _& A, f2 T' \/ @

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

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

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

例如：

在配置文件中

在应用程序中

Public DBDAO dao ;

Public void setDao(DBDAO dao){

This.dao = dao;

}

3．构造器注入

4．ref 表示参照其它的bean

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

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

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

6.lookup注入

7.singleton

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

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

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

8.DI的优点：

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

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

• Aop面向切面编程
  : v" h; {, m! i! Z- y% ?/ P
  0 c5 G# q" f5 u2 {8 J4 g

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

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

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

3.AOP 的概念

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

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

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

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

5.引入 ：扩展的功能

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

7.aop代理 ：实现机制

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

4.AOP的事件机制
! [/ y9 t* G; z. J" I

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

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

3.找到切入点

4.确定连接点

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

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

  f6 N% n# s% x( x4 \0 i




0 g! L$ q- w! I- E7 {
; P4 j* V* ^' |. g# q) O4 Z3 w

5. AspectJ

5.1.在xml中配置比较烦琐
' v) f) [, t8 r+ W  F( R* a- ^# I

所有的入口必须从一个代理（ProxyFactoryBean）开始
) r5 M9 A' {! I+ E' [, A

$ r8 t6 p/ K- R8 R
+ s- F; v4 ^$ W% D( ?- P* X

         
8 b' L. K; e: A; g0 L* s

# Q$ G/ Y; A) W( J0 o; B% |         
, a: }, T) p. e, A$ Z6 I+ H

        

        

. q/ i8 z7 Z5 {2 y) Lexpression=“execution(* com.javakc.aop.MyTarget.t*())”/>

        

        
& {& B- F- r$ }; B( x  j

   
! A" x2 M# h- p

5.3.使用注解的方法相对简单
: v. g$ e) {* l& Z' k* ^! Y

@AspectJ的基本语法

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

直接在类上定义@Aspect

2.@Pointcut声明切入点
' W; X/ j  u" W' {2 `

2.1、用一个专门的类来定义pointcut，类中的方法名就是该pointcut的名字

2.2、可以使用匿名的pointcut
( e7 I, _) ~% h* U9 V! b

2.3、执行切点的几种方法
+ x1 `" x. ~* R5 w' A# u+ F8 M$ ?

2.3.1 execute（public * 包结构.*.*.（..）） 可以指定到具体的方法
3 [' _* E) r6 ^2 @

2.3.2 within 指定到包，不能指定到类
4 q$ y+ c2 \" H0 r& y1 X% Z

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

2.3.3 this 指定到实现接口的所有的实现类
* [7 ]" v6 n. Q5 a) t/ z

2.3.4 target 指定具体的实现类

5.4.advice的五种类型的示例

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

5.4.1.@AfterReturning(pointcut=”” returning=”retVal”)
* b! a8 P; o* z/ X

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

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

pointcut指所要监控的目标对象的方法
6 D9 P2 o6 c: W* ^0 e; e9 _5 K

得到目标对象的方法的返回值，来作为参数，进行下一步的处理,参数没有顺序，按参数的名字进行匹配
! Z7 F! c  }+ h" {9 g1 l

完成追加的功能

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

(1).@AfterReturning(“com.javakc.spring.schemaaop.TestPointcut.t4()”)
7 W: ^- p; j2 V7 T4 N3 p

(2).
( I! Z) p' R2 Z/ j- e6 L' I

     2.直接引用匿名的pointcut

     (1).@AfterReturning(“execution(

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

     (2).@AfterReturning(pointcut=

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

args(str)”, returning=”retVal”)
2 N& z" w; v) z$ t( `) v8 I

@AfterReturning (pointcut=”com.javakc.spring.schemaaop.TestPointcut.t4() && args(str)”,returning=”retVal”)
* |5 ^. s. ~+ x9 K7 u7 _

public void testAfterReturning(String str,Object retVal){

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

    }

5.4.2.@Aronud
" H/ u7 U0 @! O# Z$ d; o

     注解@Around环绕追加功能；
  U2 z/ J* u' L$ k" {6 y

     在执行目标对象的方法的前、后追加功能；
+ s4 R6 O# b0 {, r% c: x! [

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

     通过ProceedingJoinPoint的实例的proceed来调用所监控的
. A6 b, h5 O4 L$ E# B

目标对象的方法
# ~7 a& F  A8 b& [! V2 P% A

     1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
8 N- v9 N( Q7 P7 E9 c! I" Z( r5 g

     (1).@Around(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
% P! R; u9 {3 L) I7 N

     (2).@Around(“com.javakc.spring.schemaaop.TestPointcut.t2()
9 [5 a( }4 }( h: J9 @. j8 R

&& args(str)”)

2.直接引用匿名的pointcut

     (1).@Around(“execution(
" b* v( ]2 r! W, P

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

     (2).@Around(“execution(
2 Q9 m4 g" _: m  f; ^. d) k0 E

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

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

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

public void testAround(ProceedingJoinPoint prj,String str) throws Throwable{
; z- q  q' [8 s4 D

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

        Object obj = prj.proceed();
1 t; ~3 w- P* X1 f8 U' H- a

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

    }

5.4.3.@Before

注解@Before在执行目标对象的方法前追加相应的功能
9 o2 d, G4 t$ p4 l( X

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
) S2 h& s8 X4 B( b( ^5 q8 _

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

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

注意args后的名称与参数名相同
" C9 X( \* O( Z

2.直接引用匿名的pointcut

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

(2).@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
% c. C/ g* O  V) u( p/ B' s

注意args后的名称与参数名相同
! H  H5 T5 D) A+ Y4 |3 Z, X

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

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

public void testBeforeParam(String str){

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

}

5.4.4.@After

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

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

     (1).@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
5 D/ A9 S* q5 j7 G! O

     2.直接引用匿名的pointcut

     (1).@After(“execution(* com.javakc.spring.schemaaop.Api.test1())”)
" f3 z  a4 t3 ~8 E9 h! P3 C% }7 c

@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
  U5 t* u9 O# T6 m5 h3 C

    public void testAfter(){

    System.out.println(“after1== >pointcut”);
) _) f& x* c7 w. E7 y

    }

5.4.5.@AfterThorwing

$ v! W9 T3 t9 f" d8 f% B& _* [+ P) k

• 描述一下spring中BeanFactory和ApplicationContext的差别
  5 S3 ^% W  q, A+ C
  : f: `5 H; ^# q1 b# K, D+ J1 c$ O: V9 \, J

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的支持
  
  

Spring提供的DAO(数据访问对象)支持主要的目的是便于以标准的方式使用不同的数据访问技术。

简化 DAO 组件的开发。
Spring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法，用来简化代码开发。
. W/ C7 j: F% s& d6 b, ^; U

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

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

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

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

" Z% M, c: B9 y. R( Q: ^2 e. d
. U9 o( g5 w6 p3 n; h- K

• 谈谈spring对hibernate的支持
  . ~; [- ^' z- O4 B9 W
  

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

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

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

2 w* A! A7 p: s2 g9 [

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

        
7 b9 }* \9 R2 w- K; X. P8 M

            oracle.jdbc.driver.OracleDriver

        
7 t7 ?( K8 x* H% W

        
5 Y8 r" U) _- @0 ^2 @

            jdbcracle:thinlocalhost:1521rcl
7 \4 U9 C/ P+ _: j# n

        

        

            javakc2
( |5 ~( U3 p2 Y* d1 _' Y" w  l7 r

        

        
6 P6 j$ |" S1 P; g4 `" m! l

            javakc2
9 T* o2 p9 p. p5 j( C

        
' z6 P" ~- f) B* _! U: D

   

9 |) F8 m6 [1 l6 I: Z

   

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

        

        
3 m# x; t* I2 o2 Q. ?

            

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

            

        
! U$ m8 Z+ r. W8 C

        
6 i; w6 \1 y1 |4 P( W! I

            
5 b8 E+ A! H4 y" h6 ^0 A5 H& w. O1 V3 [

                hibernate.dialect=org.hibernate.dialect.OracleDialect
- F" _! T2 Z+ I3 y

            
, s$ A5 [- z+ `: R

        
$ s8 s( T4 \- ~4 S

   
: t! g2 t. W; [4 ]. G' f% X

   

        

   

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

   

        class=“org.springframework.jndi.JndiObjectFactoryBean”>
9 Q# {' F0 N# ^. w& D9 M% x

        
4 b1 Q7 i# o, [9 E8 A) [: B

            java:comp/env/jdbc/myds

        
7 L4 D1 U) C9 }( x

   

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

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

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

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

   

        
) r7 _1 s4 [* S

   

   

        

            

        

   

2 }/ ]9 v4 z2 F" Y3 C- y  y- H

   
3 a7 |9 X% x* n) F  V( E

        

        
" y) a6 N5 c( Y6 I7 E/ Y3 y- s

   

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

Spring2.0之前事务的写法 1 ~& u0 I+ `! d; f * f& ~! t. C2 N) @! d 4 L  Z# C: M% ]% }# u        class=”org.springframework.transaction.interceptor.TransactionProxyFactoryBean” $ H$ h1 \+ ?4 q5 e8 A0 R4 N8 c0 b         abstract=”true”> * M! U% W: m% T0 k0 Y8 h' F, w8 L                PROPAGATION_REQUIRED,readOnly 8 ~; I9 [. Z/ F2 r8 W; P+ h ) G6 J$ t; ?* [1 o( I' g                PROPAGATION_REQUIRED   D. w% S2 g- h( w, r 5 b2 P; m3 I& V% f  }

4 C' C+ A* _; }

• 谈谈Spring对事务的支持
  
  

1、声明式事务管理：

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

2.做法：

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

2.2

2.3 注入数据源

/ A7 V' G/ w+ k/ K& D- K; S) L

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

6 P9 ?/ k* Z+ |& I
. z: ^6 F: {" r$ z% k' N1 e4 k
; R: I8 Y8 F$ y/ ?% A* @

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

9 l2 d$ r) Y9 ^8 K7 G+ i
1 {6 Q$ H: Q/ o3 s

2.6 定义切入点

) e( B2 c1 R6 ?9 S8 t



5 [+ _! a  f3 k0 j; p0 @

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

1.注解@Transcational

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

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

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

0 g" u/ u0 ^& M7 v

如何在Spring中使用Hibernate的事务：
( m8 u6 C+ W  K& O. L

& a" C) w$ g3 ]  g

) e: A; `! x6 ~. R

: w0 |7 ^* k9 _* o+ g

如何在Spring中使用JTA的事务：
( m+ L% [; F( f4 H

% ]; l. m4 g4 c. m8 S9 k' G, L

admin

事务
3 O' C1 T4 W! }* DACID
（1）原子性（A）：一系列的操作具有不可分割性，要么成功，要么失败

（2）一致性 ：操作的前后满足同样的规则，保持平衡。
3 B- Z; K- L1 d9 Q+ P
6 N- y! x! s% x" P（3）隔离性 ：在事务运行的过程中。事务内的数据对外的可见性和可操作性（必需由数据库的支持）
+ E( q) v7 a' p* c4 l
（4）稳定性 ：保证数据在事务的操作的过程中不会遭到破坏，而且是永久性存储的
0 Z/ q% j: Z! j9 T- G  K

" d  e  K7 Y7 Z+ e  `' M1 U& U
事务模型
（1）经典事务模型又叫平面事务模型（JDBC） 事务不允许嵌套

0 p; ?) f" w  c8 G4 Z5 i) h) Y（2）嵌套事务模型
: |6 r3 c1 c+ h( ~% x+ O
( {7 O# l$ D* |9 {1 k( Z) L

$ {6 g' R" m( t, B' A  H, x事务的两种方式
（1）声明式

在配置文件中设置以下6项

- _. X5 M/ \% l3 ~' ~0 r9 I0 k（１）.required
4 e4 w: z! Z) J  |) y
如果客户端没有事务　在bean中新起一个事务
; `" ]& T3 N/ X7 ~) C' s
: p& x* P8 J, Z2 [如果客户端有事务bean 中就加进去

(2)、 requiresNew
: _3 v/ H3 H% W  Z2 Q
不管客户端有没有事务服务器段都新起一个事务
2 v/ Q+ F% E# g. \$ Z
如果客户端有事务就将事务挂起
( Z. D7 H! T8 h4 j8 X
(3)、supports

! I. |6 l+ n- W4 V& X如果客户端没有事务服务端也没有事务
7 y' G" {1 I; O! N9 D
( ~! S7 m: j0 ^0 I7 X如果客户端有事务服务端就加一个事务

9 Q. s' t" S+ g(4)、mandatcry

! T$ d  Y# [7 f1 l3 ^5 ~如果客户端没有事务服务端就会报错

% Z' ]4 {+ f; R8 X2 C如果客户端有事务服务端就加事务

(5)、notSupported

不管客户端有没有事务服务端都没有事务
3 V5 m: _* w6 ?* V( o% A6 U0 j
如果客户端有事务服务端就挂起

, `+ T* s) g3 c& }% G  s2 a(6)、never

3 m% [( L3 @$ c1 _不管客户端有没有事务服务端都没有事务
$ J/ R: K* \. L, p6 {3 Z2 L
如果客户端有事务就报错

/ c' ?% A8 }3 ^. Y4 B( S（2）编程式事务
* W3 i3 a& O. j( q# b2 m
; h( a2 f+ ^! V/ VJavax.transaction.UserTranscation

JTA 事务可以精确到事务的开始和结束


$ y, |- H6 @) i! ?% b6 x  k7 c
事务的隔离性
5 T1 o$ {# G' RRead-uncommited
8 ?! I% e# w' T5 _4 t5 l6 R6 j
读取未提交的数据（基本上没有锁）脏读，存在不当读取的问题。
! s2 B2 M9 V$ }/ v- v
Read-commited
3 H/ U# P0 u8 w2 q0 C- ?8 P( P0 \
读取已提交的数据（行级锁）

无法读取已经写入，但没有被提交的数据。
# u& \2 L3 [; f: |
% f. p) g. }* a8 A% iRepeatable_read

读取的数据不允许修改或删除

: r9 r& |4 |/ j/ W不可重复读（行级锁+不允许修改/删除）
# \+ ?3 S& j3 o
% E9 R/ r* i* @7 j$ l& LSerializable
4 v# q7 h! d, \2 S% i- @2 E
幻影读（表级锁）
- s+ f, y* B7 A' z, j4 s. Q
# q$ {. H# o/ |' |
" p9 ?' \% c- i
struts
" u, I" d0 y2 r' y! s开发流程
# k7 I/ ]1 ?7 N1 O% v2 t0 V( ^2 \
1、创建表单
% w8 u' U& G" {$ K' e+ t; o7 Z, s
' c& I3 q3 o# ?1 _2、从表单中获得输入
+ D( ^+ r6 e' o& L1 r6 z$ }
3、处理输入（业务逻辑）

' v: u0 t' ~: k$ w9 l# w. F4、根据动态输入改变输入流
  A" }5 g) H: j# q) c% C4 V! F. `  B7 ^
9 B* x7 h* I& P8 z1 L2 B要完成上述四步，我们需要创建
  `) D& H' F  r/ N! _
! j) ~% j  ]/ @( D1、一个ActionForm
' W2 Q, B3 T" |; U% c4 e/ e$ o  U
2、一个action

3、一个配置文件struts-config.xml
6 l4 l' f2 n( S! t
# M. M5 A9 N0 L  n! V# G, h4、创建页面
$ R* V/ y) D  L9 N, X$ k
创建ActionForm

, F3 e6 Y# p% C2 Q1、写一个类继承ActionForm

2、私有的属性

3、相应的get、set方法

4、重写tostring、equals、hashcode三个方法

' n; f. u' u8 c* o: k6 b0 Z: z创建action

1、写一个类继承Action
9 h  f6 E/ v) ]
2、实现一个公有的方法（回调方法）
. Y# O  n9 [9 o# }" q$ U
public ActionForward execute(ActionMapping mapping,

ActionForm form,

HttpServletRequest request,
: L7 f& j5 p4 D
3 t6 M1 N1 `* E* KHttpServletResponse response)
* G( }8 P  w% E1 o  p- K$ i2 y
; z# @, n/ o8 B0 }1 x( D- f{
! M$ F$ e% m5 i; V5 f* J
//1.收集参数

! d* P) w" g/ CMyActionForm myForm = (MyActionForm)form;

: G7 [& G: O; {! t& x+ O3 j//2.组织参数

+ j! R# p8 z, Z6 k. h
! Z9 @- K7 m2 ]" Q1 J8 i
' T! a9 Q% f* H% h0 t+ u//3.调用逻辑层

boolean flag = true;
9 M1 p! Y3 t' o- k% z5 q, s
//4.根据返回值来跳转到相应的页面

ActionForward af = new ActionForward();

if(flag){

af = mapping.findForward(“1″);

}else{
. ~# A) r, h+ }
) G/ F+ a( v" V' V1 C6 yaf = mapping.findForward(“2″);
& j3 J; K5 n& W+ Z" h, W
3 h2 l. i+ u: R# ]}

5 H# G- Z6 n- t7 t2 }4 ~return af;
9 W% f0 o+ _: i' |6 @
}

配置struts-config.xml文件

  H2 q1 R: A$ `# c6 @1.<form-beans>

<form-bean name=”myActionForm” type=”全路径.MyActionForm”/>
0 w6 P. C1 N! j4 Z
<form-bean />
/ ]5 }# F' v3 A! F9 H- N- z% V
! w/ r* Y" r0 C( L0 |5 p& s: e</form-beans>
2 L5 l( ^/ C" {7 g
3 h. ?- e3 F' L2.<action-mappings>
; @8 A( X) ]+ f) Q; ~
<action path=”/sll”

name=”myActionForm”

type=”全路径.MyAction”
; r5 A- f+ t# ^/ D" q
scope=”session”

4 b/ U  a( o$ L; e) v! ?" k" Vinput=”错误返回的页面”>

3 x0 @! `9 I0 s<forward name=”1″ path=”/1.jsp”>
) ^+ w. U0 p% h6 {0 g7 K3 c
0 t6 b/ `; y9 N" h9 ]: o0 e<forward name=”2″ path=”/2.jsp”>

</action>
% u) o( Z: ?" J' c, s- y( t
</action-mappings>

步骤:
$ x5 r. A/ O; y2 X4 R3 W  D$ L
; Q4 V: D( N- ~) X6 c, v: P1.创建一个空的web应用

7 d8 E2 ^0 N. F& G9 Z% n2.将struts的包放到lib文件夹下

3.将.tld文件文件和struts-config.xml、web.xml放到WEB-INF的跟目录下
* K' P( a) W* l3 s
4.配置struts-config.xml文件和web.xml文件

/ a1 P# w' a/ t' E5.在页面引入tag文件uri
3 L. K! g+ N9 a( b( s3 K
( k7 d- F; C/ {7 R8 RSTRUTS运行机制
  {9 n& u0 w1 V" |2 Z
; J! g+ H$ L' }& j' d, T1、界面点击产生请求
6 H+ Q) M& k$ U1 x* d7 U
2、容器接到请求

4 I4 y3 r) G8 z+ [4 B/ l3、匹配web.xml文件中的*.do来调用ActionServlet

4、ActionServlet的处理

4.1 读struts-congfig.xml文件形成ActionMapping

4.2 通过path 来匹配Action类，通过Action的name属性来匹配ActionForm类

" |  L0 R6 X; g# ]6 J: E4.3 通过反射机制来给Form添数据
& }" W0 a; k+ F. V# o% z
4.4 由ActionServlet转调Action的execute方法
' x9 u5 Q1 }+ N' Y; N$ ^
4.5 得到execute方法的返回值，跳转页面

4.5.1 RequestDispatcher
# ~9 f( [) w6 L8 X& _0 E
4.5.2 response.sendRedirect(“list.jsp”);
8 k, t; B; k$ ~2 A9 h4 s. _2 Z

! K5 i+ u  ^3 j$ X0 R! ]9 K
" r3 f9 ?( o/ Z8 u/ E5 S1 r2 _1 p进入execute方法

3 R1 ^6 _% v- ~0 D0 v1 收集参数

; k3 ^1 H/ z# O2 ]2 组织参数

  U9 a2 u1 h* q: T; j3 调用，逻辑层

4 返回值
  E5 G  O% g7 i
4.1 选择下一个页面 （ActionForward）

- T( W5 s0 @; P/ I$ z$ G: U& n4.2 把值传给下一个页面

  f# n; {& t1 E( l1 x

比较struts和struts2的不同

Struts

) V) w1 |5 }! v. e+ h  W' ?6 BStruts2

( m8 w+ U% t5 T1 e( b6 {3 l组成        五个部分：ActionServlet，ActionMapping，AtcionForward，ActionForm，Action        十个部分：AcionContext，FilterDispatcher，ActionMapper，ActionProxy，Configuration Manager，Action Invocation，Interceptot，Action，Result，Taglib
- Q' [9 u- O+ x' }' G$ Kurl        .do        .action
% O  ^4 n3 l( w* K4 P" {0 w7 Y分发控制        AtcionServlet        FilterDispatcher
1 ~6 x6 [8 ^2 \( R收集参数        利用JavaBean技术，将数据封装到ActionForm的子类中；
: z! H4 A3 {7 c' n: y一个Action对应一个ActionForm的子类

$ m6 v; l4 M' a1 N使用拦截器将数据封装到值栈中。
" T- F" t8 Y0 K0 k( S9 a使用域模型，一个Action对应多个值栈中的Model
" x6 f, |( A  K
读取配置文件        ActionMapping        Configuration Manager
) Q6 V0 J% U% |# V; W1 M拦截器        无拦截器        执行Action前后有拦截器
0 e8 r8 t4 P) v8 M6 j" n! ^返回页面        将字符串封装到AtcionForward，进行跳转页面        Action中直接返回字符串，通过Result跳转页面
页面跳转方式        两种：dispatch，redirect        三种：dispatch，redirect，chain
$ L* M1 _" I- k2 ?3 B7 T3 s( {) E* ]值栈        无值栈，Action通过在request范围内设置属性，向jsp页面传递数据        有值栈，Action和jsp页面通过值栈传递数据，jsp页面通过OGNL取得值栈中的数据
配置文件        struts-config.xml        struts.xml
. P. Y' {9 V( |2 k中文问题        不能解决（需要使用filter）        可以解决中文问题：
1、在jsp页面添加Meta；
( M8 {$ l! N, T
9 d  B, D0 J4 `; U2、修改struts.properties中的设置。

admin

其他开发工具和技术
' v' E2 t( G$ {Ant
1 C! Q! L$ C9 u( {Ant是基于java的批处理工具
+ y" Z' }; ]5 Q6 t, b
! `2 u6 Z1 `5 q- M# {$ e一、配置ant的运行环境

1 \8 O6 R9 S; v6 J1.将ant的bin目录添加到path中
# D) S! n$ Q  l2 l6 s% `
8 h* u% [% s/ E; @8 C  k7 {) q1 q2.配置JAVA_HOME

3 H- F( M" [: X6 }8 J4 y% S3.配置ANT_HOME
* W7 ?$ m. x& `+ G
二、配制build.xml文件，该文件放在应用程序的根目录下

5 W& `; N8 S" I  W2 X1 O# J编译java文件
4 s4 }" E0 Q( }
. @8 ^# \2 q) X. b8 y9 v执行java文件

copy
/ Q' g9 t$ ^6 A- a+ h& @
3 ~$ g0 P1 e% J- {1 ?删除

- R4 T  M% D' B4 p, _" n9 F- L- {打jar包
* I& w  p& Z0 A7 s9 u/ V5 f
根据注解生成配置文件
2 n7 y' y0 L. u) F8 l
' g' x8 k2 U  x: T) r8 i4 XXdoclet
' B" K6 N6 L# ]通过注释生成一系列文件的工具（txt、xml、java、html等）

! @/ W" Z( a; {+ gxdoclet本质是摸板技术+字符串的替换
7 i* G  p+ R; k, J) A! r! h
* j9 l; F9 o' _1 {# P1.在java文件中写符合要求的注释（将hbm.xml文件的内容搬到java文件中去写）

1.1 在类的上面 写与表的对应
, {5 Z' d+ }, D8 A
1.2 将每一个属性的注释都写到get方法的上面
0 P6 f- H' ]) W3 O
2.在ant中引入相应的task来驱动xdoclet


5 q" V% ^5 t+ z4 s$ a
) Z6 q1 Q1 w) T. [, x7 M. L6 Qlog4j日志管理
& |0 I8 H' B7 I: v; `  O1、是什么？
$ n# R! N1 }1 ~9 ]6 g* L
7 I$ b7 v& @  O# I, w) Z* ]在开发期间用来测试、对整个日志信息进行管理的工具
/ m$ m. L6 ^2 H( c
2、功能
! V) U+ O) X8 f/ h, ^
3 q5 G3 E( w% @/ E- p) N% i1.控制输出的目的地
. y  D' u% O# L* C. `4 y
+ n( \! \4 w+ s8 @2 B2. 控制输出的格式
) Y0 m# U5 k5 Z1 r/ s% P
3. 控制输出的级别
9 Q, K( S/ A2 v* |+ X  t0 K9 Z
$ I* s7 j3 f# j, x9 d4 A5 Q- @$ z8 r3、日志的级别
4 v# J: B$ R. y/ g* ]9 k7 u
1. debug 调试
& e8 w- C, @6 d9 z- H$ M
2. info 给用户的提示信息

; z( t/ u3 H( v3. warn 给用户的警告信息
( Q' T6 y! V0 [/ l
0 X) m# c: X5 S. O/ k* w5 c4.error 给程序员用来调试

Debug—-〉info—-〉warn——–〉error
7 r1 H& W) w/ J' r
/ l# K; \) u" ?5 ~" r4、配置
/ ~% I; r# @+ G6 f! }8 M% f
( t3 }+ {7 |" Q/ I/ T1.配置级别

% M5 _# L5 ]% d2.输入源 （控制台和文件）
# `& f7 ~( @$ F$ z- h
3.可以进行分包控制
+ B& ^( Z$ [+ b' N5 E2 k0 U
Log4f.logger.包结构 = 级别
( H8 Q: P5 c; k- j1 u8 ~2 g0 F
' x1 o1 L/ _" @& G4 q. _% C* {5、使用

& n6 H7 r0 ]# H8 NLogger log=Logger.getLogger(Test.class);
5 j' }% [' M( ~; @( O5 T9 }- B
    public
void t3(){
5 }. d" g4 Y* W3 O* \& Z9 C
$ q2 P5 I7 j  n0 A2 H        log.debug(“this is debug”);
" U: W6 U" f2 _! d  S1 _
        log.info(“this is info”);
# o1 B) G$ B# s. ?
6 V/ Q- e9 ?5 ?        log.warn(“this is warn “);

( ?  P6 S3 R' G9 T6 }        log.error(“this is error”);

    }
9 s' Z4 @" Y, J  a9 H- \% I" d
Junit
9 x- u2 h( H( m+ o* S1.是什么？
0 U" w+ L% Q0 E* P
( y9 ~) a0 E( a9 O3 B& K2 k5 ~单元测试的框架

2.怎么做？

/ o% I- ]: J0 r: G5 y0 T写一个类继承TestCase

8 h4 L" @' M, [6 |测试的方法一般都以test开头并且没有参数

在测试方法前执行的方法public void setUp( )
8 E/ W" L. R: y% A
7 ^" x3 Z2 I. r" s( Q- V在测试方法后执行的方法public void tearDown( )

error和故障的区别
& k  P- G+ `& n2 ]
: y+ w8 t' R& Ferror ：代码有问题
1 D9 U% Q. M7 }2 V
故障 ：逻辑有问题与祈望的值不相符合
/ X* k- h5 p3 B4 e& R
: z6 V& {4 F/ X8 y7 E" i' |生命周期

' |# H1 u: s, p2 {' a/ h; J( Z测试—〉SetUp（）—〉testXX（）—〉tearDown（）—〉结束；
: P: i- t& o3 n
TestCase套件

public class MyTest{
7 ^/ W- [  a; b8 R
2 b; X: v' G9 K- k0 X8 K4 R& x        Public static Test suite(){
: @- ?* ?! y1 h% c- [1 D$ `* N
; }9 v4 A1 {( ?/ O: w0 fTestSuite suite = new TestSuite();
' }' V- W  |6 |: O
suite.addTestCase(Test1.class);

0 L& r; N6 C. A, e1 a/ ksuite.addTestCase(Test2.class);
3 [) a) a' M* @3 }
5 S( h( j* b, D9 H3 v; u# ]}

}

7 ]  o; M+ l. \' j' G8 q# V( w
# N8 R# P) k" k2 }
Ajax
; @0 |) c" G* {- X9 o3 a2 x; J是什么？
3 P, `& y, I9 {' d; B. ?2 jAJAX即“Asynchronous JavaScript and XML”（异步JavaScript和XML)。是一种创建交互式网页应用的网页开发技术。

无刷新页面。

# k/ X: w2 |9 g有什么？
) j. C/ s$ A4 ^  R3 Z  @AJAX是多种技术的综合，包括JavaScript、XHTML和CSS、DOM、XML 和 XSLT、XMLHttpRequest。
+ m6 \) K5 k  i. @1 U) p
能干什么？
使用XHTML+CSS标准化呈现；
0 t. R* @; t- A- e" i, Y使用DOM进行动态显示及交互；
使用 XML 和 XSLT 进行数据交换及相关操作；
1 H5 f. e# X, U7 V使用 XMLHttpRequest 进行异步数据查询、检索；
; _+ \" X" [( Y: R使用JavaScript绑定和处理有所得数据；

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

与此不同，AJAX应用可以仅向服务器发送并取回必需的数据，它使用SOAP或其它一些基于XML的web service接口，并在客户端采用JavaScript处理来自服务器的响应。因为在服务器和浏览器之间交换的数据大量减少，结果我们就能看到响应更快的应用。同时很多的处理工作可以在发出请求的客户端机器上完成，所以Web服务器的处理时间也减少了。
2 y0 W7 v9 ]! \9 m8 t
使用Ajax的最大优点，就是能在不更新整个页面的前提下维护数据。这使得Web应用程序更为迅捷地回应用户动作，并避免了在网络上发送那些没有改变过的信息。
' f1 B+ L8 r3 z& G2 i9 {8 E" Y" B
对应用Ajax最主要的批评就是：
1 它破坏了浏览器后退按钮的正常行为，就是用户点击后退按钮后不能看到之前的数据；
) w. z3 c; K, K( S. `2 一些手持设备（如手机、PDA等）现在还不能很好的支持Ajax；
3 用JavaScript作的Ajax引擎，JavaScript的兼容性和DeBug都是让人头痛的事；
. q" t) T5 Y/ f& H8 }4 Ajax的无刷新重载，由于页面的变化没有刷新重载那么明显，所以容易给用户带来困扰――用户不太清楚现在的数据是新的还是已经更新过的；现有的解决有：在相关位置提示、数据更新的区域设计得比较明显、数据更新后给用户提示等;

7 ^" L' q/ J4 F5 I怎么做？
9 V' j/ K5 S2 g1 C) N' l* A) W<script language=”javascript”>

var req;

5 a) O. |3 _+ t& h- M8 V6 O+ efunction add(){

//1:创建用于传输的对象
% t2 U' R/ e5 h5 ]! ?  \/ s
req=new ActiveXObject(“Microsoft.XMLHTTP”);
, o7 L: y# `' Q. ?  M7 _
// 声明返回后，处理数据的方法
; N0 B; ]9 X# ]% e5 I
req.onreadystatechange=manage;

8 M% Y6 f2 }4 Y0 p* _//2:准备传输的内容
9 L2 v  D; Q- `& z* u* o
4 O+ R; ]. l$ e" O7 S* svar str=”test1111″;
) g5 u4 R8 o. Q( e% _- [$ v
) O6 O: m/ Q4 r//3:发出请求
9 @1 v& \7 W1 z: G; j1 r1 U! r8 b( S
( {1 G: J! X8 W% vreq.open(“GET” ,”/others/ajax/test/t2.jsp?str=”+str);
% }4 L" u7 F- w
req.send(null);

}

( i6 ]: b; a* z. {//4:接受返回并处理
2 Y6 I5 z. Q0 D7 k% z
; Y1 u8 L+ c1 G, t3 D3 z6 Gfunction manage(){

- q, _$ {  M. c4 q. C9 [1 q. ]8 b) Wif(req.readyState==4){

' X4 D6 p! ]- h+ f: e6 a) F0 palert(“r==”+req.responseText);
9 j: E9 c; f. b, {
}
+ ?2 U1 V; M( i* o4 Q+ T; S( O
1 s7 W& ?+ Q* \* P}
% O4 F3 r' n# h, c
</script>
+ s! Q5 w" w$ A; ?# L3 H) E( B
readyState的取值如下：
) R( S2 R  D+ r: c3 S0 r: l
　　0 (未初始化)

　　1 (正在装载)
  f2 k3 _4 P5 a! R2 f( g
! l& p. s* Z; M  d0 J  f3 L　　2 (装载完毕)
8 _4 X3 ~- C# f$ A9 w5 l, f& ~
　　3 (交互中)

: ^3 ], w, @+ K6 t　　4 (完成)
# @8 d+ d6 c) `


原理
Ajax的原理简单来说通过XmlHttpRequest对象来向服务器发异步请求，从服务器获得数据，可以是xml格式，也可以是一个字符串，然后用javascript来操作DOM而更新页面。
2 X! w- S  R; j4 C6 q/ A
: X2 \) d0 \3 iDwr
是什么？
- u5 E- j; |  C& h- fDWR（Direct Web Remoting）是一个开源的类库，可以帮助开发人员开发包含AJAX技术的页面。它可以允许在页面中使用运行在WEB服务器上的JAVA函数,被调用的JAVA函数就像是在页面中JavaScript方法一样。
2 A! u. d( m) A2 |  l; E+ g
; d& U1 Q- R; O" `有什么？
它包含两个主要的部分：允许JavaScript从WEB服务器上一个遵循了AJAX原则的Servlet中获取数据；另外一方面提供了一个JavaScript库可以帮助web开发人员轻松地利用获取的数据来动态改变网页的内容。
3 o/ N1 n# b1 T) z0 `+ @! G  t( S


能干什么？
动态地把java类生成为JavaScript，感觉调用就像发生在浏览器端，实际上代码调用发生在服务器端，Dwr负责数据的传递和转换。这种从Java到JavaScript的远程调用功能的方式使DWR用起来有种非常像RMI或者SOAP的常规RPC机制。
% f: x' o  d- U/ y9 E. H( p

7 t/ ]4 O# T% A# b5 [9 K6 f0 i
怎么做？
6 u0 ]# h) P3 c7 F$ Q( h" D1 w① 编写配置文件

# @5 r9 ^2 @3 Q9 y$ V! kweb.xml
4 B( i( j7 y  H) o! F4 q
<servlet>
9 N5 _* I, P0 g
0 J2 w% v; U+ S8 r<servlet-name>dwr-invoker</servlet-name>

<servlet-class>
0 x4 C5 O1 g  q' F2 V
org.directwebremoting.servlet.DwrServlet

</servlet-class>

3 c  x) W8 p& D3 z& D0 \4 j<init-param>

' j" T) Y9 v4 _  `! h<param-name>debug</param-name>
; e3 }' d+ G& P1 C  t) h6 n
3 W( M0 \5 P# w7 ^<param-value>true</param-value>
0 u: W5 \$ e$ U& f7 \2 b
: C* k7 ]" E( A5 c0 I</init-param>
* Q2 ^) f( k: b. a. F( N$ T+ J3 x
</servlet>
+ }, Z8 r9 ~* Y0 S
1 f9 H8 M' @. z& E; q( A<servlet-mapping>
! t. ]! s: p: L( X7 n# _3 s/ w
6 J. }( Q  [+ k# S<servlet-name>dwr-invoker</servlet-name>
0 `4 J+ y& I- Y% v+ r+ m
$ T$ g7 p; d: `" N+ q: m' s! G4 K1 g4 a<url-pattern>/dwr/*</url-pattern>
/ I' U: e# ]) [
</servlet-mapping>

dwr.xml
" u1 M* A- m" N5 |
; N# {1 X+ B2 J, U<allow>

<create creator=”new” javascript=”kc2″>
$ a( i. W0 v) }; b; ]5 O4 X/ H
<param name=”class” value=”dwr.Service” />
. I, {( `1 b" {7 ~2 K1 K( T0 M5 z
1 q/ }+ |5 q, m</create>
* t) {' r& Q' @, r* |
</allow>

②编写service

public class Service {

public String sayHello(String yourName) {
, _0 s8 R; u5 F9 `
! c. g& W" N' @0 f+ t//可以是访问数据库的复杂代码
3 u) o$ G0 S$ E: U; a& N; ^
return “Hello World ” + yourName;

}

}

③测试DWR

3 c% i  m& L) Z将代码放入应用服务器（比如Tomcat），启动。

然后在地址栏输入http://localhost:8080/你的工程/dwr
! u) D. d  l* b$ T6 y, u
7 G) P: M/ a2 d: r0 t0 k+ w④编写jsp页面
2 U4 u) H* h# Q. P
1） 要引用3个dwr的js，其中engine.js必须要，如果需要用到dwr提供的一些方便的工具要引用util.js

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

" j# i8 D( n1 \; e$ B5 L3） js里的service.sayHello和java类的那个有一点区别，多了一个参数，用来得到返回的数据