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

admin

JEE
* V4 E  Y+ ]. i* K0 z简述JEE
JEE　： JAVA　 PLATFORM　 ENTERPRISE　 EDITION
8 H' z. j4 {1 W) [7 `# V' l
JEE是一个规范集；
& d, D' S+ q& S  u
- I# _2 I  u1 s% c: V- G2 YJEE是一个框架集；

JEE是一个技术集或API集；
8 ~* W3 k8 @% [3 X+ C" m0 d
" q8 ^; ~6 A1 f适用于创建服务器端的大型的软件服务系统

0 M; r, g. ^( a8 i6 L& T: o/ g
3 f+ w/ b; S  U% w( i, |! A
6 u; m8 L" A4 n: ~/ m& dC/S B/S 模式
- e, d- M0 n5 V6 F$ ]2 DC/S client/server即客户机/服务器模式，客户端也参与程序的运行与计算（富客户端、胖客户端）

B/S border/server即浏览器/服务器模式，又称为瘦客户端，客户端不参与程序的运行与计算



企业级应用（大规模的应用）的特点
7 v7 p! Q( g2 d$ m; w) R9 R( E: B1.生命周期长、稳定、可靠
( L' w) w! |6 m) s+ g. {5 E
2.组件往往分布在异构的环境中，能够跨平台

3.维护性、扩展性、重用性
6 P( U( ^- O/ E) u+ U
9 R8 M% W' ~. \7 X$ B) Z+ m4.有事务、安全、线程



什么是业务逻辑？
: g0 u) D2 K) a4 ?# A9 p+ M3 j依照业务逻辑划分模块，
& F% x/ y1 W) Q* N/ ]: Q
所谓判定业务　就是具有以下特征：
8 s% o+ [$ M- Z" Z. h+ ~
$ {3 s% f$ l, F6 D" c( Y9 n1.业务流程
1 H  {5 P* A: k0 V7 O. k
! s9 J9 M9 G$ q9 w2.业务判断

3.功能组合

. ^# ^# n1 B2 ]% i' ^" o
! }2 f& D9 ^7 v$ T6 L; g
平台（角色）的划分
; X- L5 \# K$ i6 r1.平台供应商。提供满足API集实现的厂商（BEA weblogic IBM webshphere）

2.组件供应商

3.组件装配人员

4.部署人员

2 x3 ^% j* b+ @; P0 c: g3 C5.系统管理人员

; A8 c: d6 l5 ~- W! @' C! @$ Y/ z6.工具供应商 提供开发组件所使用的工具（Jbuilder、eclipse）
3 L0 B6 Y8 z( T' m5 l
) u* n  {6 I% X) e
3 D- n: H5 M; F7 ~' G# u
java技术分布（设计架构 模块内部设计）
1.表现层 Servlet、 Jsp、 JavaBean、 Taglib

2 D: W: O* `2 o$ _2.逻辑层 EJB(SessionBean)

3.数据层 （　JDBC 　EJB（EntityBean））
; ~( O# `7 y7 k( x( t% S  P
4.服务 JTA（JAVA事务架构） JTS（JAVA事务服务） JAAS（JAVA授权与验证服务）
& s7 e% x# Y; L# L& [# X
0 I( c- H. Z; [1 t1 B" @5.分布式通讯 RMI（IIOP）+JNDI 、JAXP（JAVA 的 XML 架构）
% W' C5 P6 s3 Z
JAVAMAIL（邮件服务）、JMS（消息服务）、IDLC、JCA（JAVA连接器框架 （成））

& }; D3 l( l+ R/ O1 M* x2 R3 h

JEE的体系结构： 是一种组件的体系结构
. J% u0 V7 G% p5 Y5 Y& Q1.组件 ： 能够完成一定功能的封状体（独立的功能的集合）

不能单独运行，必须运行在容器上
  X4 c2 i8 `$ O- X  _
分为两类：web组件、ejb组件
& N9 u) t$ u& y0 p9 M7 r7 M& ~9 n
6 p2 _/ ]1 T6 d" u) F$ X& I. x% v+ p2.容器 ： 提供组件的运行环境，并对组件进行管理（一段程序）
2 c( j" s$ X& A1 H  F  s2 |* S
, }- G+ P4 I# A管理组件的生命周期
$ C2 N4 F) i) W: ]5 Y$ C
不能单独运行，必须运行在服务器上

9 ?, T3 B; f8 q# \& {程序（组件）通过上下文来调用容器（context）
1 L# O! d1 ~1 q# h
0 T! x5 G. h- q' ^组件通过web.xml向容器描述自己，使容器能够认识组件
9 }$ |1 b, C: w$ _! L
6 [6 j9 h" Q  h4 X1 T) A容器通过回调方法来调用组件

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

3.服务器 ： 提供容器的运行环境，提供大量的JEE基础服务

& S0 i  d& S! z2 t8 U9 O; N3 Uweb服务器（只提供web服务）
2 `  x  ?' t$ y# `5 S
jee服务器（提供web、jee服务）
1 A3 j4 H2 a! F1 Y
) ^$ ]- P4 Q, ?$ O/ y+ c' M8 a
" ^7 V/ L0 U2 x* P9 h. C1 y5 Q
+ R5 F; J  G  n什么是回调方法
  |5 @: e- l2 N& v- V0 T% L由容器自动调用的方法，就叫回调方法。
+ F* g$ X" L8 B$ J/ _, @7 ^  ]
5 V( U4 o3 m1 E$ a
5 I% S# b  F2 E* d
ＲＭＩ远程方法的调用机制
# f) j& ?- \# k7 z' e3 y7 \/ y例如：Ａ主机有Ｂ（）方法，Ｃ主机有Ｄ（）方法，Ａ　想调用Ｃ主机的Ｄ方法
1 f( d# w, |1 y6 u. Q
, J6 c( f7 p' C' E2 }0 s0 @( j" j. L
4 J! b% w) E* b

% y, O. V1 x  s+ Z. Q: r
8 Q! l3 V8 q" B4 f* h学习方法
. i* O9 @: A: i  p3 J1.规范（熟记） 2.熟悉API 3.多练 4.多想

admin

Servlet

•     描述war包、jar包、ear包的结构
  : t7 G' ~" l& w$ L; c* Z
  ! M, X5 o! X4 J& P7 ]3 V
  ; X' W" E0 Q/ R( R" O5 r, C/ r

war-                            web文档压缩包

—WEB-INF

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

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

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

) C+ j5 K: \) {( a6 [

jar-                             java文件压缩包

—META-INF

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

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

–META-INF

—Application.xml 配置文件

–*.war

–*.jar

9 `( t& z$ d9 B9 l  J

• 什么是servlet？servlet主要做什么？
  
  1 ?6 ?- V, s3 S3 h5 I) a
  * w; c1 {+ d, l. _5 O

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

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

: `& z, ]6 N# `2 u% s  {9 G/ r; `1 k

• servlet 与cgi相比的优点？servlet的缺点
  
  
  3 P$ Z+ A5 v+ N1 i, c1 G" {! q

优点：

性能（线程比进程更快）

可伸缩

Java强健且面向对象

Java平台独立

缺点：

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

• 常用的servlet包的名称是？
  
  6 [" A+ b; b; k
  

javax.servlet

javax.servlet.http

7 {$ j( M$ N7 z  `) G( Q2 o, h

• 描述servlet接口的层次结构？
  
  " R, |+ w6 A! ^+ S2 ]
  

Servlet

–GenericServlet

–HttpServlet

–自己的servlet

ServletRequest

–HttpServletRequest

ServletResponse

–HttpServletResponse

1 C0 l/ r/ u0 d% w! G

• 对比get方法和post方法？
  8 y3 {( C+ \& @: r
  
  - w" q2 d5 O/ D) t

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

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

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

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

• 归类描述HttpServletRequest接口都完成那些功能
  1 p2 @% x  t' K4 A8 P9 i
  
  
  • 读取HTTP头标
    0 d& d/ S* }2 ~+ Q! [9 L2 N
  • 读取cookie
    2 e! w! h, q0 Z8 g
  • 读取路径信息
    " G- J) x: n! s$ K% K
  • 标识HTTP会话。
    6 O; v  r2 X* G6 o
    # m) z: {4 ]7 z3 I6 \6 T# s

9 ?% |$ k: \/ B: b. F9 Z. r

• 归类描述HttpServletResponse接口都完成那些功能
  
  
  " H. J/ t7 ^+ F& F  H
  • 设置HTTP头标
    6 e$ ~) q' V7 b" f8 F( g  f
  • 设置cookie
    6 d0 o  j9 P/ X3 Q" S
  • 设定响应的content类型
    
  • 输出返回数据
    
    , U7 c( }: K4 V

• 描述service方法所完成的基本功能？默认是在那里实现的？
  
  0 ?( o! V4 f+ Q7 `1 U
  $ _: i( Y6 K# T% ^: ~: I8 U. r

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

实现：默认在HttpServlet类中实现

• 如何开发自己的Servlet？描述应该做的步骤和每步需要完成的工作
  . ~& x( h' F( S3 S+ _
  4 S  ^/ }" P+ C  r. T9 @" x- e
  

1.引jar包

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

2.开发servlet类

1)首先继承HttpServlet

2)重写 doGet( ) doPost( )

3.部署

安装web服务器，例如Tomcat

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

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

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

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

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

4.启动服务器

• 为何servlet需要部署描述？
  4 u, O$ D, Z8 l
  / s7 k! l1 g( m7 j/ [
  

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

• Servlet基本的描述应该是？请写出来
  8 O1 G& T# h  H& y! W
  
  

<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
  
  % _- R) v' G$ w
  

FORM标记

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

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

语法：

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

{HTML form tags and other HTML content}

</FORM>

. r  W# f1 v+ |/ g$ b: T

• 如何接受request中的参数
  
  String userName = request.getParameter(“userName”)方法
  
  , m. h1 l8 R: h+ [2 v( R2 C! }1 z5 Y

• 如何接受request中header的值
  
  6 r- `, v6 R7 X3 O) z
  

request.getHeader(name);

request.getIntHeader(name);

request.getDateHeader(name);

request.getHeaderNames();

  X+ h. Q! v7 I9 ]" z7 i4 a* y

• 如何输出html
  & ?1 y7 t" |, a
  
  * ]8 w- |3 p% S$ I9 y  H

PrintWriter pw = response.getWriter();

pw.write(“<html>”);

pw.write(“Hello”);

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

! R- B/ `5 O0 M- [

• 如何设置输出的contentType
  . V4 l8 T; `6 ^; \
  # g5 S* r3 J6 n, c- S
  % D4 C6 x" ?5 a  ]" a

response.setContentType(“text/html”)

6 F1 J# e5 G6 _4 A& O1 n" R

• 描述servlet的生命周期？
  . P* `0 I; _% [* T# T/ v' ~6 z
  
  

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

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

5 R2 w( q- c6 N

• 描述init,service,destroy方法的功能和特点
  0 `  E' `$ ?& I' C. r4 U: _5 y2 v) m
  
  

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

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

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

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

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

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

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

• 什么是回调方法？有什么特点？
  $ b6 J. f6 e. f$ q3 i# U3 A. @
  & U+ R8 o; V. V. }9 h9 j$ N- B2 m
  

由容器来调用程序的方法

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

6 H; U4 i: F4 D0 X* }+ y# D- n$ E

• 如何设置初始化servlet的参数？
  
  在<servlet>中添加如下配置
  
  $ L* t* h  S8 ?3 x

<init-param>

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

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

</init-param>

$ m" H9 W: G5 Y  q  k& _/ d+ e. Z/ o

• 如何获取servlet初始化的参数
  6 U7 i# G( d# J# Q* v' W- X; ^
  
  + ]1 X6 V  K% n( d' A

public void init() {

greetingText = getInitParameter(“greetingText”);

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

}

; T0 h! R7 e1 T

• ServletConfig接口默认实在那里实现的
  % K3 x+ w! o7 K' X$ e
  
  # H, c% d. _- o- u+ v4 g4 B% z  M

GenericServlet类实现ServletConfig接口

1 W" l3 B/ j4 k) Q8 H" W: `! y

• 什么是ServletContext？有什么作用？
    k% H- n" \( t5 t+ E
  
  

Servlet上下文

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

  ^- C  f/ r$ l/ ^# @/ {5 m7 ?

• 如何访问ServletContext接口？是在那里实现的？
  
  * M/ W1 k3 g) X% E, y
  . L3 c7 X$ P/ @: B5 ]

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

GenericServlet类实现了ServletContext接口。

• ServletContext接口的功能包括？分别用代码示例
  4 K- I7 X8 p& W& D/ e0 R  u
  
  3 ~: v2 G: J7 i: V) 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的参数？
  
  
  

<context-param>

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

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

</context-param>

• 如何获取ServletContext设置的参数值？
  
  
  $ }' U% X7 h- I1 K

ServletContext context = this.getServletContext();

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

, F5 B$ P3 Q' d0 \

• 描述Web应用的生命周期？
  
  3 p; R$ y5 F  |6 |: Q8 V2 H& K* |- T% P
  

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

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

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

• 如何用代码实现监控Web应用的生命周期？
  + J% v0 a0 Q+ w
  - m3 b( I; {8 b% Q) Y) h
  , @( @3 a& C5 c4 x5 H6 E, K$ o* ^
  4 N; E6 M* K2 r0 b. z2 G

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
  
  / H1 G# a/ f( z( }+ A7 X
  400 Bad Request//错误请求
  401 Unauthorized//未被认可
  404 Not Found//没有创建
  500 Internal Server Error//服务器内部错误
  
  

# v) q  p( d/ U: j$ ?6 `5 e8 r8 I

• 描述Web应用中用声明方式来进行错误处理的两种方法
  
  ( o6 |8 ?6 h' m; s6 @0 _  R! ?
  7 L3 F6 r. o7 U; T# I

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

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

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

• 描述记录异常日志的方法，都位于那些接口？
  ( c: F7 R' g6 Q% y
  
  9 X8 |* N% Y- @5 `* K4 e, u

GenericServlet：

log(message:String)

log(message:String, Throwable:excp)

ServletContext：

log(message:String)

        log(message:String, excp:Throwable)

• 什么是会话？
    k3 k; O( O8 q
  6 k1 o9 u. H) j8 J& Z. t3 P
  2 D8 L5 P# `9 [7 r  l+ D3 ~: y6 B

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

4 G; f2 P! w6 ]2 h

• 如何获得会话？
  % ~, U% `3 z+ O* Q+ s( W5 D4 q
  
  HttpSession session = request.getSesseion( );
  
  $ m2 x- b; O. r* n  ]

• 会话Api的基本功能？
  
  , b8 L3 y+ }2 H, F
  

getID() :String

    isNew() :boolean
& |2 I9 t- w  g4 u) f

    getAttribute(name):Object
7 f  _6 J' r% @8 ]

    setAttribute(name,value)
4 E5 t5 Q- i) Z* z+ l

    removeAttribute(name)

• 如何销毁会话？
  
  
  0 ~) ]  w$ n! f6 p

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

<session-config>

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

     </session-config>
" Z/ C6 k( S4 b: Q4 t" |

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

invalidate()
' u9 U% Q5 A  j5 F& S

     getCreationTime() :long

    getLastAccessedTime() :long

    getMaxInactiveInterval() :int

     setMaxInactiveInterval(int)

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

    client server

! V: G9 K4 z- Q* z  n

request

response (sessionid)
  V% i0 C" `6 I# d' C/ {0 B) j( ?

request (cookies)

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

0 W$ c8 F5 `- i: k4 H. y

• 请描述session和cookie的异同之处
  
  8 c: ~4 Y* \3 }( G
  2 d: c- A4 f% T8 e' V

! o, ~. X5 u" z2 s- C$ \2 j
) G- L6 E6 R) a

• 如何读写cookie，代码示例
  4 R1 B* L9 L6 s3 U
  
  * i- W& }$ g1 p7 c

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

response.addCookie(c);

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

        for ( int i=0; i < cookies.length; i++ ) {
! R+ U/ y% o4 B% i9 h; k3 p' f

            String key =cookies.getName();

String value = cookies.getValue();
* q7 ?1 V0 Z  ]! s

System.out.println(“cook”+i+“:key=”+key+“,value=”+value);
7 X; `6 [) s1 _3 {! Z6 a

     }

+ x! p' u3 Z3 r2 E) \2 ]

• 什么是URL重写，如何实现，代码示例
  . Z& m) N* X) ]" g
  
  

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

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

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

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

; i& d% W. p) r( f/ T
9 v; F* s$ l, g" Q9 t. e

• 描述web应用的4种认证技术
  
  ) a( ]+ X7 [- l& }# V/ U9 e6 J
  

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

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

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

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

+ f0 h4 f' U; p4 ?, r

• 什么是授权，什么是验证？
  
  
  

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

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

• 什么是HTTPS
  ; O: Y1 R  E: ?) |# c  p2 J
  4 B: }! Z' J) |: m" i$ M" s
    ?# c. p3 q7 ^

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

* T6 S; R* b, S  N+ _

• 什么是审计？
  
  
  

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

: n' g& F" m. }% U, A

• 如何实现声明性授权
  $ Z" K3 ^. M- V. d2 `
  1 g5 l, i9 |: L
  4 O- a3 P1 u# t

1、标识web资源集

2、标识角色

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

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

在 web.xml里配

• 描述servlet并发问题？
  
  6 t% o$ I7 |- ^9 X
  

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

$ z, p9 o" y5 |8 B$ H2 B

• 描述Web应用中的六种属性范围
  
  8 W. l- w8 S2 H, E  D
  

局部变量（页面范围）

实例变量

类变量

请求属性（请求范围）

会话属性（会话范围）

上下文属性（应用范围）

5 z# J0 f; f/ v" y

• 指出上述六种哪些是线程安全的
  
  
  & _: ]% f7 Y7 z5 k$ n/ a. \

局部变量和请求属性

• 什么是STM？如何实现？
  ) f( k; H& Y. ^! X& g8 x! B8 @5 Q
  
  

SingleThreadModel接口

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

+ I" q/ _+ K& U; t

• 如何实现并发管理？
  
  * c: T! i  u( O2 v% p# \
  

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

使用synchronized语法控制并发

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

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

" j/ Z8 E: J- S+ A

admin

Jsp
7 P, W* v& @$ h什么是Jsp?
Java Server Page    结合java和html在服务端动态生成web页面的技术
  y7 Q6 x! ]' O% N


描述Jsp页面的运行过程？
第一步：
9 X8 K4 F$ v% F% v/ h( |
请求进入Web容器，将JSP页面翻译成Servlet代码

第二步：

9 I. Z+ c4 r. E; M编译Servlet代码，并将编译过的类文件装入Web容器（JVM）环境

第三步：
/ V: F+ o, M8 c! `8 _
% v' S$ b5 H+ ]3 c2 H( hWeb容器为JSP页面创建一个Servlet类实例，并执行jspInit方法
" I; ?# o- ]# Y- y; _
% l6 {/ r7 q" n$ Y1 i+ a- `6 R' A第四步：
, E7 \: T, p5 z- |; l0 k9 L* ~) Q
Web容器为该JSP页面调用Servlet实例的_jspService方法；将结果发送给用户


& C- k1 I5 I' i$ P6 y* P& B
描述Jsp页面的五类脚本元素的功能、写法、并示例
注释 <%– –%>
5 ^' N: H: Y% d' q7 m
' k* B9 w3 M. h  B% [2 [<HTML>
; j* G/ L( [$ v4 W, p; J3 R( {% U
<%– scripting element –%>
4 W6 h: K9 Z# e- p3 H' W" c* G2 p
2 q3 n4 @3 W4 e4 L! [$ @</HTML>
( u8 M8 C& n- x4 ^: u* U% r/ ?
$ _2 {$ T$ Z" P; k0 J* }, J指令标记 <%@ %> 指令标记影响JSP页面的翻译阶段
' ^/ P& w& j) \
<%@ page session=”false” %>
9 L2 B2 e& y' C( U8 Z1 F
声明标记 <%! %> 声明标记允许JSP页面开发人员包含类级声明
: A( u- W& @4 t, j! P! S& u( V  _
<%! public static final String DEFAULT_NAME = “World”; %>

    脚本标记 <% %> 脚本标记允许JSP页面开发人员在_jspService方法中包含任意的Java代码

/ r* ]+ A7 o# {2 ~; f    <% int i = 0; %>

表达式标记 <%= %> 表达式标记封装Java运行时的表达式，其值被送至HTTP响应流 <B>Ten is <%= (2 * 5) %></B>
8 J# ?: F2 m# H+ a8 }3 k

% Z  ^5 k0 n$ e2 {
描述Jsp页面中的注释种类和写法
- U! J. j  o9 R: qHTML注释

! J% g1 M1 {9 a& x4 O* {4 C<!– HTML注释显示在响应中 –>
8 V% w- G$ @& ]5 r& k$ k( @; e; ~
+ v# w' t' A4 c2 W, k. zJSP页面注释
5 N* R' R1 O+ z# Y2 R) S; E
. q/ I4 k( u3 @5 s1 X; q9 b<%– JSP注释只在JSP代码中可见，不显示在servlet代码或响应中。–%>

4 B  {: E1 K' m+ x9 }2 Q& |Java注释

( g' t( C. d5 G, G6 }0 r7 r2 o<%
: ~! T' h0 X4 I2 X
# X9 F. g: _% ]5 l$ w  l0 p/* Java注释显示在servlet代码中，不显示在响应中
1 w* K. v" E2 V) G
*/

%>

0 Q: ^" B5 I3 t

6 s- G# q+ i- u! k2 P: M描述Jsp页面的指令标记的功能、写法、并示例
指令标记影响JSP页面的翻译阶段

<%@ page session=”false” %>

<%@ include file=”incl/copyright.html” %>

6 y) [* l; p; g- g+ k7 W<%@ taglib %>
. J% ?" n, ?; z- W

. J3 ^" t* ~, o
描述Jsp页面的声明标记的功能、写法、并示例
2 E% L% d; I: k声明标记允许JSP页面开发人员包含类级声明
: U3 I; o7 b# u% K2 q, t
: [& `9 y" T4 _% h/ s写法：
* \. S* a; j/ }" E% N: q6 O. N
<%! JavaClassDeclaration %>

例：

/ R; H* r5 e2 U# s+ l0 u$ \3 [<%! public static final String DEFAULT_NAME = “World”; %>
- v( a. L: ], ^
<%! public String getName(HttpServletRequest request) {
2 |" m0 E/ a8 [: k2 a
, M$ ^& x% }' Y, V' y" creturn request.getParameter(“name”);

% X9 u8 z& a+ c$ @+ t. x}

4 |2 O# ]! C. U4 ^( ?%>

<%! int counter = 0; %>
6 d5 d0 _+ r, z# i/ Z0 y) p
* e2 O- |9 l) {6 p8 j% _4 ]

描述Jsp页面翻译成Servlet的规则
0 R. n0 e7 t' Z" ?jsp中的注释标记被翻译成Servlet类中的注释
6 R0 l& L3 J8 @; J  x
jsp中的指令标记被翻译成Servlet类中的import语句等

jsp中的声明标记被翻译成Servlet类中的属性

: p: `3 i+ G* y- ?jsp中的脚本标记被转移到Servlet类中service方法中的代码

$ t9 Q: t" p+ c$ o* V/ {. c, ajsp中的表达式标记被翻译成Serlvet类中的write()或者print()方法括号中的代码
$ }: j) q" B3 M1 Z
" N8 H7 M* S+ k3 Q/ l9 _4 V. b
8 q/ f2 d* v  J8 D
描述Jsp页面的九个预定义变量的功能、用法、并示例
& \4 d. s' D1 vrequest 与请求相关的HttpServletRequest对象
; y3 r" T7 L' e8 ?. u# A
response 与送回浏览器的响应相关的HttpServletResponse对象

7 x% T, s, v' D2 c, cout 与响应的输出流相关的JspWriter对象

5 Z  j" ]7 x, a( c4 }    session 与给定用户请求会话相关的HttpSession对象，该变量只在JSP页面参

与一个HTTP会话时有意义

1 g3 J+ G* q' i5 i9 z. _1 Z2 I$ _1 i    application 用于Web应用的ServletContext对象

7 {7 J- }* X& W1 U8 ^% W. Yconfig 与该JSP页面的servlet相关的ServletConfig对象
; {0 h8 i* D7 b5 D
; [6 Q8 w% @* s: b& kpageContext 该对象封装了一个JSP页面请求的环境

3 _" p' r1 T! ~page 该变量与Java编程语言中的this变量等价

    exception 由其它JSP页面抛出的Throwable对象，该变量只在”JSP错误页面”中可用

7 D  a2 p3 \' \# I
, c2 x. w5 v" M$ c6 ^' g+ y1 J
page指令的功能，写法、并示例，并描述它的如下属性的功能和用法：import、session、buffer、errorPage、isErrorPage、ContentType、pageEncoding
; d$ t9 I2 ~+ I& Himport import 定义了一组servlet类定义必须导入的类和包，值是一个由

0 U) o# c) z2 y3 m1 T& L0 ~! o逗号分隔的完全类名或包的列表。

" i% j+ p2 e8 D3 s% G3 [session session 定义JSP页面是否参与HTTP会话，值可以为true（缺省）
+ G6 K2 [  G5 ~" l" ~7 e
或false。
/ P. v9 M4 Q( o/ w4 }9 b
buffer buffer 定义用于输出流（JspWriter对象）的缓冲区大小，值可以为

none或Nkb，缺省为8KB或更大。
4 B/ D. a% Y3 t. P8 t" N
errorPage 用来指定由另一个jsp页面来处理所有该页面抛出的异常
. D1 A3 q: l+ O0 P# p2 T
# W! F* N. l( k! z% }0 p( B5 GisErrorPage 定义JSP页面为其它JSP页面errorPage属性的目标，值为true或
7 L) U1 Q! W# m* H
9 n. D/ ]  s* xfalse（缺省）。

$ q' O: L. {0 Z# g3 [2 N! W; q* _ContentType 定义输出流的MIME类型，缺省为text/html。
& `" l5 M" N$ O
4 b; g( z2 d4 r6 }$ GpageEncoding 定义输出流的字符编码，缺省为ISO-8859-1
1 F3 }  v+ m) P' d8 ~1 x4 \' o  z3 Q* B
7 u. u4 m4 L$ p; Z9 C

' r. e8 G9 m) c) m+ T% |, {描述MVC各部分的功能？MVC的优点？MVC的缺点？
MVC各部分的功能：
2 V+ ?. h7 O1 V- ?2 h6 C/ P
Model（模型表示企业数据和业务逻辑）
1 Y4 Y" Z! s- ^+ Y5 D
/ o" }1 T- S- O9 {( @. Y封装应用状态
6 T9 I1 [& k( I! |# V2 o. ?
: ^1 k1 Q8 \, B2 m3 G+ \响应状态查询

) u  _( k0 M4 r; Y; [" |5 X) C7 `暴露应用的功能

7 {9 ?, R9 s/ ~* uController（控制器接受用户的输入并调用模型和视图去完成用户的需求）
+ \1 o; O3 @# l, e# z
. @" G/ u) r0 `1 ?" {验证HTTP请求的数据

将用户数据与模型的更新相映射
% z* g0 G/ d1 I0 i+ E8 \3 ?& W% z
/ g, d6 E& k' u3 P) Q+ K选择用于响应的视图
  s7 f( \, w: d7 P, ^% Q3 u
View（视图是用户看到并与之交互的界面）
" d4 O$ L, i" S9 w& h
产生HTML响应
& [, ~2 p1 o6 v% _% o2 b
请求模型的更新

提供HTML form用于用户请求
* y4 |$ ~5 `9 n' T5 v; D
% K2 W" Q. d. D, D! aMVC的优点：

% B( f8 G: H& A  }( f        低耦合性：视图层和业务层分离

高重用性和可适用性
1 F& r7 t$ b* g5 g0 q6 ~8 v
  T- G1 h+ _+ u较低的生命周期成本
* z- J1 y6 j! J  ~
快速的部署
( l/ F# z2 j, _2 N, I% N. _
可维护性

( n# o' k1 s4 y9 T! k; z6 f$ H0 M有利于软件工程化管理

. R; v  p" Z1 j* j提高软件的健壮性
( D. g! m" n" X+ u, l5 N  u3 O
MVC的缺点：
" y& Q; t6 B# a; r
        工作量大，增加工作的复杂性，MVC不适合小型甚至中等规模的应用程序
1 h  p1 j9 \3 H8 {

& {" `+ E, z/ ~5 H* ?- ?% D
什么是Model 1结构，以及结构中各部分的功能
4 H  K0 a8 I" H( o结构：jsp+javabean
( Q* l0 T% @+ D" }: k1 V* @
Model1中使用jsp来处理web应用中的视图控制部分

Javabean收集参数

7 _2 B- H& m% v: ^0 P

1 `- _: r* F% ?! u% e" N什么是JavaBean?
; ^$ }; n  @" d" s用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。
- U/ f5 J+ B- `
! O* L0 }0 `2 a# s9 J* Q
# o3 b, |$ j. E+ d( c% a) ?
JavaBean的规则？
使用get和set方法定义属性

3 {% x  s8 A' B2 k一个无参构造方法

% _; @7 M& z! M( T无public实例变量( 所有属性私有化)
$ w; s+ ]6 O8 G- p8 e
- ]9 M6 X& u% [  \, `( _* A3 f
5 X* E3 ?; y; i% C9 b+ Q( |
什么是jsp标准动作？包含那些？分别都是什么功能？如何使用？
1 i, a4 \  i7 I+ c$ c4 ]JSP页面中使用类似于XML的标记表示运行时的动作

- b9 [( _% k% D9 i& fjsp:useBean
4 W$ Q1 C7 x( H1 y; \" e
jsp:setProperty

jsp:getProperty
+ [8 A5 a. |5 L' {) A  Q
2 l- f7 @4 l  O( c9 t' bjsp:param

jsp:include

jsp:forward



用代码示例如下标准动作的使用：useBean、getProperty、setProperty
<jsp:useBean

id=”myForms”
. ]" A  {; _6 P) C; _
5 Q6 e/ k$ [5 \& |% H6 }class=”com.base.mystruts.forms.MyActionForm” scope=”session” />
4 C1 F; H" N1 H) t
- i  A1 Z6 S2 h    <jsp:setProperty name=”myForms” property=”name” />

<jsp:getProperty name=”myForms” property=”id” />

5 F3 c. R: E1 B  U# G5 ]' c4 K
; M: I: j7 C& D3 n1 J# a
描述说明Bean的四种scope
' J; R- y% R; e4 Mpage

request

session

. c% A0 j% Z0 w8 w) vapplication
3 m* p/ {3 k4 o% c! w


, d# @( M5 V7 b, f: G" _* _# i描述说明页面上的字段和Bean中属性的对应规则
id 指javabean的变量名
* f+ B1 k- L2 S; q
class指javabean类的全路径

scope指javabean的应用范围

name指所用到的javabean的变量名

    property指javabean中的属性
3 g, [) r9 D3 x7 s+ z( m

5 g+ d1 }5 D# j. _3 I
描述useBean动作的处理过程
' V6 L# @' [% m3 Y使用id声明变量

试图在指定的范围内查找对象
3 I  C7 D% {9 P7 Y. i
% E' t  b" Q2 ]! u" D+ }3 l如果没找到

5 F* d. [4 {0 A' I; A7 ^创建一个类的实例

" b- ^* M( o/ b- d执行useBean标记体初始化对象

/ |6 M! s. u& I! F  c8 z: M+ ~如果找到

     将对象转换为类指定的类型
, y5 [$ [8 v+ ]0 s

+ u# h2 T1 B$ H+ F( V$ t8 ^
' u, b. z5 ]) U2 {+ A& n. ^$ s) V描述forward动作的功能
使用脚本代码处理请求时，可用jsp:forward 动作产生一个不同的视图，

: ^+ C% F% s* w使用同一个request：
7 ~) Y: }3 X  q
* n5 K; Q( q% a5 O! ~  z* V
5 X! u& W( m! t9 I, J
什么是Model 2结构，以及结构中各部分的功能
' K# `9 V4 ~' I$ b/ I0 E: jjsp+model+servlet
8 v, a2 C2 e3 E& ]2 u
Model 2架构使用MVC模式，JSP页面充当视图，Servlet充当控制器

Servlet控制器：

% p" I4 p, C) v; q; |. f: q% m验证HTML form数据

  ]+ V! z0 p9 u. u8 r调用模型中的业务服务
, O# s/ r9 c2 [3 v" F% b
" h/ j* }4 H. P) w" P1 h存储请求（或会话）范围内的域对象

# _3 K0 [- ^- t- M7 [: g* r选择下一个用户的视图

JSP页面视图：
! X7 f% ?/ l/ k5 s3 ?% J
* M5 M' m  |% f! K/ @) P使用用户界面（在HTML中）
- n0 E; E9 w( e/ @! H) O
        访问域对象

: H; A$ }) @( H+ |! w

& N; `" `# I) \; r如何获得分发器？分发器的功能？
- C" K6 y) Z* E上下文对象中的分发器：

ServletContext context = this.getServletContext();
, B/ I5 x0 `' w, S* ^$ `/ n5 |: \# t
RequestDispatcher servlet = context.getNamedDispatcher(“MyServlet”);

* s: V1 Z% B) u6 f2 mservlet.forward(request, response);

请求对象中的分发器：
( J8 w- h0 z+ w% @4 v) A
" k* E0 Z0 |0 a, e1 ^' @% kRequestDispatcher view = request.getRequestDispatcher(“tools/nails.jsp”);
0 p- Y* H- m3 N6 [+ d0 s
view.forward(request, response);
  z1 i! i9 M: ]# f
" `6 F+ x- q6 E3 i/ q! L6 ?6 Z可以将请求转发到另一个jsp页面，并保持请求的传递性

+ b) h+ N1 q/ M/ O3 ]$ k8 i- Y0 ^

Jsp中页面跳转的两种方式？
' A9 ?+ ]5 \) r5 T5 N使用分发器跳转页面
RequestDispatcher dispatcher = request.getRequestDispatcher(“url”);

dispatcher.forword(request);

    特点：保持请求的传递（上一次请求中的数据，在下一个请求中仍然可以得到）；
7 _7 T- a% A% \0 f& X7 \
        转发的页面只能是同一个Web应用程序的其他Web组件

. ]0 O$ ]1 o+ C- a# K7 z3 O使用重定向跳转页面
response.sendRedirect(“url”);
8 k( }; a7 r" ]8 W( ^" c$ B
# u3 X( P! f+ ~    特点：产生全新的请求，（上一次请求中的数据，在下一个请求中不能得到）；

6 z! [: p) W& D8 u        重新定向的页面可以是任意的URL
# g5 R$ F  B) @6 z4 O9 x
" g, _0 `; }* Z: _* ~9 W
- u9 e$ j) d% |) b5 h+ T
4 D! G4 [0 \6 \3 f描述Jsp中引入另外页面的两种方法，并比较两种方法的特点？
+ G5 [' m8 ~' ~) g0 `<%@ include file=””%> 在编译期间把另一个页面完全嵌入这个页面,可以说是一个页面

在这里可以共享变量
+ p$ L/ y: L, n# W0 ?5 @' H3 \
<jsp:include page=””> 动态的再运行期间把另一个页面加入这个页面,可以说是两个
" `2 G( {6 A  E3 }1 A/ J
) Q& l; W2 H/ |* l6 f页面，不可以共享变量

. V% r; I7 O+ P; Q0 w

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

包括：
3 Y& f: f2 q) d6 h5 O
一个标记库描述符文件（*.tld）

所有相关的标记处理器类(*.jar)
7 n9 c( g6 r5 x

/ Z1 j  @" H7 p: e" @! Q5 O: G5 n# K
描述使用自定义标记的步骤，以及每步详细的工作
使用自定义标记前，要拿到.tld和.jar两类文件

9 l" r4 d/ c8 _& O0 P& n* d把.jar文件放到WEB-INF的lib里面。
! Q2 X% w5 \; }; q: ?) T把.tld文件放到WEB-INF根目录下。
) k+ |7 e' j& R9 S在web.xml中配置。
: @: L7 @/ u: M, E- s<taglib>
0 ]/ T* B8 X# |( h5 }7 n$ b
/ A2 L" h% n# h; C$ Q<taglib-uri>http://java.sun.com/jsp/jstl/core</taglib-uri>

     <taglib-location>/WEB-INF/c.tld</taglib-location>
+ Q8 |, U# V4 k  c1 B
</taglib>
. g* `# L  V- z. ]" W  n1 @# p7 J& S
3 v5 @  b' F- d4 p9 W2 P/ I" B在页面中引用。
<%@ taglib uri=“http://java.sun.com/jsp/jstl/core” prefix=“s”%>

, F! ~6 J' q  _7 `4 ~8 Euri必须与web.xml中的uri对应

prefix是前缀，用来区分是哪一个taglib

使用标记
  ], y6 R8 J% \' U% M  x格式：<prefix:tag名称 属性>
$ r$ I9 Q+ {3 d! T2 N
, ~1 U' `0 V% b. o- ^<s:forEach >

admin

在tomcat下配置数据源
) }: t# x" G: d" y, w1、服务器与数据库的连接

! X# T4 D/ P* W) w* [3 y配置server.xml文件

# g0 D1 X! W3 N- b0 g( m/ r1.oracle
( x$ Q2 Q" R4 o  @
5 z: g1 {% X8 ]4 L# _$ j<Resource name=”jdbc/company” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”

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

url=”jdbcracle:thin127.0.0.1:1521rcl”

( [( T3 ^/ \3 _4 |! H4 T" SdriverClassName=”oracle.jdbc.driver.OracleDriver”

username=”aa”
' T/ {% C: n$ t' U2 S. S$ E5 T) x
password=”aa”

2 E  _" `" N+ y1 V7 \2 N2 Y0 ~' `maxActive=”50″

* u! f! A! j4 t3 o. ImaxIdle=”10″
$ ~! |: A7 S1 }; H' ^2 H/ Y
maxWait=”-1″
7 t1 t' H6 P0 d6 l' C6 j) N
/>

  O! i& a# q2 F& \' b" w2.sqlserver

8 j" u2 m& A, u1 ]% e; Y3 z/ Q<Resource name=”jdbc/webpage” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”
1 f) N0 A$ n* t9 A8 F
6 d. `$ V5 \( ]% N( y3 j* k/ ]        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”

url=”jdbc:jtds:sqlserver://localhost:1433;SelectMethod=cursor;
5 \9 w) U$ s) R' F+ [& B; I4 p
DatabaseName=webpagetest”
( l+ w) Z4 c1 _2 B% R
driverClassName=”net.sourceforge.jtds.jdbc.Driver”

' i5 _. d& w% k* N. S; p4 Gusername=”aa”
8 E( `: k3 d( K
3 A& p4 n3 v! rpassword=”aa”

" ^9 t$ r: e9 c( b6 f: T: I% CmaxActive=”50″

maxIdle=”10″
8 T" B5 D( @9 j* s1 ]! i
  K% F  T! K, }& T; W' {$ v6 PmaxWait=”-1″
' @* s! y1 X3 u# _$ C
/>
9 B* H3 y" m. ^: f
* H0 F6 p& \$ R  H2、配置自己的web应用的xml文件
$ c7 E7 O# X- o$ k# j1 v! B; J
" |) _+ x/ u3 C3 [( H
% E! l. w2 M6 F1 T" k
7 p8 P9 V1 L( y<Context path=”/eb03web” docBase=”F:/workweb/eb03web”

privileged=”true” antiResourceLocking=”false” antiJARLocking=”false”>

<ResourceLink global=”jdbc/company” name=”jdbc/company” type=”javax.sql.DataSource”/>
7 l3 `  r7 _. y) P. R) \5 u
</Context>



2 t# Z) k( w; N, W) p- U- _3、配置web.xml文件
: |" v- m, O" [1 Q% Q- j; Q* E
与服务器建立连接

<resource-ref>

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

<res-type>javax.sql.DataSource</res-type>
& \3 B8 R" s; j. f9 ~# S
4 ?) ~# C4 k3 |<res-auth>Container</res-auth>

</resource-ref>

4、在应用程序中不直接与数据库连接，通过DataSource连接池建立连接
5 h. A# G& t" i7 T3 J- @0 j
4 t' x0 o+ X5 J* y//1.在程序单独用时设置系统的属性，在tomcat下可以不用配置，
: W! L% x+ e2 ~* M
% g1 Z& ?+ W+ r. VSystem.setProperty(Context.PROVIDER_URL,””);
3 s( R. d4 ~6 L9 N+ ?
2 b3 d0 d2 d/ e, X! C( g2 ?System.setProperty(Context.INITIAL_CONTEXT_FACTORY,””);
6 p6 D  c! i0 B# E
# T; b; Z4 J; Z1 O  C& K% B0 P//2.创建一个上下文对象

InitialContext context = new InitialContext();
4 f) y5 H( d9 p. j% z- R9 g4 q
//3.通过上下文对象在连接池中查找DataSource
5 L! U' \. @5 i- r* G. x7 ^
7 w! a0 Z1 |3 k( S( B, rDataSource ds = (DataSource)context.lookUp(“java:comp/env/jdbc/company”);

% u1 {( D8 p% z0 s0 x: E* o6 n$ M//4.通过数据源建立连接
  U5 p. a* _7 G( l4 [8 b+ _7 R$ G
; j% K1 T" V8 h, z) w0 Gds.getConnection();

admin

ORM对象关系型数据库映射
(Object Relation Mapping)

% e# P2 Q4 f: _) O3 ~; p' G6 @一、映射的特点
2 p& H8 H! N! A* D$ p* Z
+ i' }  B& Q1 C1 F( V- Z/ q1.一个对象可以对应多个表
7 V- r. U6 d9 H6 @% Q
2.一个表可以对应多个对象

# D. O: g' U( y8 z. Q3.对象和表的关系不用完全对应

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

  z) e6 k$ A5 p4 `8 r7 c+ I( y5.类型可以不同，但数据类型之间可以转换

6.对象中必须有主键，数据库的表对主键无所谓
0 ]# E9 |2 V0 g4 _+ X: s
4 e5 b! ^2 |& b: n# z( c, o. \3 U* A7.数据库中有主外键关系时，对象中可以有，也可以没有
( l, g' \6 |9 g$ }6 ^2 N" k


" _$ k6 T; S$ K# `- Y, e) @4 d二 、有一个映射的描述文件————>xml

三 、怎样实现描述文件————>一段程序

对象 映射（mapping） 数据库

user

2 D& G( h6 @) zid=11

name=”张三”———— > (1) —————> tbl_user(id,name,age,tel,address)

age=25 <————(2) <————

6 M6 k8 e) _( K

4 d, ]/ Z4 Z  ^(1)从对象映射到数据库

! c0 q9 p4 s1 ^1.JDBC

2.根据描述文件来动态拼接sql
2 _" w/ b( H2 |+ l; U
6 L: ~( v% _) f2 d1 P- X3.执行，添加到数据库中

+ B9 H' x# l3 O" N& W8 _

(2)从数据库中映射到对象
; N( w4 r  E) M0 k$ H( m9 K4 j  {
+ b8 P4 n1 [6 A$ K' @- L1.JDBC
/ i1 J; ]1 Y' |' T# s$ {
2.拼接查询sql

0 g+ @5 `5 K: k, a3.ResultSet
4 X6 |: L3 q4 k
4.Model
3 c* v7 Q1 A  T/ E/ w


# ~* \# L" m! }$ g' `! s% h* Q) Dhibernate
开发流程：

9 V3 N  G+ F: O' k) u是什么？
hibernate是一种基于orm 的轻量级的框架

6 s8 K8 }  o$ t; B: x4 H" [

  M) O! o. @; v' h. v3 A$ [) c" u! V有什么？
. h( l3 ?9 u5 B1. session 保持连接状态（依赖事务和连接池）
# W0 F& _, x: |! f& w5 w1 m% [
2. Transaction事务
! Q/ Y* [) t$ B' n1 Y( h
$ m3 {2 ?4 S) q1 k1 z! c3.
+ \7 e7 L# {2 `8 }Connection Provider 连接池
/ E4 T( F8 O( O9 D5 Q1 |# r
# A: G4 O9 b/ E7 _
8 j' z" ~0 H: x# \$ N. U
能干什么？
1.orm

8 m5 T+ `" A; b+ Z6 P# i9 I2.提供操作数据库的接口，简化数据持久化的编程任务

8 _" R/ C5 i! y7 j  a3 l( s
0 N# b4 v! d+ k6 ~9 F8 N
怎么做？
, L6 G& i9 F8 H" N9 W% e1.搭建hibernate的运行环境，将hibernate的包和hibernate所需要的包拷贝到lib 文件夹下

. _, D0 q& {  q) w3 S+ ]) z' O9 k2.O（vo）

* v) y& g% Z$ j3.R （关系型数据库中的表）
7 E% ]3 u: S! G9 l+ K1 G8 S
2 w$ S) [7 v; |4.配置文件

4.1 cfg.xml 放在classes根目录下，默认名字为hibernate.cfg.xml

9 |" y0 _0 g2 }6 y  Fa.与数据库的连接

b.可选配置
- N! e$ j4 R6 R) b
7 r9 f* E) r) u, c- O; a  tc.映射资源的注册

' J$ u3 {9 n, W- W4.2 hbm.xml文件 名字与类名相同 并且与类放在一起
3 J, f5 B6 o5 I2 R  ~( ]
a. 对象与数据库表之间的映射

" I2 f/ w, ^1 R2 h* \- X5 hb. 对象的属性与数据库表的字段之间的映射
5 X) o+ J, P6 ]( N/ R$ E% P) N
" f# `) |' K$ {* Z9 J" B7 dc.组件之间的映射

3 B% O5 O- b5 V5 b1 ^5 y3 i* U8 bd.对象与对象之间的关系映射

5、客户端

1.得到SessionFactory

/ _/ Q! g2 h1 h; O2.通过SessionFactory 工厂来创建Session实例

3.打开事务

4.操作数据库

5.事务提交

6.关闭连接

运行流程：

整体流程
: z2 D$ X2 n$ n; ^! a; F1.通过configuration来读cfg.xml文件
7 p; `6 s, R5 U# r) }( r
# o' Z) c$ L4 n2.得到SessionFactory 工厂（根据数据库的连接来创建sessionfactory）
3 \' a# ]1 d1 N7 B  |% D- `. C
6 b$ p8 i6 w# \2 V: v7 D9 @7 i! [3.通过SessionFactory 工厂来创建Session实例
7 o7 H3 T, H9 ^) ^8 W& i
6 W9 K2 I# {, ^2 b0 N4 P! K4.打开事务
( f) p1 _* b) ^  l: E% n- c9 T
5.通过session的api操作数据库

6.事务提交

; r6 s0 D5 @" Q9 h. {* S: N% ?' w7.关闭连接



) Z9 `% Z( i* Msave
1.to—>po

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

3.根据hbm.xml文件和model来动态的拼sql
* u3 U3 N- }3 j# c  U
/ C( x; n! v3 Y. P3 r4.客户端提交或者刷新内存
: U# w! c. S, ?6 n' h
5.执行sql，值放到数据库

+ P! S. p* ^# V' i
* x$ Q, \4 H7 K: _
update、delete
1.根据model 的id在内存hibernate的缓存中查找该对象
3 P5 b6 i+ X6 U& X3 n& A
3 C4 d! g- P2 ]: l7 D9 q, Q如果内存中没有就到数据库中查找来保证对象的存在

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

+ A3 S+ c, F4 g0 ~3.根据model和hbm.xml 文件来动态拼sql

  d9 R+ k- ^' g3 A& S4 U4.客户端提交或者刷新内存

5.执行sql
3 ?# v  M+ ]0 {& H* ?$ [0 l

# a+ F% s8 A4 ?, I2 m+ B6 t
Query
* K. B4 |7 G" \- }0 |; `, T' xload
6 t7 M& O7 y! u0 }
/ E: ?! ^4 H; ?! ~8 z6 S1.根据model的类型来找到hbm.xml文件
, K6 s+ B! N0 s  m. N% s  U
- q$ r% W% _4 V/ s# s2 o' T2.判断id对应的对象在缓存中是否存在，如果存在，就直接使用，如果不存在就进行下一步。
: e7 z6 \% ?( t# ~5 `$ h2 ~3 A2 b
3.用id做为查询条件来动态拼sql

1 x. E6 y( n) q; Q4 S& z4.执行sql 查询（先在内存中查找，如果没有找到（会抛出例外），就去数据库中查找）

5.返回一个model类型的对象
7 N& V- J! X: Y" o4 H
3 `- |4 i; s, _' E  Eget
' `& ~9 K4 a- G+ U/ r
    1.根据model的类型来找到hbm.xml文件

* M# W. C  b/ o" n& s2.用id做为查询条件来动态拼sql
3 |+ N! N; z0 k4 b! o" Q8 r
3.执行sql 直接在数据库中查找，如果没有查到就会返回null

query
9 g3 F7 m. I; j+ ?! Z  Y- {
) v" d9 m) s" s2 \1.分析hql语句，得到model的类型

2 F( X" }8 |3 o1 u2.根据moedel和cfg.xml文件中映射文件的注册找到hbm.xml文件
4 W- i% Z1 M% v- q# V  Y: I. O
3.根据model和hbm.xml文件来动态拼sql

4.执行sql查询数据库
  g" R. P- j; u1 Y+ B4 t5 h$ X7 O
5.返回一个resultset

) ^  D- T6 Y- P! n6.循环resultset的值，放到model中在放到集合（List）中
- A/ U- ^0 T6 y5 k! U3 ?
1 k; s7 M0 [3 Q" d- ]# y
) v1 E- O3 t( g  ]
谈谈hibernate缓存机制
- J# W, Y; {7 w4 g, R; a/ Q
缓存其实很直观的理解为放到内存或者硬盘上的一块区域，缓存就是一个缓冲的作用，有很多时候，我们的数据需要经常访问，如果放到数据库中，不是不可，只是效率上低，如果有了中间产物来代替数据库，就省很多事情了。打个比方，去买酱油，不一定一定要去酱油的生产工厂去买。代码中需要数据的时候，可以先到缓存中查找，如果存在，就直接拿数据，不存在就去数据库中取，也省了很多事。
) j; K. J; h. c: |

4 J. M4 G* r  U) ~1 B) Y: l; X
0 }/ Z* I, s2 k( |3 @hibernate使用的是二级缓存，有两个级别，分别是Session，SessionFactroy级别，一级缓存是Session级别的缓存，Hiberante来管理的，这个我们一般不用管，二级缓存是SessionFactory级别的，可以进行配置和更改，加载卸载，就是我们平时用的hibernate配置文件中的配置SessionFactory的属性。
8 N2 b! {$ }: O2 m  z( Q
! o  d" ~# i: Q" I7 K& s0 K

对一级缓存中的session事务进行数据的预存取，数据在各个session的上下文中存在（单例），当session关闭时，就是session.close( )，整个所有session范围内的数据全部清空；二级缓存默认的情况下是不开启的，如果开启，数据库汇总的所有数据都先copy到二级缓存中，这里要注意的是，一级缓存是每个线程下创建的session缓存区域，可以是多个，二级缓存只有一个区域 ，画个图比较容易理解。
# _% ?8 J0 H( a% ]1 q+ o' e


" Y$ [7 f' m, Y2 C$ p* ^) L| 一级session缓存| | 一级session缓存| |一级session缓存| |一级session缓存|

, ?/ l& B/ D+ a| | | |

% j$ }! r+ n+ E# a/ Z! [8 ~- U| | | |

2 E0 K$ o# B3 u- b5 M—————————————————————————————————

; _4 u* Y1 C* n, ssessionFactroy级别的二级缓存

——————————————————————————————————————-
  \8 h& n: T. p2 a, a
|

# ?6 d' S% ~+ ~& B8 w7 X( t% L|
+ b- f: ^' a+ }( F3 |$ q8 v- @- y/ @
- O' F) ~5 T4 N3 W/ f0 x- P( p|
3 z7 v. S+ x6 Z. L3 ?* \
——————————————————————————————————————

DB

8 v# J" P* [- a. y9 ~+ R7 v—————————————————————————————————————–
& c  L( b9 o8 t7 m6 M/ e1 m

admin

Spring
/ y3 N1 A& k! n  ?5 O7 ]5 _

• 是什么？
  
  % q0 d  J& O" E7 ^. \- \% l% v/ J

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

• 有什么？
  ) s; J& C! {5 X
  % O" P! q% m, ?% D) g4 q/ ?; k5 n

+ B7 r3 Z1 n: z4 H" }- T

每个包的功能：

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

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

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

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

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

AOP ：面向切面编成

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

• 能干什么？
  
  

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

• 怎么用？
  1 g! q/ b' I; Y0 R. }) V2 j( P
  6 f  j: c: K% X$ [, h9 z) }* t3 x9 W
  • 搭建web工程，引入spring的jar包
    
  • 在web.xml中添加如下配置
    - W, w& \/ [/ `* Z2 C0 d
    
  
  
  2 i: Y4 U/ C! [! Q. j7 h

            contextConfigLocation

            classpath*:applicationContext*.xml
# d6 ~5 t# g4 b% K8 K

   

        
4 f) r0 P( k" g2 h2 i4 ^; x6 i0 X  A

            struts2
/ @4 u. @' ]) s# F  l( W$ Q( X

            
( ]) T1 |% Y3 D! m. ~

                org.apache.struts2.dispatcher.FilterDispatcher

            
$ k+ [2 q0 B1 ?/ B; G' B# a

        

        
4 N1 T5 G  m7 H  E# n

            struts2

            /*

, z0 m: ^- E2 M! i* R) e5 S* ~# f4 @

            

                org.springframework.web.context.ContextLoaderListener

            
1 Q8 U: p0 _0 L( j2 X0 N

        

• 部署
  
  $ O+ X4 @# B2 h7 \5 \8 V

• 容器和bean
  : O  f# ]5 u( ^4 L8 s" o: f$ P

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

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

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

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

• IOC控制反转
  " X" o$ s# b+ g4 g
  & y2 V+ v; n" Y  K2 O- W% y
  
  % f) e3 G- q6 k2 K, O
  
  从前的应用程序想要得到A的实例他会直接主动的去拿，当用了sping后，应用程序由主动的去取变成被动的等待，由spring来控制应用程序所需要的对象
  
  0 k  Y* x9 I" X9 S" M& {; r. B
  • IOC的优点
    
  1.可以通过IOC来获得实例
  2.可以通过DI来获取注入的资源
  • 配置IOC的原则
    
    • 一定是可变的资源才采用依赖注入
    • 一定是层间的接口或者是模块之间的相互调用才采用依赖注入
      " F4 w3 L* ]5 z8 c( }9 g7 n" P

• DI依赖注入
  4 W1 \& x% S  ^; O' X

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

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

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

例如：

在配置文件中

( p1 T! o8 @4 K2 ?+ B
  i5 a/ i9 t! F6 u; f

在应用程序中

Public DBDAO dao ;

Public void setDao(DBDAO dao){

This.dao = dao;

}

3．构造器注入

: v: P: a: B# ?

4．ref 表示参照其它的bean

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

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

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

6.lookup注入

7.singleton

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

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

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

8.DI的优点：

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

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

( j- W+ B& _5 d% t% Z

• Aop面向切面编程
  6 a+ @: y( F: l1 c5 |% e/ i
  0 _: B. F* Z9 A

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

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

2.AOP的思想： 主动—->被动（追加功能）
2 a4 N$ O/ n1 d

3.AOP 的概念
; ]) q5 r' k8 p' w, Q1 C4 J

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

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

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

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

5.引入 ：扩展的功能

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

7.aop代理 ：实现机制

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

4.AOP的事件机制
- `, j1 K" a$ R* @/ U

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

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

3.找到切入点

4.确定连接点

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

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

3 z9 H3 l& r! [
9 M% k% Q: v( Q3 u' R
' F  A8 c/ J3 h6 m5 v
' W( d6 l4 [5 g# n$ P, B


- U% z2 e- B# v: P. ]/ e, [, q

5. AspectJ
7 Z* X; a: w/ F

5.1.在xml中配置比较烦琐
( U: b3 u, C' Y: p+ i

所有的入口必须从一个代理（ProxyFactoryBean）开始
# a8 H, y$ z1 O9 L* N# y( q

         


! F+ o% r9 w0 M0 a         
! o, }; j( I# c, M2 {! a4 u& N

        
: m& K7 H7 \5 {' f" G+ O

        

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

        
0 r9 f7 N' o7 _# y. U( y  w* Z4 }

        

   
9 j2 z. u0 M3 V& H% K. ]/ Q, Y( o

) l8 ?% J. J, b7 |4 G  G

5.3.使用注解的方法相对简单
( Y4 H3 [7 g9 t2 ]2 T) F

@AspectJ的基本语法
" Q# S; r/ I4 b" H! A0 K

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

直接在类上定义@Aspect
  `7 Z; E" ~" U+ d  B4 `

2.@Pointcut声明切入点

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

2.2、可以使用匿名的pointcut

2.3、执行切点的几种方法

2.3.1 execute（public * 包结构.*.*.（..）） 可以指定到具体的方法
; c% f: u5 H6 N% l

2.3.2 within 指定到包，不能指定到类
9 n. R8 [6 \- V( u/ h: H

within（”com.javakc.spring..*”）
4 U- N2 s1 `4 _! s# F' K" p

2.3.3 this 指定到实现接口的所有的实现类
# K3 c9 U3 `9 B8 e. e# y

2.3.4 target 指定具体的实现类

5.4.advice的五种类型的示例
) _$ Q5 r; c! R4 O0 R

　　　 客户端必须从接口走才能得到监控，实现想要追加的功能
* @4 a: c5 Q2 ~

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

追加的方法的参数名字一定要与retrning的名字相同
5 f7 R- J& H) X5 T0 v5 q" |5 N' c

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

pointcut指所要监控的目标对象的方法
! U4 ^& ~7 }' f# W

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

完成追加的功能

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

(1).@AfterReturning(“com.javakc.spring.schemaaop.TestPointcut.t4()”)
" I; t: d& Q6 P  L

(2).
9 y, I2 {, N, O9 [  ~

     2.直接引用匿名的pointcut

     (1).@AfterReturning(“execution(

* com.javakc.spring.schemaaop.Api.test4())”)
) I0 j5 V; j# \$ t1 a& b

     (2).@AfterReturning(pointcut=
6 D, a" F! a( u7 c" ^

“com.javakc.spring.schemaaop.TestPointcut.t4() &&
5 W' K8 r# m9 b2 F0 n! e8 s0 z$ `0 r

args(str)”, returning=”retVal”)
" m  [/ Z# \; n% O+ G! m  t- O1 k2 {

@AfterReturning (pointcut=”com.javakc.spring.schemaaop.TestPointcut.t4() && args(str)”,returning=”retVal”)
  t4 P# W( F+ N$ Q6 T& p5 e: \

public void testAfterReturning(String str,Object retVal){
  {1 E, f6 u# V) `

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

    }

5.4.2.@Aronud
. ^: r1 l1 T% h' r

     注解@Around环绕追加功能；

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

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

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

目标对象的方法
$ v0 r6 E7 c5 U) F

     1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
% h5 J2 K! H2 O' Z8 E* k2 Y& N6 X

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

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

&& args(str)”)

2.直接引用匿名的pointcut
% q% X# A* V! Q' G+ N

     (1).@Around(“execution(

* com.javakc.spring.schemaaop.Api.test1())”)
0 M2 F/ |/ [( B0 A, F5 |: r

     (2).@Around(“execution(
3 C9 p; b- a" Z9 n! `

* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
* g2 h( r) I9 b

// @Around(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
8 V2 U1 r& v" `% {3 U/ X9 Z) S

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

public void testAround(ProceedingJoinPoint prj,String str) throws Throwable{
; \4 s6 [4 j1 |7 _5 ]

    System.out.println(“around1==========before1pointcut==>”+str)
+ m4 {1 y* d4 k2 K. H

        Object obj = prj.proceed();

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

    }

5.4.3.@Before

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

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

(1).@Before(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
. _3 A1 T! X: h) G

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

注意args后的名称与参数名相同
. d- T7 z; f8 Q2 t4 w2 ^

2.直接引用匿名的pointcut
% K' p0 O" x* q, E$ l/ u/ D; N

(1).@Before(“execution(* com.javakc.spring.schemaaop.Api.test1())”)
; H% X  p/ |  J# }" T" X

(2).@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
/ Q: z2 ^3 @: |( V$ k- |

注意args后的名称与参数名相同
; C2 Q; Q) [' t7 n

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

@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
7 c1 [& r' q) Y1 j( y) W

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

     2.直接引用匿名的pointcut

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

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

    public void testAfter(){

    System.out.println(“after1== >pointcut”);
/ \* y; ~' s! {* D( @

    }

5.4.5.@AfterThorwing
/ v9 n1 N0 n! j! p, C; c+ v

• 描述一下spring中BeanFactory和ApplicationContext的差别
  ( e# m$ N( N/ H" C
  

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

% d) }* ^& ?5 P5 R, D

• 谈谈spring对DAO的支持
  
  

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

简化 DAO 组件的开发。
1 K2 B5 I7 l+ |; ~Spring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法，用来简化代码开发。
4 I: N1 K0 E5 S) j- b; D: e

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

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

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

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

• 谈谈spring对hibernate的支持
  
    [( M" ^2 g& c4 M# i9 k. ?: I

在所有的 ORM 框架中， Sping 对 Hibernate 的支持最好。如 SessionFactory 的注入、HibernateTemplate 的简化操作及 DAO 支持等。另外， Spring 还提供了统一的异常体系及声明式事务管理等。
- j# E/ e: m! a' a* x) k

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

1、通用的资源管理: Spring 的 ApplicationContext 能管理 SessionFactory，使得配置值很容易被管理和修改，无须使用Hibernate 的配置文件。详细配置如下：
# B. F2 e- ?' g# Y

2 v& ]( Q0 X8 C/ E; ~) k* j

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

        
4 `3 i3 q* `9 q# ^" q0 t/ }1 V" ~

            oracle.jdbc.driver.OracleDriver
% [+ G. t6 b' z" Y, S

        
2 _/ c2 ?& O7 q1 B( P  j

        

            jdbcracle:thinlocalhost:1521rcl
& r$ K# N4 R6 k& [" C$ J, m8 M

        
  i8 B, E0 {; `1 B( y

        
$ ~' Y- q+ T; b& ~% S

            javakc2
& E2 g6 j7 H) y9 q  J0 k7 {

        
8 H$ j; z+ [. W$ E! X5 X

        
$ y6 P4 m. z6 _' X1 Z0 e

            javakc2

        

   
  k0 ^3 L& ^2 h

0 t2 ?6 x* C& a

   

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

        

        
: o! |9 t6 H5 v  D5 e

            

                com/javakc/spring/h3/UserModel.hbm.xml
! }6 O4 ]1 Z: E9 ~# F

            
2 ^: ?+ d+ f/ H; j3 x! p* _- y

        
5 W) C) k. {6 @# _7 p- L

        
: R7 Q+ D; {" y& |7 i6 ~, l; ^

            

                hibernate.dialect=org.hibernate.dialect.OracleDialect

            
) b2 {( [  P0 L

        

   
. j2 Q+ V$ U+ T# Z2 i7 ~0 H/ W" z

   
2 b1 n9 D) P- ?1 e' O

        

   
( Q% ^. F+ F9 h  L

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

   

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

        

            java:comp/env/jdbc/myds

        
9 J* J! ^! Z) E

   

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

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

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

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

   

        
6 y: C: B' u3 W2 r+ m* y+ H

   
' x9 p7 s* X% D8 d$ E

% A8 ]/ W6 I1 f2 L+ S- |

   
6 \: @# e3 X% R8 d2 S

        
" |' ]9 @2 }* |" X

            
  _6 C7 o5 A( r- O

        
5 H, r4 \+ h3 m8 V" g. ]

   
1 ?7 a3 p5 R* C9 N$ P

$ h" [8 y" J) ?: Q0 p$ Q! g0 V

   

        
. |6 z/ X, }& C3 o, N

        
* C( V4 K2 Y$ t$ z; ~, W

   
1 U6 d/ Z0 ~1 y; F/ F! c: `

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

Spring2.0之前事务的写法 + A; I& O% f9 `( @( e' i6 C % T0 K; H" p5 ~; x0 ~         class=”org.springframework.transaction.interceptor.TransactionProxyFactoryBean” , v( F5 S2 G' E8 M4 y, q1 H 0 _. w( d7 Q* n! J* z& s        abstract=”true”> ) R& Y3 y2 V& Q7 j- x! f' r                PROPAGATION_REQUIRED,readOnly                 PROPAGATION_REQUIRED , C1 _9 X, P% I! B ; ?. E, |* _( A. m* b" G$ v8 E( M

• 谈谈Spring对事务的支持
  - ]8 E4 l3 b; c# h
  

1、声明式事务管理：

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

2.做法：

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

2.2

2.3 注入数据源

+ |* F0 v+ F1 w% F
; A( g' D* H! W
+ t* j) t- p. H4 r

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

5 t* w" v& G/ U; G

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

8 `2 B! x$ d- G- {

  g, c$ s' k; G) R( V; N, _
% Z/ k1 i$ I& k0 c) b

2.6 定义切入点

: c7 V) x1 \# ]8 |- |$ h) H
8 g3 y& T7 D# Y9 G; W# _$ d

# F- Q5 P+ S6 B2 T0 z/ e' J

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

1.注解@Transcational

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

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

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

3 F. e6 T3 Y9 z$ C1 K7 ]6 I! z
% |+ g0 Z/ u; ?! _

如何在Spring中使用Hibernate的事务：
9 W: o; w! N* B' G' _7 q

4 B0 U# P" Y7 o# P9 U" B

0 t$ n# k3 |) O" v

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

1 E$ ]. |8 }0 X

admin

事务
ACID
（1）原子性（A）：一系列的操作具有不可分割性，要么成功，要么失败
8 C' r4 ^* M* {* u8 m) m
（2）一致性 ：操作的前后满足同样的规则，保持平衡。

- G' r5 o: z! N" w) y1 r2 y% e（3）隔离性 ：在事务运行的过程中。事务内的数据对外的可见性和可操作性（必需由数据库的支持）

（4）稳定性 ：保证数据在事务的操作的过程中不会遭到破坏，而且是永久性存储的
2 N0 K' F6 @3 d
0 S, }3 @+ d1 `9 c  ?/ A7 e
1 Z! I5 I, G4 i
事务模型
（1）经典事务模型又叫平面事务模型（JDBC） 事务不允许嵌套
0 W* Z; L; ^6 H" s; S
（2）嵌套事务模型


5 K& g; Z. H8 g7 M6 K. Q
$ ?9 k8 R$ q& Y6 {' {3 `% ~! O6 A8 _事务的两种方式
（1）声明式

; T" V7 q" i  H7 s4 {% m! p& u0 w在配置文件中设置以下6项

! w/ k5 _" H3 h/ S（１）.required

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

, I: T; r. d) ~8 r6 ~) r8 a! R如果客户端有事务bean 中就加进去

(2)、 requiresNew
( A1 p. J/ p. C. J
不管客户端有没有事务服务器段都新起一个事务
5 X) e9 @7 O5 D8 v1 i
" @5 T3 s4 f, p. P9 O$ E如果客户端有事务就将事务挂起
3 a: M6 y0 q, k
(3)、supports
! j$ M& i7 q- x4 j# m3 I
如果客户端没有事务服务端也没有事务
! ?- `! v3 A0 c- U
6 k. h+ I7 k5 x% j# C* Q: G如果客户端有事务服务端就加一个事务

(4)、mandatcry
  C, T3 ^3 u+ [3 m6 L! y
  ^7 l+ J; o7 u- I* P& ~% X5 z如果客户端没有事务服务端就会报错
/ b. `1 ^7 z. ~2 }
& P  G' T/ k% m& x, [0 b如果客户端有事务服务端就加事务

* ?; F* }# B% L(5)、notSupported
; b: t( J! W; A( A
不管客户端有没有事务服务端都没有事务

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

(6)、never

" E" v/ E! K5 p( H% v6 W不管客户端有没有事务服务端都没有事务
: z% Q+ F/ o; a! a# f/ x5 r
如果客户端有事务就报错
& G! H6 D! \2 S! H; v0 `
) ~' g9 I+ ?, F- F+ U$ r8 D（2）编程式事务
) \+ H6 M7 Z, C# f- ^+ P9 }
- ^8 }& [! S  {# f8 j1 g7 PJavax.transaction.UserTranscation

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

; ]) k6 d6 w& t3 V! f

事务的隔离性
) `4 u5 w! i. qRead-uncommited
( z5 [& K1 p, @" Z( M3 R$ y
& N- D( S% O/ S" s' [9 L2 ?读取未提交的数据（基本上没有锁）脏读，存在不当读取的问题。
* n  Z4 j1 r% R
Read-commited

3 V5 M9 y" y# ?6 N. d' q1 S4 ^读取已提交的数据（行级锁）

无法读取已经写入，但没有被提交的数据。

Repeatable_read
; E5 e+ T. y7 W( C& G5 u
读取的数据不允许修改或删除

/ f, b6 `  p0 n3 D不可重复读（行级锁+不允许修改/删除）

Serializable
1 j; z" R4 ]. [' }( o4 t  ]4 }
幻影读（表级锁）


& @+ [% A- {+ L. }. Q( \' ~1 F
; t' `. v9 \* w4 ystruts
开发流程

1、创建表单
2 Y* t0 Y( f& w- p" I8 p
2、从表单中获得输入

3、处理输入（业务逻辑）
9 X/ l4 ]1 E, n8 |
4、根据动态输入改变输入流

要完成上述四步，我们需要创建
- t. N* h  r0 V! r# {# S4 f1 a
1、一个ActionForm

0 M. n7 R- }* ~1 C" H  m/ M2、一个action

3、一个配置文件struts-config.xml

. O$ M7 I( q0 Y3 j4、创建页面

创建ActionForm

' V$ S: t$ W! ?; }) ]/ K9 ?2 Y/ m1、写一个类继承ActionForm

& {% k# Q" R6 U; D6 D% [2、私有的属性

3、相应的get、set方法
1 o% j7 Y! R- f4 x! \/ d. }  P
4、重写tostring、equals、hashcode三个方法

创建action

1、写一个类继承Action
& t1 }8 G- I1 b6 U
7 ]2 K/ Y, V1 M/ H! H  t6 i: T2、实现一个公有的方法（回调方法）
3 p4 g+ S1 k; O3 L8 w- e2 q* {" O
" Y$ _7 o: Z$ p! x+ S, H# jpublic ActionForward execute(ActionMapping mapping,

ActionForm form,
: k  E; w6 X, U. v. h
  @9 f. E3 I% o! r& r/ eHttpServletRequest request,

HttpServletResponse response)

% ]! g& E/ R% B& v# c3 u8 o4 t{
# X# ]! B$ o1 c8 O
4 m+ K( V2 U4 v9 O# {* ^//1.收集参数
7 X+ v* H" x4 X$ i( u
MyActionForm myForm = (MyActionForm)form;
& A' w4 @+ c, ]1 T+ \
$ x* ~  {& e% m* e5 P//2.组织参数



//3.调用逻辑层

boolean flag = true;
  g7 S& R* m; w3 ^
//4.根据返回值来跳转到相应的页面
- ^* X% }* Q" T  |( r, o
ActionForward af = new ActionForward();
' ]( G4 L$ Q) f$ S
0 f! M( ?7 R2 p8 f- U4 `1 aif(flag){

' F/ O; |% t, Z5 j3 Faf = mapping.findForward(“1″);
: o6 {: U" q# M3 m
" p$ L. x* P6 N8 x+ m" a, \}else{
  F$ o/ m/ H: b
af = mapping.findForward(“2″);

( ^/ ^. C1 @: |}

+ Z1 b2 m! N4 j) t0 J+ ]( I; ]return af;

2 v% Y! k2 ?  w}

配置struts-config.xml文件
. i/ v5 c9 d# U! C" a) O
6 I/ f4 j9 r, \' ?' Z( L1.<form-beans>
# f6 [) `$ R) j- S: K' J' X7 d% P# i
<form-bean name=”myActionForm” type=”全路径.MyActionForm”/>
0 |; X0 p8 l( _0 [) _' ?! ~# F
/ x8 `5 k& Z6 L: `( [<form-bean />
( `0 R7 S- G# o6 d- }
</form-beans>
' d. I9 p- e2 Y& U+ p
  N" J# [* u2 N( N: X2.<action-mappings>

<action path=”/sll”
$ K# G. u4 B4 ~" Z$ G, U7 e
name=”myActionForm”

type=”全路径.MyAction”

1 D" J: ]& O3 f+ T1 Vscope=”session”
% S/ a. u. f- e9 n8 h
input=”错误返回的页面”>
, ~$ \1 v; K: {. }" U  I, C
- n. s* e' M6 G1 H/ Y6 h<forward name=”1″ path=”/1.jsp”>
4 m1 w; F/ o  F! m; e! Q8 Z
+ |8 m$ K, k8 B8 R2 R' h( Y<forward name=”2″ path=”/2.jsp”>
. D4 x" s+ s3 B9 o
1 q, Q' C, f1 Q, d</action>

</action-mappings>

, O7 ?9 U5 M7 @步骤:

1.创建一个空的web应用

2.将struts的包放到lib文件夹下

3.将.tld文件文件和struts-config.xml、web.xml放到WEB-INF的跟目录下

4.配置struts-config.xml文件和web.xml文件
. o* J: O0 v8 k& P7 L7 U# r
) E; j& Z6 j; a( u5.在页面引入tag文件uri
7 o. t( y1 k% g; S$ x& W0 d
STRUTS运行机制

6 Q6 C) \  e# a8 h( e6 ~5 g1、界面点击产生请求

* L; v5 ~9 D) Z* y: ~. S% Y; {2、容器接到请求

3、匹配web.xml文件中的*.do来调用ActionServlet
" p% f% \. C, T# R+ K# A: E
6 Z$ e) _/ L+ b6 O# O# K; ]8 \; i$ P4、ActionServlet的处理
: }' W# d5 S# r  t" y: \7 z
( c- ?5 I: E/ _8 j4.1 读struts-congfig.xml文件形成ActionMapping
) M! ?: x* }8 v! w8 S
4.2 通过path 来匹配Action类，通过Action的name属性来匹配ActionForm类

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

4.4 由ActionServlet转调Action的execute方法
3 b  W! F+ W9 g' G: c
4.5 得到execute方法的返回值，跳转页面
+ L0 `& I- d; y; \
4.5.1 RequestDispatcher
: x2 L0 e8 W$ [/ h
4.5.2 response.sendRedirect(“list.jsp”);
1 e& M) {$ Q+ T: j3 E) }


进入execute方法
/ h# E! c, L9 ~$ q9 ]7 Q
1 收集参数
* w/ b5 w% X& p5 V- R% `5 I2 t2 R
5 D$ S4 }/ @  b2 组织参数

3 调用，逻辑层
3 v8 Q7 [1 W" W( l
4 返回值

4.1 选择下一个页面 （ActionForward）
, s  g8 }" r# g% K: D, Y
4.2 把值传给下一个页面
, M& z; W# t, O- A9 X! m
- F# |3 I& A+ Q, a& l
* Y% K. }0 P: H& U% R: C" y
0 l; _. F  ^, K9 U/ ~$ T$ ?: {比较struts和struts2的不同

Struts

$ k7 ?6 k: `# I! HStruts2

3 Q* E( I6 z2 h+ A2 M# g: n组成        五个部分：ActionServlet，ActionMapping，AtcionForward，ActionForm，Action        十个部分：AcionContext，FilterDispatcher，ActionMapper，ActionProxy，Configuration Manager，Action Invocation，Interceptot，Action，Result，Taglib
url        .do        .action
分发控制        AtcionServlet        FilterDispatcher
" G0 c. A; B, z* w# r收集参数        利用JavaBean技术，将数据封装到ActionForm的子类中；
一个Action对应一个ActionForm的子类
0 S/ ^4 `& \+ H" I8 D
1 t, @9 z/ K0 h+ {# W  ~使用拦截器将数据封装到值栈中。
使用域模型，一个Action对应多个值栈中的Model
9 G1 U6 ^  ~$ W/ |3 z# S
  r, g7 W1 f5 V2 p+ G( _读取配置文件        ActionMapping        Configuration Manager
拦截器        无拦截器        执行Action前后有拦截器
返回页面        将字符串封装到AtcionForward，进行跳转页面        Action中直接返回字符串，通过Result跳转页面
9 R6 a$ l, o1 W2 J% }页面跳转方式        两种：dispatch，redirect        三种：dispatch，redirect，chain
值栈        无值栈，Action通过在request范围内设置属性，向jsp页面传递数据        有值栈，Action和jsp页面通过值栈传递数据，jsp页面通过OGNL取得值栈中的数据
6 {7 q5 O5 P* e配置文件        struts-config.xml        struts.xml
( y; C; ~7 v) J3 {6 e4 ?+ I中文问题        不能解决（需要使用filter）        可以解决中文问题：
/ n% G  |# g# B1、在jsp页面添加Meta；
' d2 B: ^% {2 ?
2、修改struts.properties中的设置。

admin

其他开发工具和技术
Ant
Ant是基于java的批处理工具
: _2 N% f7 T6 J6 g! X$ Z
一、配置ant的运行环境

5 u+ J5 V" e; M; b1.将ant的bin目录添加到path中

+ K3 U4 O, t8 [# I& @0 o9 y* O+ ^2.配置JAVA_HOME

: I) ~  j. g* M9 Z, v3.配置ANT_HOME
" j- k2 d% A3 a; V  g
二、配制build.xml文件，该文件放在应用程序的根目录下

编译java文件

! E% C1 H+ T1 q8 O: T( p执行java文件

copy

  ^6 j1 m" c$ H: G删除
" [) M% F1 z5 x% |
$ B! g4 g! p7 m( w& I7 Q% \9 k/ w打jar包

/ K7 m8 h# N7 x% ^+ k根据注解生成配置文件

Xdoclet
通过注释生成一系列文件的工具（txt、xml、java、html等）

xdoclet本质是摸板技术+字符串的替换

1.在java文件中写符合要求的注释（将hbm.xml文件的内容搬到java文件中去写）
6 T, V  V# ~0 Z- Q
8 R, M5 z. |9 l6 q, P1.1 在类的上面 写与表的对应

1.2 将每一个属性的注释都写到get方法的上面

2.在ant中引入相应的task来驱动xdoclet
  a- ^% ]4 P8 M( _. m
% v/ M3 q& X# q. \$ d4 f) j5 a: u( G
1 u1 [$ q, F7 ]* b2 B' f
log4j日志管理
# y: z5 `9 E% z; Q- t2 ^- G1、是什么？

在开发期间用来测试、对整个日志信息进行管理的工具

2、功能

1.控制输出的目的地
* m6 ]( l0 z1 x
2. 控制输出的格式

3. 控制输出的级别

3、日志的级别
$ g3 [0 y9 t* F- E+ M
1. debug 调试
1 g4 q6 `8 F% G0 \2 q  Q8 _
2. info 给用户的提示信息
  y6 V! d- Z+ g7 ?+ W
4 P- F4 j5 y$ R( @- H3. warn 给用户的警告信息

4.error 给程序员用来调试
& F  Q8 j) O' S7 {4 V
9 b  L4 C# t- S+ t2 zDebug—-〉info—-〉warn——–〉error
; X1 ?* Y5 v* l8 b3 v
6 l* V* R, L' X8 ^* u' f$ N4、配置

1.配置级别

- B: W) h: o5 m; c+ V& q2.输入源 （控制台和文件）

3.可以进行分包控制
8 a, e; _+ ^5 j- n6 f
$ a2 V9 {+ K( ILog4f.logger.包结构 = 级别
! e. |4 g! x: n( T& l9 b
" y& {) w' J% u  j5、使用
+ }$ H  o4 T, ~/ l+ k0 L1 h
% Z+ T6 n) E- ?5 h# o+ QLogger log=Logger.getLogger(Test.class);
) w" @0 }( t+ U9 M! S. |0 p6 a/ j
    public
void t3(){
, O  r. n# i$ ?. m, R
        log.debug(“this is debug”);
# S! v) h; d0 ~5 o% z9 [6 k1 C
        log.info(“this is info”);
: P2 @( @. q7 v4 H1 k1 v# f
        log.warn(“this is warn “);
; D: [. f! P$ |
        log.error(“this is error”);
1 a5 q% g( n4 S  T% y
    }

Junit
1.是什么？
% k! ?. F3 v- a( Y6 O. W
单元测试的框架

2.怎么做？
3 I) i9 @9 G9 D! c+ O1 p
6 y- b6 G, ^1 z0 m' h9 g写一个类继承TestCase
. t6 u" G0 A( L" j
测试的方法一般都以test开头并且没有参数

在测试方法前执行的方法public void setUp( )
& v4 B! Y2 R& q# z  U" x& k9 |
- M% S( I5 j* u* p9 J8 b在测试方法后执行的方法public void tearDown( )

error和故障的区别
7 a, u- U' ]+ y& B  [3 \
8 G0 K4 Z( ~( @' |/ Oerror ：代码有问题
0 Q; V( v. h8 v3 R8 o# u. y
故障 ：逻辑有问题与祈望的值不相符合
2 }3 R6 T3 ]: J& J+ L  j5 H
生命周期

! A" w( u9 r3 w, q; W测试—〉SetUp（）—〉testXX（）—〉tearDown（）—〉结束；
3 Z( |$ ~" e& ~2 F$ y& x
& [7 |/ x6 [7 eTestCase套件

public class MyTest{
1 P8 i' g% R& E1 [
! G2 j9 {5 U# g5 k9 |        Public static Test suite(){
, T' J% [: `, n! o( J+ X
$ K: B2 y0 p( U% |; c! h! ~TestSuite suite = new TestSuite();
0 k4 R1 E. e( b' w4 p; p
4 [! S& ^6 G6 i9 isuite.addTestCase(Test1.class);
8 J5 G! V$ c+ M  e: x
suite.addTestCase(Test2.class);
0 \+ }1 V* |) w( e8 f. C
: i, Y$ o8 {; m+ ?. c6 r2 G5 H}

) r) f; O9 E# F- b) ?# q2 k8 d}
& ], n: m1 N$ ~  J  C

& P  n! \8 q# l6 }/ {# g2 k
5 c" C; M$ y: o/ R3 d# j) {Ajax
) A; }) R# U( c2 A是什么？
) U4 ~: F! i& Z+ u& {6 g5 ZAJAX即“Asynchronous JavaScript and XML”（异步JavaScript和XML)。是一种创建交互式网页应用的网页开发技术。

无刷新页面。
0 v9 s7 p- `4 u1 Z
; j$ W- r0 p. {* F2 c& T有什么？
5 F! u/ h, U- W* ]' `3 UAJAX是多种技术的综合，包括JavaScript、XHTML和CSS、DOM、XML 和 XSLT、XMLHttpRequest。
" q0 W3 J4 T# V
能干什么？
5 h7 ^3 v2 t) m4 @0 s& X使用XHTML+CSS标准化呈现；
使用DOM进行动态显示及交互；
4 a) `1 p  a5 q. T2 J- g- N使用 XML 和 XSLT 进行数据交换及相关操作；
0 d6 h2 F  }4 {1 x) c; l使用 XMLHttpRequest 进行异步数据查询、检索；
( r9 e  h: M- j( U: L9 [使用JavaScript绑定和处理有所得数据；

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

与此不同，AJAX应用可以仅向服务器发送并取回必需的数据，它使用SOAP或其它一些基于XML的web service接口，并在客户端采用JavaScript处理来自服务器的响应。因为在服务器和浏览器之间交换的数据大量减少，结果我们就能看到响应更快的应用。同时很多的处理工作可以在发出请求的客户端机器上完成，所以Web服务器的处理时间也减少了。

使用Ajax的最大优点，就是能在不更新整个页面的前提下维护数据。这使得Web应用程序更为迅捷地回应用户动作，并避免了在网络上发送那些没有改变过的信息。

/ A- ~# W: F5 ?' T9 N3 n对应用Ajax最主要的批评就是：
1 它破坏了浏览器后退按钮的正常行为，就是用户点击后退按钮后不能看到之前的数据；
7 v1 F4 Z: w! H: s2 一些手持设备（如手机、PDA等）现在还不能很好的支持Ajax；
, {7 D# U# B& L1 Q6 m, Z6 R3 用JavaScript作的Ajax引擎，JavaScript的兼容性和DeBug都是让人头痛的事；
4 Ajax的无刷新重载，由于页面的变化没有刷新重载那么明显，所以容易给用户带来困扰――用户不太清楚现在的数据是新的还是已经更新过的；现有的解决有：在相关位置提示、数据更新的区域设计得比较明显、数据更新后给用户提示等;

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

* T1 n6 ^. x' p- i* r; o4 v# cvar req;
: Q7 o" |$ k' ]3 r
function add(){
% \3 H- Y1 P2 {" M/ j3 q
//1:创建用于传输的对象

1 ^8 G6 C8 D* I: z% p$ |3 d4 E2 l1 ~9 @req=new ActiveXObject(“Microsoft.XMLHTTP”);
  f" y" u& V1 U) `4 }/ ^# q
$ k/ N$ c: z4 x# g// 声明返回后，处理数据的方法

req.onreadystatechange=manage;

//2:准备传输的内容
! P2 i( H9 V5 i' l
3 Y% @- A4 w: [9 Z8 R5 D. \% lvar str=”test1111″;

$ \' h: L5 T, S, V7 N* Q' w//3:发出请求

req.open(“GET” ,”/others/ajax/test/t2.jsp?str=”+str);

! V( S$ S1 ?2 h6 s. N7 C7 breq.send(null);
' C# ^$ B) B! z
}

% z$ F, o4 L! q& w4 M//4:接受返回并处理
# d8 B7 t8 [5 n0 `8 r$ J6 t
# h2 v4 w) q9 @3 Kfunction manage(){
6 J8 w+ `  S5 K7 i% U( z
! T3 |5 ^/ L8 A0 Aif(req.readyState==4){
7 ^  C: S; s: l+ F( b: R6 Z, r
! |" }) U& E5 g; b4 @) @% b: d- Falert(“r==”+req.responseText);

6 \. A/ G/ R1 I; s, q  U}

  \9 P! U* C0 n) x( ~9 r}

5 r$ ?' j' b* R</script>
/ z; r3 S: {$ Z) `
' Z* t/ l1 Q9 A5 x5 }+ [readyState的取值如下：
0 D* a" o. U/ s( H$ Z! P% i
' k; u$ o. `/ r5 D2 m7 {0 d　　0 (未初始化)

　　1 (正在装载)

! L" [" t& D9 H0 F5 h　　2 (装载完毕)
1 r" {( x8 Q0 J$ I
; ^- R: D+ d& |& r( Y/ g2 U3 d3 M　　3 (交互中)
& J5 ]9 g1 Q$ S% i  t. U1 n
" s* j0 _" X' }　　4 (完成)


' X+ S% O" @/ n) N1 A% l
原理
Ajax的原理简单来说通过XmlHttpRequest对象来向服务器发异步请求，从服务器获得数据，可以是xml格式，也可以是一个字符串，然后用javascript来操作DOM而更新页面。

Dwr
" C& G- T! A( _是什么？
7 O* y9 K& s9 ^2 \) X# n) U; \( oDWR（Direct Web Remoting）是一个开源的类库，可以帮助开发人员开发包含AJAX技术的页面。它可以允许在页面中使用运行在WEB服务器上的JAVA函数,被调用的JAVA函数就像是在页面中JavaScript方法一样。

+ Q  F1 D5 s: i$ F有什么？
9 e/ Y7 e* F* Q; ]" `它包含两个主要的部分：允许JavaScript从WEB服务器上一个遵循了AJAX原则的Servlet中获取数据；另外一方面提供了一个JavaScript库可以帮助web开发人员轻松地利用获取的数据来动态改变网页的内容。

8 x+ f1 `* K9 Q$ ?' h+ O; J5 p9 n* y

* m; f0 w/ d; g$ T0 M能干什么？
动态地把java类生成为JavaScript，感觉调用就像发生在浏览器端，实际上代码调用发生在服务器端，Dwr负责数据的传递和转换。这种从Java到JavaScript的远程调用功能的方式使DWR用起来有种非常像RMI或者SOAP的常规RPC机制。



! c' C2 [/ _9 S) a+ m4 f* V怎么做？
① 编写配置文件
9 A/ o* i0 B2 |/ o
. A5 P7 C" D5 ^# c$ nweb.xml
; q7 X/ e9 e: S
<servlet>

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

<servlet-class>
2 @  m0 @- [: A3 N; ?* T
org.directwebremoting.servlet.DwrServlet
+ V6 X0 S3 A# Z
3 X# I5 K! D- g" `5 \+ E4 `+ Z1 A  i</servlet-class>
2 z( b8 U5 n0 o; t( _, a
<init-param>
7 \7 e+ h; s7 a6 r' O  t( _
2 ^+ ?5 p# S" O<param-name>debug</param-name>

<param-value>true</param-value>

* x" f9 ~4 v; z' b4 |</init-param>
. ]; h/ a) |7 d7 c4 c' P
* g# H( q6 h+ ?+ p% y</servlet>
  D6 c6 R: H1 V# e; r  f/ d
<servlet-mapping>

<servlet-name>dwr-invoker</servlet-name>
$ I" T2 o- s+ W: d4 r
<url-pattern>/dwr/*</url-pattern>

/ ^* [8 x3 Q( M9 U, Y, r( ]5 U3 G</servlet-mapping>
0 I6 ]( `3 l3 N& A
% R: x7 q" R/ V8 z' k. i! cdwr.xml
2 ?4 C# X& x# H- V) w. E' L
1 E( {  v8 g- @) h  l<allow>

7 C* f* J% t) H' F! q. Y. v<create creator=”new” javascript=”kc2″>
( r, u. |* R4 W
4 |% t/ A4 U* c# V<param name=”class” value=”dwr.Service” />
8 l# y* i8 V6 L4 I4 X3 T' t. k( n" r
# `, H5 f/ _" B% C</create>
$ U8 F+ W  R2 h4 e& ~9 P
0 k6 e4 X3 P0 n( A! G4 M* F</allow>

9 g4 l( F# i4 z$ F- ]②编写service

public class Service {
6 }1 P5 G/ C" ^3 P; d
  Z, ^9 h4 G9 K* {* F8 Ipublic String sayHello(String yourName) {
: f& y8 _  @5 e# p" g
//可以是访问数据库的复杂代码

return “Hello World ” + yourName;

}
# O) r4 f  C- g: v) ~
8 y- T1 N3 U( c2 I: `}
* O# [- Z# ~( s1 ^2 x, }
1 h4 x( X% a( R& N③测试DWR

, {  }3 X6 r" Q" O1 P+ f. G将代码放入应用服务器（比如Tomcat），启动。
+ \, c+ w9 F  S0 g  x
' a% }# N: V* P) p. N/ G9 Y然后在地址栏输入http://localhost:8080/你的工程/dwr

2 f" Y3 V6 g+ C1 a④编写jsp页面
( I9 J; Y  ?; Y$ j( t0 |& C
* ^* K1 \4 t7 G- G1） 要引用3个dwr的js，其中engine.js必须要，如果需要用到dwr提供的一些方便的工具要引用util.js
/ ~8 b3 K& y; ~' H1 C4 V; G
2） 然后还要引用dwr自动生成的js，dwr/interface/service.js，注意js名字要和dwr.xml配置的一样

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