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

admin

JEE
简述JEE
2 B8 F6 Z& q4 ^$ ^! k: e5 V) BJEE　： JAVA　 PLATFORM　 ENTERPRISE　 EDITION

JEE是一个规范集；
5 Z* Y0 [* z6 a: i
JEE是一个框架集；
. V6 ]1 v- E4 q/ i  Z, o
1 S  m+ w! X" TJEE是一个技术集或API集；

适用于创建服务器端的大型的软件服务系统
' ^8 e9 l( o& h; W9 H2 I) B# }
0 o& R) F) o- |  S5 ?3 B- A

C/S B/S 模式
% `$ r% D) W$ B' BC/S client/server即客户机/服务器模式，客户端也参与程序的运行与计算（富客户端、胖客户端）

B/S border/server即浏览器/服务器模式，又称为瘦客户端，客户端不参与程序的运行与计算
3 |) `1 k6 T8 L( W. Q! F' f2 b

4 |1 Z3 M! X6 I0 d8 M: d
企业级应用（大规模的应用）的特点
1.生命周期长、稳定、可靠
8 S6 ~1 @! [" b" `8 v( _; ~
1 B1 o* @7 f+ N( x/ O2 q2.组件往往分布在异构的环境中，能够跨平台

3.维护性、扩展性、重用性

4.有事务、安全、线程


' k$ X% E" p+ L! L% B
; }( S9 G2 n. I: ]什么是业务逻辑？
依照业务逻辑划分模块，
! x% x1 x/ V) z& m. K$ b8 H# G
所谓判定业务　就是具有以下特征：

. [  _2 P* v. b7 ?- e1.业务流程
1 p; n0 @& w8 k" M1 [/ y2 ?
2.业务判断
0 ~/ L4 w" o# h9 Q* Y! R! R
3 V- J/ k: _) T) ]3.功能组合
) q3 t: r' x& I) I* P
7 t: e7 Z% [2 I9 S$ G# d' T6 L
8 x) D4 Z% N* b- F' i4 K; J
平台（角色）的划分
1.平台供应商。提供满足API集实现的厂商（BEA weblogic IBM webshphere）
) Z. {7 M& N* a( y% j
2.组件供应商

3.组件装配人员

& Z" V8 Z4 V) t  I# {. s. ^/ L4.部署人员
  `+ |$ w% b- t7 j* s+ i6 D
5.系统管理人员
. X$ x+ w4 X6 Q- ~/ S
6.工具供应商 提供开发组件所使用的工具（Jbuilder、eclipse）

7 q1 E) e" f. p, N$ p

2 M3 X- B7 @% v% Bjava技术分布（设计架构 模块内部设计）
1.表现层 Servlet、 Jsp、 JavaBean、 Taglib
! d/ S3 I0 Z! j. s# k7 M/ Z
2.逻辑层 EJB(SessionBean)

3.数据层 （　JDBC 　EJB（EntityBean））

* T  X  B4 V6 P: Y" G# f4.服务 JTA（JAVA事务架构） JTS（JAVA事务服务） JAAS（JAVA授权与验证服务）

- z/ D/ Q6 u2 d) t$ t8 i5.分布式通讯 RMI（IIOP）+JNDI 、JAXP（JAVA 的 XML 架构）
8 _8 ^8 `4 {/ r3 w! q' K
" {% `4 p# I1 h9 rJAVAMAIL（邮件服务）、JMS（消息服务）、IDLC、JCA（JAVA连接器框架 （成））
- n& o9 M6 Y% f4 A5 E" |" r

$ M; J, _! X6 p
. O2 G8 Z; k+ i: w( ZJEE的体系结构： 是一种组件的体系结构
1.组件 ： 能够完成一定功能的封状体（独立的功能的集合）

; W8 ~- t9 y4 T不能单独运行，必须运行在容器上
+ g0 Y' Z; f, w8 O% u* E
( P/ z" R) T! ?+ i分为两类：web组件、ejb组件

  t6 n; f% q* v0 k- N2.容器 ： 提供组件的运行环境，并对组件进行管理（一段程序）

管理组件的生命周期
; F& u1 F4 }& Y* J
不能单独运行，必须运行在服务器上

$ |) B6 c* x7 [程序（组件）通过上下文来调用容器（context）
0 j' {* }2 S4 J. m8 }+ w( |( v
组件通过web.xml向容器描述自己，使容器能够认识组件

) A: e; l0 F( b容器通过回调方法来调用组件

分为两类：web容器、ejb容器
8 i" T# P& Y* h8 \& `- N6 C
3.服务器 ： 提供容器的运行环境，提供大量的JEE基础服务

+ y/ T( W# Y8 [, @web服务器（只提供web服务）
2 Z5 ^1 p4 X+ i/ y% f4 {  Z7 C
$ i* C) j4 n& ?. Sjee服务器（提供web、jee服务）

, l0 a- d5 P) e8 S' i
2 ]0 ~, h+ t! C, d: Q8 y
1 V; Q5 ~. ^3 S什么是回调方法
/ J! A6 l: G* z# ]由容器自动调用的方法，就叫回调方法。
  P( L' z% v! c7 i0 q

& y. |* e$ [, {) j8 d9 o& E3 ]
ＲＭＩ远程方法的调用机制
例如：Ａ主机有Ｂ（）方法，Ｃ主机有Ｄ（）方法，Ａ　想调用Ｃ主机的Ｄ方法





" {) c" y& I3 \$ V学习方法
% N, N  D% E: x: \1.规范（熟记） 2.熟悉API 3.多练 4.多想

admin

Servlet

•     描述war包、jar包、ear包的结构
  $ j3 A4 f+ G7 S/ z
  
  

war-                            web文档压缩包

—WEB-INF

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

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

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

1 M$ Y8 [0 O, n6 d5 b4 [- d. _

jar-                             java文件压缩包

—META-INF

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

# k5 r8 r( h7 u! `

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

–META-INF

—Application.xml 配置文件

–*.war

–*.jar

# D$ K1 Q! [9 n0 I% K5 x: E+ o; ~' ?

• 什么是servlet？servlet主要做什么？
  
  0 q7 y0 U0 ]+ i2 K' I. e. L/ X. a" T
  5 [) b6 d+ S/ q8 F

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

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

, f' G+ Y1 Z! F0 T. a

• servlet 与cgi相比的优点？servlet的缺点
  % I" c+ e; V' c9 R2 B' ^. l
  
  

优点：

性能（线程比进程更快）

可伸缩

Java强健且面向对象

Java平台独立

缺点：

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

- S6 V0 C! h6 g

• 常用的servlet包的名称是？
  / Q2 L; j2 E( e3 j" z" s4 u
  
  

javax.servlet

javax.servlet.http

• 描述servlet接口的层次结构？
  
  ) I5 G' v9 C- A# ~7 l
  , }8 D0 D3 \7 g9 X2 K

Servlet

–GenericServlet

–HttpServlet

–自己的servlet

ServletRequest

–HttpServletRequest

ServletResponse

–HttpServletResponse

• 对比get方法和post方法？
  ' L4 h! N+ h" }% O
  # y) P( g% r/ L/ F
  , f; A8 F. ?* B- W9 `; n

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

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

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

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

8 Q1 x3 w3 j; g3 E" F; ^

• 归类描述HttpServletRequest接口都完成那些功能
  
  + V  ]; L5 W. a
  . \9 H0 j+ l' s
  • 读取HTTP头标
    7 x1 j/ i4 k) [8 E- U- J
  • 读取cookie
      H8 f; M) R3 C3 u
  • 读取路径信息
    
  • 标识HTTP会话。
    
    

+ _" }  ~$ ]6 Q" a8 Y. k

• 归类描述HttpServletResponse接口都完成那些功能
  
  
  
  • 设置HTTP头标
    
  • 设置cookie
    ; d% t/ C! n$ P+ G: ~
  • 设定响应的content类型
    - h9 q& i; f% t: w5 B' F6 k3 [+ M
  • 输出返回数据
    
    ) f: g- ~3 ]; \6 g' s' Y

7 X# a5 s; [$ y& t

• 描述service方法所完成的基本功能？默认是在那里实现的？
  , X9 ^' c: ^4 _6 B2 x, A/ o! y& N
  : S6 v" ~7 c" j# T3 O$ O" E% N
  

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

实现：默认在HttpServlet类中实现

: X0 W4 H4 c9 e! i8 w0 R

• 如何开发自己的Servlet？描述应该做的步骤和每步需要完成的工作
  % R7 U8 E/ ?: `! b6 T" \" _1 [8 d
  
  

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

$ ]) u7 p* D5 Q  g

• 为何servlet需要部署描述？
  
  0 a3 ~4 x! J8 X8 G7 b! |
  

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

' X3 x' Q* R( r8 V, R- U1 h

• Servlet基本的描述应该是？请写出来
  
  1 W( {- W, w$ b3 V
  2 o: M& V; C1 m, u4 X! r! F* ]

8 ]3 `6 ]0 h+ |0 I0 J% A; \$ g

<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
  
  
  

FORM标记

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

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

语法：

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

{HTML form tags and other HTML content}

</FORM>

  [% r  }4 J; U- x

• 如何接受request中的参数
  
  ' @1 v" Q+ p; `# {String userName = request.getParameter(“userName”)方法
  7 S* \1 r  A9 G' J9 b8 ]$ _! S
  # p, L0 ]5 D7 L+ O# j  I- {

• 如何接受request中header的值
  
  
  

request.getHeader(name);

request.getIntHeader(name);

request.getDateHeader(name);

request.getHeaderNames();

• 如何输出html
  & K1 F3 a) \, A
  $ Q5 C- ?  G/ ~7 r, ~0 [2 B
  7 }7 @' f- T! |) k1 q" I# s

PrintWriter pw = response.getWriter();

pw.write(“<html>”);

pw.write(“Hello”);

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

• 如何设置输出的contentType
  8 N7 H8 i+ ]. L5 J% j7 A1 S
  . z. C' v7 o+ k- n, u( s6 @- s
  

response.setContentType(“text/html”)

• 描述servlet的生命周期？
  
  
  

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

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

• 描述init,service,destroy方法的功能和特点
  0 e* i2 i6 f: @2 R3 D6 ]% T
  
  ' W! O5 I( y- S  ^! o; f5 t% w

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

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

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

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

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

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

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

• 什么是回调方法？有什么特点？
  
  
  ' U% z# A3 f% z. s4 |

由容器来调用程序的方法

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

, @: F+ k& j: J. `  I5 v

• 如何设置初始化servlet的参数？
  
  在<servlet>中添加如下配置
  # H$ [7 Y- W3 s  k
  4 C/ _9 b3 ~: F3 y4 W% O+ y

<init-param>

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

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

</init-param>

. C% m. h: |5 X: V8 R0 k# K, o

• 如何获取servlet初始化的参数
  
  
  7 n1 ^' d; H1 R- D! v4 n

public void init() {

greetingText = getInitParameter(“greetingText”);

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

}

- _4 H% H3 Q. X

• ServletConfig接口默认实在那里实现的
  
  ' C( ^7 X) ~0 y, Y: ~. u4 h
  ! x: A5 |1 S* G- {8 {

GenericServlet类实现ServletConfig接口

7 I/ Z2 p/ j6 A5 \

• 什么是ServletContext？有什么作用？
  : c/ C; \' a: T( i
  * y# B) P" ]9 [3 d5 K4 g
  

Servlet上下文

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

2 j& j& s5 l  E4 \

• 如何访问ServletContext接口？是在那里实现的？
  
  ' s& s: B3 g0 z! L9 Y6 t3 R
  

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

GenericServlet类实现了ServletContext接口。

• ServletContext接口的功能包括？分别用代码示例
  7 Y) {* B0 }9 A" `
  5 N" U% V# y0 [- V' g+ C8 h9 j! z0 T
  ) E# p' ?4 w; e* p5 |

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

# u) [& o) Y5 V) D1 m! \) p

• 如何设置ServletContext的参数？
  
  
  ! {! ^+ Q' Y, b3 r6 Q2 q# c

<context-param>

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

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

</context-param>

• 如何获取ServletContext设置的参数值？
  
  / N% w) ~# B  G5 Z
  

ServletContext context = this.getServletContext();

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

: L9 _% E7 M6 h% ~

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

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

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

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

• 如何用代码实现监控Web应用的生命周期？
  3 @2 Q+ B- F8 N+ n
  
  
  

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//服务器内部错误
  
  

& Y6 b' p, m3 Y$ `$ e7 F/ }

• 描述Web应用中用声明方式来进行错误处理的两种方法
  
  
  , G" X2 S5 N. b9 \/ t. g8 r/ I9 G) j

使用error-page元素声明一个给定HTTP状态码的处理器

<error-page>

<error-code>404</error-code>

<location>/error/404.html</location>

</error-page>

可以声明任意数量的错误页面，但一个给定的状态码只能对应一个页面

使用exception-type元素声明给定Java异常的处理器

<error-page>

<exception-type>

java.lang.ArithmeticException

</exception-type>

<location>/error/ExceptionPage</location>

</error-page>

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

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

• 描述记录异常日志的方法，都位于那些接口？
  
  
  1 R9 Q2 s/ f+ B

GenericServlet：

log(message:String)

log(message:String, Throwable:excp)

ServletContext：

log(message:String)

        log(message:String, excp:Throwable)

• 什么是会话？
  
  ' M( L. e- ~$ F( a( _
  + x0 E2 Y9 k' \& H

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

- z& n. Q- R, j* h% O' p

• 如何获得会话？
  
  - r1 g5 O$ H0 B2 q  o  D; p& ~
  HttpSession session = request.getSesseion( );
  
  : M5 s7 _2 [6 J

• 会话Api的基本功能？
  / `% h! {* i( u
  ' S( |" y( S% M* V2 S, \
  : {* v( H. V# h+ P: h

getID() :String
$ p% K, {( C( p# Z

    isNew() :boolean

    getAttribute(name):Object

    setAttribute(name,value)

    removeAttribute(name)

• 如何销毁会话？
  / K5 F4 I0 I$ `+ z
  
  

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

<session-config>
7 t; {: `4 T; E( M

         <session-timeout>10</session-timeout>
, r, Z- ?1 w9 W, O

     </session-config>
) z* G9 Q1 r/ H4 q5 L0 u8 t, g' r' k6 m

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

invalidate()
$ ~7 [3 Y$ `0 w# h0 m* S) U

     getCreationTime() :long

    getLastAccessedTime() :long
/ ]; x  A  u. [# N* E

    getMaxInactiveInterval() :int
3 e$ i2 ~. ~( u8 P" r* `

     setMaxInactiveInterval(int)

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

    client server

, w6 H2 n' Z7 k% F& |

request

response (sessionid)
5 L5 G4 O, f7 E# z( W

request (cookies)
% ^) [- s9 K% i  L8 u" i, k0 T) c

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

• 请描述session和cookie的异同之处
  1 d3 a* I" o5 q# J9 W; i6 o8 ]
  / b6 W8 |2 N8 A0 r; ^* v6 c7 t
  8 i* t# r+ ~5 {" o' Y1 Y4 @

• 如何读写cookie，代码示例
  5 U; X7 ^9 X  Y9 q! w
  
  

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

response.addCookie(c);

读：Cookie[] cookies = request.getCookies();
8 G2 Z0 U2 S" p8 X, M2 f$ X

        for ( int i=0; i < cookies.length; i++ ) {
3 t0 o, S" e6 S! w! ?6 q- A9 S! h

            String key =cookies.getName();
1 J' l% Y! l2 K( ^" y2 W

String value = cookies.getValue();

System.out.println(“cook”+i+“:key=”+key+“,value=”+value);
) \: q5 x3 ~, j, J; y

     }

0 S$ c' c5 e& N0 K  I

• 什么是URL重写，如何实现，代码示例
  * X. u# \- u7 K# P; z8 O
  + Q" q$ w6 F$ @) x3 e6 A$ U$ e! B
  & s5 E/ }0 G. c' M! V+ r

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

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

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

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

$ }  S" l. n4 C9 V' ^
9 Q# `+ D, c4 p: J, [

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

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

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

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

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

• 什么是授权，什么是验证？
  3 B2 A7 w3 q/ P1 s* k) H5 m) K
  : f4 M; _5 f% Y: |, r
  + T5 ]* o  z( d1 q) a5 f* Q  S

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

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

• 什么是HTTPS
  
  
  2 K; U2 k4 P2 X

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

9 g: V0 q" C% z  i3 |

• 什么是审计？
  / y# B( a+ V& K7 N
  ' A/ m, @) w5 w) A
  

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

' |2 e# j! m4 A1 ~6 \* ~

• 如何实现声明性授权
  1 P2 ?/ Y$ R9 L+ y0 I
  , ?# q) H, Q- N2 d1 S! d1 Y
  

1、标识web资源集

2、标识角色

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

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

在 web.xml里配

• 描述servlet并发问题？
  
  * H5 P5 `7 X" q( }9 _; ~) [, S8 j
  

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

• 描述Web应用中的六种属性范围
  . q* N2 S& D7 t4 b2 E  p% e) Z
    M$ z) h; n6 I- O" b
  

局部变量（页面范围）

实例变量

类变量

请求属性（请求范围）

会话属性（会话范围）

上下文属性（应用范围）

• 指出上述六种哪些是线程安全的
  # C! ~2 e& }3 C1 L5 R/ N1 q
  
  9 |/ _/ C; ?" a7 |. V8 [: J- n5 ]

局部变量和请求属性

, Z* C  o$ T% ?+ g

• 什么是STM？如何实现？
  - r$ \# w) L0 I$ [+ ]6 H% v2 M
  # F* M: p, M  i- G' s5 \
  ) {. |* j& K; ^5 J7 w

SingleThreadModel接口

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

• 如何实现并发管理？
  
  & ?$ H% {, V& r9 \4 ]
  ) n. A; o- ^: {; \( W' x/ q8 f

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

使用synchronized语法控制并发

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

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

admin

Jsp
( B* n: N9 L$ h* ~; u3 w什么是Jsp?
5 Y' \* Q+ v- l- u) m& OJava Server Page    结合java和html在服务端动态生成web页面的技术


! S9 {. c9 I: r& k1 S- I$ g
  s2 v5 Y7 T$ V描述Jsp页面的运行过程？
% W$ w6 j% ^2 a& r$ v第一步：

+ H' Q" V- `5 D$ u. ]' @6 }请求进入Web容器，将JSP页面翻译成Servlet代码
; T, p* Z" R) u' M" w
第二步：
8 L/ V* `1 @9 `; y
编译Servlet代码，并将编译过的类文件装入Web容器（JVM）环境

第三步：
0 j) R. N- _" T# |) |) y
) c$ L# o# x) H( `" J% }; W5 wWeb容器为JSP页面创建一个Servlet类实例，并执行jspInit方法
$ [4 _6 `* J; U1 M6 m+ i
第四步：

Web容器为该JSP页面调用Servlet实例的_jspService方法；将结果发送给用户
$ b% a, T/ c/ J# e! i6 @5 I8 f  n
: m/ c. ~4 Z$ v2 l
6 o# J( H0 f5 J7 T& U
3 u# q6 L* m7 f. E7 \" w! x描述Jsp页面的五类脚本元素的功能、写法、并示例
注释 <%– –%>

<HTML>

<%– scripting element –%>
. h0 J3 h" l4 Q# U) y( R
</HTML>
0 T. I. Z8 Y0 w. r
指令标记 <%@ %> 指令标记影响JSP页面的翻译阶段

" V3 P9 g2 |$ j/ N& c9 @( l<%@ page session=”false” %>

; `7 `5 Y* ]$ c3 r4 n声明标记 <%! %> 声明标记允许JSP页面开发人员包含类级声明

* U/ U' f; v$ b1 i5 w$ H3 n# D! O! M<%! public static final String DEFAULT_NAME = “World”; %>

    脚本标记 <% %> 脚本标记允许JSP页面开发人员在_jspService方法中包含任意的Java代码
5 `1 \& f7 j. Z$ j1 ]) l
    <% int i = 0; %>
$ V( ?: S7 x3 _+ V4 y
表达式标记 <%= %> 表达式标记封装Java运行时的表达式，其值被送至HTTP响应流 <B>Ten is <%= (2 * 5) %></B>
+ Z# [0 u. L9 X  D


: h3 L. X- J$ o4 _描述Jsp页面中的注释种类和写法
HTML注释

<!– HTML注释显示在响应中 –>
4 W0 J; e; c3 L& L6 w  }; _
JSP页面注释
3 z" P+ K+ m! _4 t6 L
- H) @- ?# Z7 ~4 a* ^* d  n<%– JSP注释只在JSP代码中可见，不显示在servlet代码或响应中。–%>
3 b/ P0 X: ]! B- u. K6 u* L
1 p% P: H" G9 D6 h1 \! l7 `Java注释
6 T9 {' P5 N  C8 h# i
<%

; g, l' f& s( _) E0 v  w/* Java注释显示在servlet代码中，不显示在响应中

*/

%>
! P3 q$ h7 V8 F9 @2 i, y


3 d) s8 v% N3 t4 \4 r, v4 F* V2 y描述Jsp页面的指令标记的功能、写法、并示例
* e1 Y4 q1 W" u  o: o# I: m指令标记影响JSP页面的翻译阶段
! g" g* ~$ [* e- |- S
<%@ page session=”false” %>
( y& J2 J2 ]0 E+ Y
<%@ include file=”incl/copyright.html” %>

<%@ taglib %>
) Y1 m( _( J0 J1 L4 C+ t. P' f6 u5 B( ]; ]
$ Z/ S3 R- d% S  D! E8 q
4 Q9 @: M  m9 o% n" {; v* L
描述Jsp页面的声明标记的功能、写法、并示例
( q: J. j! A; j9 v" J, S% w声明标记允许JSP页面开发人员包含类级声明

写法：
/ d! f0 i2 w; G1 m0 ^
' m6 }7 @: V. k<%! JavaClassDeclaration %>

例：

4 f" Q6 I( G/ y<%! public static final String DEFAULT_NAME = “World”; %>
- ^0 ?+ m$ P& y: p* N$ Z
& j5 J  v  t+ K8 T4 M<%! public String getName(HttpServletRequest request) {
& D5 V" X3 Q$ ~2 j9 d  c8 M
0 F) ]4 H  _# D) J) Kreturn request.getParameter(“name”);
5 I' Y5 y8 E7 p
; b# w# r* j: Q! [2 v+ t}

%>
, ~: T1 w+ j* O  L% r) P7 D
<%! int counter = 0; %>
% D# q( P! ]: q" Y. e
) E1 y  f( ]' N, F

描述Jsp页面翻译成Servlet的规则
5 ]- \' X, v' z$ `# A" gjsp中的注释标记被翻译成Servlet类中的注释

' T: p  l; O% L% \jsp中的指令标记被翻译成Servlet类中的import语句等

- {% V( i) A  g7 [jsp中的声明标记被翻译成Servlet类中的属性

jsp中的脚本标记被转移到Servlet类中service方法中的代码
2 q. m2 s, p" x; [# u2 z
( a( R5 f6 r2 X5 A% e  ^. Fjsp中的表达式标记被翻译成Serlvet类中的write()或者print()方法括号中的代码

, A4 V, |) [$ W0 w6 A9 ^- A

描述Jsp页面的九个预定义变量的功能、用法、并示例
: }3 _& o. W$ E' s" E! Xrequest 与请求相关的HttpServletRequest对象

8 \6 B' r& }: Eresponse 与送回浏览器的响应相关的HttpServletResponse对象

: `/ r" L- I# ^0 Kout 与响应的输出流相关的JspWriter对象
* w7 T! c- c9 \' _; X
    session 与给定用户请求会话相关的HttpSession对象，该变量只在JSP页面参

与一个HTTP会话时有意义

    application 用于Web应用的ServletContext对象

; Q  h! i7 W0 n% o7 v* \, Yconfig 与该JSP页面的servlet相关的ServletConfig对象

" P1 C% k8 r0 V) c8 q3 ^pageContext 该对象封装了一个JSP页面请求的环境

page 该变量与Java编程语言中的this变量等价

    exception 由其它JSP页面抛出的Throwable对象，该变量只在”JSP错误页面”中可用
( U( D1 G+ C) U7 ?

  |3 O$ b) h* n; ?8 P0 p0 U( Q
page指令的功能，写法、并示例，并描述它的如下属性的功能和用法：import、session、buffer、errorPage、isErrorPage、ContentType、pageEncoding
import import 定义了一组servlet类定义必须导入的类和包，值是一个由

1 u$ U9 u3 s; u- Z( |3 c逗号分隔的完全类名或包的列表。
' o( Q! q  a+ h- t/ ^, E
2 ^8 t0 L! Z$ [# p' _; B8 O5 wsession session 定义JSP页面是否参与HTTP会话，值可以为true（缺省）
! g. _; q; D# q# G# g
或false。
7 }; c' z! J5 N4 g+ s
buffer buffer 定义用于输出流（JspWriter对象）的缓冲区大小，值可以为

none或Nkb，缺省为8KB或更大。
' m$ M# @9 M  H  p
* ?1 ^" D1 S" nerrorPage 用来指定由另一个jsp页面来处理所有该页面抛出的异常

isErrorPage 定义JSP页面为其它JSP页面errorPage属性的目标，值为true或
' L9 x, a- e) b, v) H
6 A0 n6 q, |7 efalse（缺省）。

ContentType 定义输出流的MIME类型，缺省为text/html。
3 H  ?, U! _4 D- a9 Y5 q
8 \+ \+ j* _4 d: I; v+ SpageEncoding 定义输出流的字符编码，缺省为ISO-8859-1
8 [( n0 V3 B/ E" y1 w

* F1 i( G- m2 X8 a  o
- k2 {$ Y6 [/ M9 l" a描述MVC各部分的功能？MVC的优点？MVC的缺点？
MVC各部分的功能：
% x1 O' m$ _$ C. o' h" i4 l3 \( B
Model（模型表示企业数据和业务逻辑）

封装应用状态

8 F6 K8 Z' [/ t/ A8 g; H8 X响应状态查询

暴露应用的功能

Controller（控制器接受用户的输入并调用模型和视图去完成用户的需求）
3 \; C" N* p* o9 |
2 F5 _* K. G5 c  [& B5 h验证HTTP请求的数据

# s% K) [+ w+ I# {3 C将用户数据与模型的更新相映射

选择用于响应的视图

View（视图是用户看到并与之交互的界面）
; M0 b# `' j( D5 u, ~7 Y! Z- \
5 Y3 }6 y2 {- \( F, o( u! G& X产生HTML响应

请求模型的更新

提供HTML form用于用户请求
  T- r( V* T0 |. K+ i) S  F" z- V5 Y
MVC的优点：
  X& p2 Q' m" [. M
/ y( O% N8 y% P        低耦合性：视图层和业务层分离
1 x& X1 W3 F1 w0 E6 Z( R
高重用性和可适用性
* u$ w  X7 o3 Q" A: O' Y
较低的生命周期成本
! ~( V9 C+ r* r' G! Z8 _
快速的部署

可维护性

9 y% s% ^: i" K& L4 S' X' O( F9 x有利于软件工程化管理
, Q4 |; y' z" E5 r
0 Y( w  g7 e$ Q* Z# T3 D提高软件的健壮性

MVC的缺点：

) D7 _, F% e) q! h5 U" e# B        工作量大，增加工作的复杂性，MVC不适合小型甚至中等规模的应用程序

0 I, R# ^$ T: A
3 v' W; X. O! ?9 e# c! S# W  |
% n/ `$ C+ \- q% t& n* @2 ?( a1 r8 `什么是Model 1结构，以及结构中各部分的功能
结构：jsp+javabean
3 p/ w0 w& s4 c
' B2 v- e0 ~, T8 f. O9 NModel1中使用jsp来处理web应用中的视图控制部分
& F: U0 {$ k; Y% i" Z" [
Javabean收集参数
* y0 t8 g! b* y! ^1 t6 H- `7 q4 q


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



* Z# B. Q( ?1 x! vJavaBean的规则？
' v4 ]( B" j& L使用get和set方法定义属性

2 L7 \# l, s4 P$ Y% a$ \/ H一个无参构造方法
3 i' l& G2 O8 w' g$ Q4 K3 x
, e' v; ]( ~/ u( }" h无public实例变量( 所有属性私有化)

+ ]9 x) b5 I5 W" m8 a( \/ \
# u: x1 `5 V/ E* X3 {
什么是jsp标准动作？包含那些？分别都是什么功能？如何使用？
+ W+ d% W8 l3 A, r( T$ cJSP页面中使用类似于XML的标记表示运行时的动作

jsp:useBean

6 \/ z$ S8 }9 `# z9 _" ?/ Djsp:setProperty
" F. G1 n$ Q: N) b9 a! C5 q9 H
jsp:getProperty

jsp:param

jsp:include

, w3 A( S: p+ B; T- kjsp:forward

; w% k! L$ X, D, X9 _; S

用代码示例如下标准动作的使用：useBean、getProperty、setProperty
! |8 c, m: _- n0 O6 {) d' v$ }  m<jsp:useBean

6 \% n6 j9 N. m2 [: Z, L  u5 tid=”myForms”

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

% t* _$ y; k( e7 C) Y7 I    <jsp:setProperty name=”myForms” property=”name” />
* \- ]( O, u7 T' I
5 ^0 s8 E! `/ |: v5 N<jsp:getProperty name=”myForms” property=”id” />
0 g& o2 E: e% Y/ B' Q2 m' M
$ u2 H- Z# f6 ?0 i; E0 c3 u
# U* }& L  \: |$ a. V
描述说明Bean的四种scope
9 \4 ?0 B/ F) F- X; [page

5 i' ~$ [2 c3 z, \) ]request
9 F- m  @; d. ~
3 l: F* T: Z9 u0 A' E3 Esession
* C0 _4 ^9 N) [
. r; W5 x' c6 a' Iapplication
4 N1 Q( S3 L8 k- m5 N; n
+ E, G# L+ h( u
0 L3 h6 a3 E, u  U, p1 w2 a
/ X3 V% W7 Z8 u3 V5 h0 T1 @描述说明页面上的字段和Bean中属性的对应规则
id 指javabean的变量名

class指javabean类的全路径
; R' _: Q/ i# C8 p
+ m! V( H4 i7 W; N) A! Oscope指javabean的应用范围
2 q) f+ q2 D  E% l
name指所用到的javabean的变量名

    property指javabean中的属性


1 I0 V- w3 e: B7 C5 M0 [( K
描述useBean动作的处理过程
8 K) v8 j; r' u. b" H使用id声明变量
6 f  ]4 P; y2 j' R  `
# M; V( U6 Z* A2 B8 v1 W试图在指定的范围内查找对象
; y( |6 e2 `1 |; q0 a
  l% J, j2 {% D: V2 n如果没找到
6 C: q; ^9 W, d
创建一个类的实例

执行useBean标记体初始化对象
$ o: V6 o: H) p3 _
5 Z% j$ e" X4 T+ ~& u* [如果找到

2 T6 y3 n; i- v     将对象转换为类指定的类型



; J3 T6 c: L; q描述forward动作的功能
# N1 ^2 H, x7 B! O使用脚本代码处理请求时，可用jsp:forward 动作产生一个不同的视图，

使用同一个request：

4 r+ M7 L; I8 @
+ ~" d! }; \6 h* j. ]
什么是Model 2结构，以及结构中各部分的功能
2 q6 e8 g* F! \3 j: q. Ojsp+model+servlet

Model 2架构使用MVC模式，JSP页面充当视图，Servlet充当控制器
' m4 T* N0 m! C' L
% d+ p/ e2 F0 t* @Servlet控制器：

验证HTML form数据
3 `) w% k( s: N, e& x1 H4 P+ \. n! J
/ P0 b9 g* @* @4 T% n% S% O; r调用模型中的业务服务

存储请求（或会话）范围内的域对象
4 _+ u6 C% \6 M! ]7 P' h
: X% ?! t. Q, a选择下一个用户的视图

JSP页面视图：

使用用户界面（在HTML中）

: d+ B6 \7 B1 d" i$ t8 P8 n4 H        访问域对象
# f$ x/ s7 W( `3 y- h* T


+ `( o1 m; q/ ?; D如何获得分发器？分发器的功能？
: h! R# a1 L; l9 E+ t上下文对象中的分发器：

" R1 f+ [' \8 MServletContext context = this.getServletContext();
6 o7 F; h) [! ~# y3 c6 t; k
RequestDispatcher servlet = context.getNamedDispatcher(“MyServlet”);
, y0 V3 P: w) }. @. i
  a: x) z+ u' z6 gservlet.forward(request, response);
9 k  j7 K* A1 Z, _
! w4 n7 J. K9 x请求对象中的分发器：

$ t$ P2 I+ k- s, T. HRequestDispatcher view = request.getRequestDispatcher(“tools/nails.jsp”);

view.forward(request, response);

* A6 v' j$ d$ o  w, f7 w' v% _可以将请求转发到另一个jsp页面，并保持请求的传递性

* R/ l: D( M) N( q( b" S+ |. T
, l' w- K1 L0 _8 k
Jsp中页面跳转的两种方式？
使用分发器跳转页面
RequestDispatcher dispatcher = request.getRequestDispatcher(“url”);

dispatcher.forword(request);
3 }8 V$ D6 R, h8 H2 c" d' ]( T/ H- s
6 H2 ]/ P, s0 C; o- L; t    特点：保持请求的传递（上一次请求中的数据，在下一个请求中仍然可以得到）；
) L* o" \; y5 u+ E* \: Q
! o2 V3 r( H& f0 m* ^8 J        转发的页面只能是同一个Web应用程序的其他Web组件
+ d) e3 h8 e6 f2 i6 V; T0 ?) L* i6 Q6 ~
" v: T! @4 v% D7 P& L9 ^使用重定向跳转页面
. P% ^  W5 [% N* z( G+ X  Tresponse.sendRedirect(“url”);
6 W0 _' E% D" q
    特点：产生全新的请求，（上一次请求中的数据，在下一个请求中不能得到）；

        重新定向的页面可以是任意的URL

! E  C! C1 J1 f' L

描述Jsp中引入另外页面的两种方法，并比较两种方法的特点？
0 x) p* {# J# ]; }2 a0 ~<%@ include file=””%> 在编译期间把另一个页面完全嵌入这个页面,可以说是一个页面

在这里可以共享变量
& c" F9 }: q+ y- N! }3 i6 t
6 G4 {9 Z0 G* C- K4 q0 A<jsp:include page=””> 动态的再运行期间把另一个页面加入这个页面,可以说是两个

, u7 b( Q( {  f! ~页面，不可以共享变量


7 l+ e' ?0 j  i, L- ]/ u0 C) v
什么是自定义标记
自定义标记库是一个Web组件，
% _5 m& O+ Q* y  g6 e( o
4 R2 D- R- T( G' a1 h& L' ?: C; ~包括：
% H) t- a$ Z: w3 n
! ]4 N" z. G: q& `4 e- E7 c一个标记库描述符文件（*.tld）

, n7 x3 n  p; L8 Y+ E8 B. z# ]- ~所有相关的标记处理器类(*.jar)

. {& n+ g: L9 |$ ^
, }% b  S( g/ U& T& E8 }7 y
" B  O# `* u. H( `' ^描述使用自定义标记的步骤，以及每步详细的工作
使用自定义标记前，要拿到.tld和.jar两类文件
5 x5 ~" }% {" Q7 n2 U
把.jar文件放到WEB-INF的lib里面。
把.tld文件放到WEB-INF根目录下。
在web.xml中配置。
% M% a1 U- q7 A) o( x( @) P<taglib>
% t  f4 E6 N$ q. ~% p* G- Y+ @
<taglib-uri>http://java.sun.com/jsp/jstl/core</taglib-uri>
8 ]3 H1 V/ \5 {2 q7 n! O9 J0 p
     <taglib-location>/WEB-INF/c.tld</taglib-location>
6 r6 [: l' Y) O+ J" k
</taglib>

  F. K/ `# f4 d4 n0 n在页面中引用。
<%@ taglib uri=“http://java.sun.com/jsp/jstl/core” prefix=“s”%>
3 d) m0 ^# R+ j1 `) a  [# L
uri必须与web.xml中的uri对应

( C& j! u5 U: wprefix是前缀，用来区分是哪一个taglib
4 }+ r( ?, n: y" [6 l: T3 F3 l# O
2 j! _6 i9 ?  b0 o- N; C使用标记
格式：<prefix:tag名称 属性>

<s:forEach >

admin

在tomcat下配置数据源
8 S7 V" @3 n& h- l! E$ I' e1、服务器与数据库的连接
& t' x# A& ^; B: G' x. N
配置server.xml文件
( t1 r3 P7 A8 d0 n+ ?
1.oracle

# E) T# s& P- ]. x5 `; D<Resource name=”jdbc/company” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”
1 D* U" i2 R& E' `2 q: e5 N
                        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”

url=”jdbcracle:thin127.0.0.1:1521rcl”
( h( U$ D3 i- j- ~! B2 O
driverClassName=”oracle.jdbc.driver.OracleDriver”

username=”aa”

# ]6 F; g# S/ l6 L3 N6 U& _password=”aa”

( P1 c" f; J6 U. w* ~maxActive=”50″

3 G" H; Y+ q! |7 A: [( M. AmaxIdle=”10″
) F  m% d" _5 Y$ Y. G3 A
: J; h8 m8 T: h# I6 ?' J0 K! H: ^* zmaxWait=”-1″

/>
; O  X3 @" r. A8 C" Y8 t9 i
2.sqlserver
, w6 k/ ?  a, M( i6 `
<Resource name=”jdbc/webpage” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”
& N, G- {$ l! |
        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”

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

DatabaseName=webpagetest”

driverClassName=”net.sourceforge.jtds.jdbc.Driver”
1 @) [0 N4 F: b4 Q  E
username=”aa”

( F8 d, ?) f5 k* Jpassword=”aa”
8 T9 U/ Z6 r8 r% e
5 m/ p4 p7 Q  J2 F  R6 ^/ Y, emaxActive=”50″
5 `5 F$ I0 \/ h& a! l) }1 H2 ]+ H
& f! d( h; ?/ y  n! P% `maxIdle=”10″
& T1 s7 A$ K1 d! W/ @- i
maxWait=”-1″

9 M/ m: J- w0 r4 l/>
8 P$ u4 ]+ t# @
% Q+ L( y8 o1 d2 t3 E0 K2、配置自己的web应用的xml文件



' T2 T+ r- e( u/ N<Context path=”/eb03web” docBase=”F:/workweb/eb03web”

7 j& i. w2 E( ~privileged=”true” antiResourceLocking=”false” antiJARLocking=”false”>
/ V4 G8 V4 u* T3 X
<ResourceLink global=”jdbc/company” name=”jdbc/company” type=”javax.sql.DataSource”/>
' e8 y! F/ Z5 H* c' t
6 a! J- p. S. X1 U% E6 T5 P6 i</Context>
. x. U: K" S$ O7 o" m3 W. N" v
4 i; F& x% u& ]0 `  r
2 P8 O  B5 B* d! q  j0 \
, e% ?; K( @* {; N" }! I0 \3、配置web.xml文件
/ K' B2 h. i5 y( j4 N* A: D8 T
0 ?8 R# H2 B3 P; [与服务器建立连接
9 W2 @$ T' X+ x; l' ]3 c
<resource-ref>

( M2 d5 ]# R& f" t4 m<res-ref-name>jdbc/company</res-ref-name>
. B! j. y+ C4 j/ q- G9 Z8 n
<res-type>javax.sql.DataSource</res-type>

<res-auth>Container</res-auth>

</resource-ref>

4、在应用程序中不直接与数据库连接，通过DataSource连接池建立连接
9 L4 p6 ~% @2 ~" E% y. G
//1.在程序单独用时设置系统的属性，在tomcat下可以不用配置，

8 q6 V& d+ {+ h$ i. R+ ISystem.setProperty(Context.PROVIDER_URL,””);
- e2 l0 E  U0 Z  n
System.setProperty(Context.INITIAL_CONTEXT_FACTORY,””);

- h1 W9 M3 W2 h! k" w//2.创建一个上下文对象
2 C$ ~2 @0 D1 j( C1 u+ ?* h" P
InitialContext context = new InitialContext();

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

4 \+ j' v3 G0 i7 d& C. ?DataSource ds = (DataSource)context.lookUp(“java:comp/env/jdbc/company”);
6 E% R! i* O2 v0 h
//4.通过数据源建立连接
5 O- q: C$ v3 c4 p- \3 T
+ l. u: G, `1 t( Qds.getConnection();

admin

ORM对象关系型数据库映射
(Object Relation Mapping)
$ \% |' }6 _9 u3 n
一、映射的特点
; h. m" B$ Q0 R" r
8 u, d, v1 `: J* }/ w. M# c1.一个对象可以对应多个表
' X% i" E; I8 Q7 E* x1 R
2 }" h! i( M; L' Q* Z$ n2.一个表可以对应多个对象

4 M( H4 e$ F( \  p) j3.对象和表的关系不用完全对应
8 `' y2 A3 m8 r) p/ A. X
1 p' f& P; m' ~5 s" H4.对象的属性的名称和表字段的名称可以不同

5.类型可以不同，但数据类型之间可以转换

6.对象中必须有主键，数据库的表对主键无所谓

7.数据库中有主外键关系时，对象中可以有，也可以没有
- c) c% [# F5 M3 J# ~+ j
. @6 e. b7 g! i+ v5 E9 f
( h8 t& \- V* D  P& _
& n9 ]( n4 }1 g, p1 j3 Z4 U二 、有一个映射的描述文件————>xml
3 N, c: A) C  W  P/ D
三 、怎样实现描述文件————>一段程序

对象 映射（mapping） 数据库

user

7 o- s6 i* `# n. E7 d0 {: eid=11
9 a, I; a. b; W$ n  t% ^
" y2 T) a" G1 r% tname=”张三”———— > (1) —————> tbl_user(id,name,age,tel,address)

. U: J" @  m& ~, _/ f% eage=25 <————(2) <————
! O- Y, T! d8 z2 ?6 [- t


(1)从对象映射到数据库

1.JDBC

2.根据描述文件来动态拼接sql

3.执行，添加到数据库中


  G! v; P# C% d' P
/ ~- a/ K0 u2 X0 k  E; L/ j(2)从数据库中映射到对象
) L! T! S8 b) J# m5 s
1.JDBC
. _$ d6 y- }% g; J. \4 x
- b' ?' e  }* `/ }/ \5 d1 Z2.拼接查询sql

$ Y% R. |" L" }3.ResultSet
, K! `' Z7 q5 r$ h- g$ E
% b+ {  l/ {/ O3 t1 j4.Model
; l  p  v' ?) t. y" d- Y8 @
8 g0 W) [) `/ U0 s' `/ @) o7 j" R! Y
- u' ~. h* l2 |; Q
# B7 p, b+ _6 P0 T9 M7 d; Lhibernate
开发流程：
) s  I% T& _7 j8 k- y
是什么？
3 P% U3 P: ~& r# {% b  d  m$ [hibernate是一种基于orm 的轻量级的框架

: y, f2 Q  _7 n

9 N7 }1 E2 z8 K. b有什么？
# G, d; i$ o% Y# b+ f1 X& ]6 K8 t1. session 保持连接状态（依赖事务和连接池）

2. Transaction事务
3 W: _6 K- [% K: p0 c& i
4 P& _8 l" a0 U: w  z" R; m8 D3.
$ F* ]% |$ x3 d  S) [( HConnection Provider 连接池
3 I6 G. v: Y# P) b/ e/ o
$ S! [# K7 }: _7 K5 C9 j) s4 c
& u* V4 c( _- f, u6 ?
( A5 ?$ }- g3 @$ ?1 v* Z* W能干什么？
  C9 |+ Z+ q$ N$ P& z, P. F1.orm

/ V/ V6 I, H* K9 `' F2.提供操作数据库的接口，简化数据持久化的编程任务
) C4 Q$ O+ S5 z8 F+ |


& I7 r+ Y8 r- `, L怎么做？
7 _( A; Z) t# W  e1.搭建hibernate的运行环境，将hibernate的包和hibernate所需要的包拷贝到lib 文件夹下

. \7 v4 D2 v- _2.O（vo）

. m# D  ?/ f6 z% K& B7 j" h( R3.R （关系型数据库中的表）
1 t* Z: A% m* r4 Z  u$ s" n
4.配置文件
+ _3 |9 m' e' }. D$ f4 N
% f1 c3 }* u6 S& p' N/ O4.1 cfg.xml 放在classes根目录下，默认名字为hibernate.cfg.xml

) T  Z6 s$ L' \& q( wa.与数据库的连接
4 ^( ]3 P8 ]: ^; x
b.可选配置
5 \' t: P- o. n8 b, J
c.映射资源的注册

4.2 hbm.xml文件 名字与类名相同 并且与类放在一起
- [2 ?) u3 {, U; D$ F
9 _- h0 }$ z4 p! u* ja. 对象与数据库表之间的映射

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

% ?4 {! Z% k; K$ d2 lc.组件之间的映射

- @( P0 ~% z6 G5 [% u0 R  w5 Nd.对象与对象之间的关系映射
8 I& x; M$ z9 h) u* ]! k) {7 X
' r8 ^6 ]3 W* o! {! x  R* E5、客户端

  a- A2 _/ ^, z1.得到SessionFactory
) h8 r+ J) ?' |; S
2.通过SessionFactory 工厂来创建Session实例
( Z$ u& k8 D# u. p
8 W. [" e3 q, \( S7 e3.打开事务

7 F! L) U8 ?0 C# l3 b: j4.操作数据库

, C' T' u+ J* h' v. i( Z/ h5.事务提交

1 |0 C. L7 p# Q, J3 {' e2 T6.关闭连接
( o$ O2 l, s9 i" B3 V% e
运行流程：
( o5 i+ T+ m4 A7 y
) h8 O% |! l6 Q整体流程
1.通过configuration来读cfg.xml文件

: S/ g. P+ b1 H4 ~5 s- ]1 K- G2.得到SessionFactory 工厂（根据数据库的连接来创建sessionfactory）

5 ]$ K$ l3 G+ a4 O7 |( \3.通过SessionFactory 工厂来创建Session实例
# p7 l9 X$ F8 d7 u: X; e2 j* s  ^
4.打开事务

5.通过session的api操作数据库

6.事务提交
7 n  y1 T( j0 I, }8 Z# H7 b7 M3 F
7.关闭连接

8 f% e5 s% H2 K" c. h
& t" `6 z8 m1 D7 [/ W! F
/ [' J7 l) t( ]4 O' Ysave
1.to—>po
, \& u5 O, N6 N+ H! _7 M, Q% _& R
2.根据model和cfg.xml中映射文件的注册来找到hbm.xml文件

3.根据hbm.xml文件和model来动态的拼sql

, u. T# v7 u  a" g! f+ N4.客户端提交或者刷新内存

5.执行sql，值放到数据库



& N# D7 J' a, ]/ }5 qupdate、delete
1.根据model 的id在内存hibernate的缓存中查找该对象
. N  ]) R% E: f0 z
如果内存中没有就到数据库中查找来保证对象的存在
% v7 `/ [/ W/ N
2.根据model和cfg.xml文件中映射文件的注册来找到hbm.xml文件

3.根据model和hbm.xml 文件来动态拼sql

4.客户端提交或者刷新内存

5.执行sql
, @& m/ f! u, u; G' t' q  l' C

( X. X6 {! ^. b' V
: g% @/ W4 _3 a, I" X" P% |Query
load

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

2.判断id对应的对象在缓存中是否存在，如果存在，就直接使用，如果不存在就进行下一步。

' |& ~6 N+ E+ A4 Q5 T3.用id做为查询条件来动态拼sql
2 x/ I. c  ]7 J9 j6 d, @: Z% B
4.执行sql 查询（先在内存中查找，如果没有找到（会抛出例外），就去数据库中查找）
) v% ^, H$ P( q- s8 E) Z
5.返回一个model类型的对象

! e  g# S) `' \+ x2 e" t" Qget

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

+ Q9 f, U2 h2 w6 E9 n1 ?2.用id做为查询条件来动态拼sql

# }' V4 Y+ l/ I; B: E: M* T3.执行sql 直接在数据库中查找，如果没有查到就会返回null
& i) m, \4 S+ v& {+ W5 Z
query

1.分析hql语句，得到model的类型
; M; i. Z/ P8 ]  I( l
2.根据moedel和cfg.xml文件中映射文件的注册找到hbm.xml文件

3.根据model和hbm.xml文件来动态拼sql

7 V) a4 _6 a& C# S4.执行sql查询数据库

( r  F& n! b. o8 D, X, R5.返回一个resultset
- r8 s" W6 O! t4 N
- _5 w; h- o4 W) E6.循环resultset的值，放到model中在放到集合（List）中


7 J5 m9 N7 w* d: ]
谈谈hibernate缓存机制
; Q* j% [# t% L9 @
5 u5 D" M. }  V0 S: g$ B缓存其实很直观的理解为放到内存或者硬盘上的一块区域，缓存就是一个缓冲的作用，有很多时候，我们的数据需要经常访问，如果放到数据库中，不是不可，只是效率上低，如果有了中间产物来代替数据库，就省很多事情了。打个比方，去买酱油，不一定一定要去酱油的生产工厂去买。代码中需要数据的时候，可以先到缓存中查找，如果存在，就直接拿数据，不存在就去数据库中取，也省了很多事。


" p" v8 Y: n- _  o6 m$ \
hibernate使用的是二级缓存，有两个级别，分别是Session，SessionFactroy级别，一级缓存是Session级别的缓存，Hiberante来管理的，这个我们一般不用管，二级缓存是SessionFactory级别的，可以进行配置和更改，加载卸载，就是我们平时用的hibernate配置文件中的配置SessionFactory的属性。
/ Z8 M) U: t& X$ q
# U% s3 }6 F; M' n9 v. L

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


. j" _! i3 _0 `' j9 z' @+ N| 一级session缓存| | 一级session缓存| |一级session缓存| |一级session缓存|

| | | |
5 G& g0 D6 D2 s
| | | |

$ f3 V6 H; k" W* A—————————————————————————————————

sessionFactroy级别的二级缓存
# B' w! C4 k  |8 U% S' A& O/ M  `3 u
——————————————————————————————————————-

|

|
& z  L8 n4 H; \# o( `* I! b
|
  }5 p4 g+ R( m) Q0 P
- ?# U; ^' T  ^8 N——————————————————————————————————————

DB

6 C. v' a& j  a' D) \( L—————————————————————————————————————–
8 x% ]' X+ Z$ Y( b: F  O  c/ p

admin

Spring

• 是什么？
  
    U( J2 j6 a; Y7 S- ]+ J

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

• 有什么？
  4 T- m0 ^3 N7 T) m: W9 u
  

9 E1 W; k5 _% o( k. x1 \$ T! `

每个包的功能：

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

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

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

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

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

AOP ：面向切面编成

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

+ h. Z# U( U! o% b

• 能干什么？
  
  

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

• 怎么用？
  
  8 Z5 `1 o: p* n2 u; ?7 n1 W- s+ \
  • 搭建web工程，引入spring的jar包
    ! U9 t) V6 \3 n$ ^& t0 u6 T" O! K
  • 在web.xml中添加如下配置
    1 i! g) b: ~4 P: o
    
  
  9 n. O" f, y1 ~2 _& U5 K
  

            contextConfigLocation
+ O6 B% \% q  P3 V, I8 {9 v; Q

            classpath*:applicationContext*.xml
- [: d* |8 \: ~. v  ~7 b

   

        
  E: D9 j+ @# T

            struts2

            

                org.apache.struts2.dispatcher.FilterDispatcher
$ i1 Q" |( `) D. F, a  I* |

            
5 k" A& P! x8 E! j' s  j

        
5 ?4 {1 M2 g, q3 Y, Z" t

        

            struts2

            /*

            

                org.springframework.web.context.ContextLoaderListener

            

        

• 部署
  
  

' X4 R3 w8 d3 n! ?( M' r' K+ v
" a) o& r3 J/ g3 j/ v; X
# x/ }' r9 _* U- R

• 容器和bean
  

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

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

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

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

" c2 q' F* T! ?" c( @

• IOC控制反转
    L  L. h2 K+ W3 j/ ^1 x  g
  0 \) d, t9 m0 C
  
  - ~; |; S* a* j2 i
  
  从前的应用程序想要得到A的实例他会直接主动的去拿，当用了sping后，应用程序由主动的去取变成被动的等待，由spring来控制应用程序所需要的对象
  
  % i4 F. w4 X6 V! L' k! }) M& I
  • IOC的优点
    
  1.可以通过IOC来获得实例
  2.可以通过DI来获取注入的资源
  • 配置IOC的原则
    
    • 一定是可变的资源才采用依赖注入
    • 一定是层间的接口或者是模块之间的相互调用才采用依赖注入
      " @* f5 ]% c; U

• DI依赖注入
  9 y1 V8 F1 j5 K: h; `, r0 @

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

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

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

例如：

在配置文件中

* H- J9 x4 D. R/ g  Z3 G
6 F3 l% P% w; _# U! g9 j

在应用程序中

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.切断了对象或组件之间的联系，使程序的结构更加松散，运行和维护更加简单

+ H- R; T2 r; m7 ?2 _) t9 g7 S" t

• Aop面向切面编程
  
  5 e+ W% E4 g6 v* ^

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

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

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

3.AOP 的概念
  \3 z( I1 _( T" f- e

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

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

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

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

5.引入 ：扩展的功能

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

7.aop代理 ：实现机制

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

4.AOP的事件机制
. g6 f% t2 P) n5 e: L0 S, Q, Y$ X

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

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

3.找到切入点

4.确定连接点

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

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

5 t3 W! U& H4 a: \% y$ B' Z

9 ~' s+ n  \- J7 m4 i

5. AspectJ
+ I2 s4 n; S' t  i3 @7 |! r9 O

5.1.在xml中配置比较烦琐
3 m3 J3 V0 G3 C2 U$ U7 I; J' z

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

  `  W$ u' S1 S8 f8 ]* U

         


         
9 z  n- i" N* Z5 G. }' U% W

        
; E/ h- {, C* E4 s2 B/ m, O

        

expression=“execution(* com.javakc.aop.MyTarget.t*())”/>
' R% p2 F% F3 C, i5 B

        
. `* {0 }( a! d8 V( G

        
" B4 t5 |, D6 O# o, p6 y9 j

   
! P+ `' C# p4 Y7 k" G: J

) F. X+ X8 J2 `6 Z1 E
' j) E2 I6 U: A  h4 M  p* [

5.3.使用注解的方法相对简单

@AspectJ的基本语法
9 B! N& ~: L1 D! ]- A9 |9 ~7 ?* B5 W

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

直接在类上定义@Aspect
9 k" Q6 [+ E5 B3 a1 d! v! R

2.@Pointcut声明切入点
* A- l! Z4 C8 l1 g5 t2 S6 {

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

2.2、可以使用匿名的pointcut
4 ^+ Z7 H- ~9 {1 P

2.3、执行切点的几种方法
0 D0 @9 |1 E2 ?, n7 h

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

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

within（”com.javakc.spring..*”）
. f) N! {: ?: G* n/ L& w8 ~4 \

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

2.3.4 target 指定具体的实现类
0 _9 n2 C$ S' w# p, X

5.4.advice的五种类型的示例

　　　 客户端必须从接口走才能得到监控，实现想要追加的功能
: p* w- z% U& l5 c0 P

5.4.1.@AfterReturning(pointcut=”” returning=”retVal”)
4 m/ g: p2 R; i" k5 G, M6 A8 Z& B/ }5 H

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

在注解@AfterReturning中必须加上pointcut和returning两个参数
' r$ M! i* q) K3 O  ]+ H3 i

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

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

完成追加的功能
( F" z. g; J! H4 V

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

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

(2).

     2.直接引用匿名的pointcut
) Z+ Y4 _1 S+ j6 o

     (1).@AfterReturning(“execution(

* com.javakc.spring.schemaaop.Api.test4())”)
4 M& _+ [5 j% u9 R5 }0 o% O

     (2).@AfterReturning(pointcut=

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

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

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

public void testAfterReturning(String str,Object retVal){
8 h4 M2 m& R% a4 y# Y

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

    }
/ x0 K& k# c! W4 v1 h: x

5.4.2.@Aronud
* c" l% z% @& z/ s# B. H) B3 a; Y' z

     注解@Around环绕追加功能；

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

     必须有参数；第一个参数的类型必须为ProceedingJoinPoint；
8 l$ _8 U; H/ H

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

目标对象的方法

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

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

     (2).@Around(“com.javakc.spring.schemaaop.TestPointcut.t2()
8 p' u! ?! B# c. ?4 I6 G! S& G

&& args(str)”)
  B6 Z/ E: v- k: t5 v; M; d" P7 x

2.直接引用匿名的pointcut

     (1).@Around(“execution(

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

     (2).@Around(“execution(

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

// @Around(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
$ c7 ]  A' w/ p1 u/ v  o. x

     @Around(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
6 H( W( h4 o1 j+ j" G9 W

public void testAround(ProceedingJoinPoint prj,String str) throws Throwable{
+ G, d+ C: v0 \! B/ G

    System.out.println(“around1==========before1pointcut==>”+str)
" O+ `3 \: q1 _- N& J; i4 Q5 h

        Object obj = prj.proceed();

        System.out.println(“around1==========after1pointcut==>”+str);
! b0 x& O6 q7 ^) x! \( i

    }
1 i, |: Q4 m/ P7 n

5.4.3.@Before
0 @" q! O5 x3 F5 J5 n/ e

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

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
6 c4 M! e3 I9 G2 z5 l8 I6 I' M

(1).@Before(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
1 m" s6 m9 e$ R, c0 q

(2).@Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
* E# r2 r- ]+ F, z# J9 g3 k

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

2.直接引用匿名的pointcut

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

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

注意args后的名称与参数名相同
" Q) g5 t, }- {

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

@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
( ^: c& a$ ]" L1 w! }

public void testBeforeParam(String str){
. X/ y- Y; W5 D' c5 D7 x

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

}

5.4.4.@After
9 ?% e3 n* u& Y

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

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

     (1).@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
  x- Q- _( L0 i8 y/ C0 p, W

     2.直接引用匿名的pointcut
$ `: g# o+ ~" [4 X' R

     (1).@After(“execution(* com.javakc.spring.schemaaop.Api.test1())”)
6 V  w5 C! {9 j; x* j0 @4 h3 |2 `2 \

@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
8 `$ T: r: M8 }3 l

    public void testAfter(){

    System.out.println(“after1== >pointcut”);
  Q9 Y; z$ O5 F$ G& `! K5 ~6 K& ~

    }
3 x( C3 h( ^* j! k( W  l

5.4.5.@AfterThorwing

. s1 }- `! W. C- d9 q8 A1 T2 g# E

• 描述一下spring中BeanFactory和ApplicationContext的差别
  4 p* ^# ^2 N/ C5 Y. O5 X' z0 T
  4 U6 Q% z# B# z' @

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的支持
  
  $ _* g/ [7 |' h; A- [$ j

Spring提供的DAO(数据访问对象)支持主要的目的是便于以标准的方式使用不同的数据访问技术。
/ G/ y- A3 f! H3 A

简化 DAO 组件的开发。
4 V( q: L! G. ]* q* H) n- HSpring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法，用来简化代码开发。

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

面向接口编程及 DAO 模式的使用，提高了系统组件之间的解耦，降低了系统重构的成本。
1 k. F6 G2 R: X( w; \, W

方便的事务管理: Spring的声明式事务管理力度是方法级。
0 t8 V, y7 C/ M3 j% j: D; w

异常包装:Spring能够包装Hibernate异常，把它们从CheckedException变为RuntimeException; 开发者可选择在恰当的层处理数据中不可恢复的异常，从而避免烦琐的 catch/throw 及异常声明。
! ^" M$ a% F1 p- n: L' F4 [

$ K8 w9 k* M5 r# U

• 谈谈spring对hibernate的支持
  
  ; H: Y! i% u; O3 \! s

在所有的 ORM 框架中， Sping 对 Hibernate 的支持最好。如 SessionFactory 的注入、HibernateTemplate 的简化操作及 DAO 支持等。另外， Spring 还提供了统一的异常体系及声明式事务管理等。
: d& j( I* K+ o3 }/ A  T; U$ s5 L

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

1、通用的资源管理: Spring 的 ApplicationContext 能管理 SessionFactory，使得配置值很容易被管理和修改，无须使用Hibernate 的配置文件。详细配置如下：
/ r0 t' ?7 ]& O- O% m

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

        

            oracle.jdbc.driver.OracleDriver

        

        

            jdbcracle:thinlocalhost:1521rcl
5 T% _) P- F; h( [" B# X0 K6 h

        
* @& D& i' A4 u3 B. ?

        
5 r. G6 l4 c! [8 m" L6 `  {

            javakc2
: B! b# y* {# ^% f3 u. {

        

        
! }6 @9 c. l1 q- [  }' X

            javakc2
0 u( Y( w8 P5 N$ l$ t$ Q/ G% q! `

        
7 C8 X% U+ U0 R6 |

   
/ ?* A9 q2 Q# b, H

+ M0 I0 s  M* ]5 r& x+ e1 J

   

        class=“org.springframework.orm.hibernate3.LocalSessionFactoryBean”>
! o& m0 ]  x+ W6 b/ P

        
5 _8 S8 P7 U  G, d3 G8 O0 C* t

        
; Q$ \7 k6 V  B( W7 b

            

                com/javakc/spring/h3/UserModel.hbm.xml
3 @' W/ S1 i! s( n

            
6 }& }, X& p" P1 e, m9 e! X( }" D# S

        

        

            

                hibernate.dialect=org.hibernate.dialect.OracleDialect
2 s1 y- |. b( j' {

            
3 u8 Z! a2 r: M' ?9 D; R; x* \

        

   
+ _* e# P( z  ]

   
8 u" i$ J/ O: }; F/ |: P/ x

        

   

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

   

        class=“org.springframework.jndi.JndiObjectFactoryBean”>
1 ?+ X+ ^' d- M$ {0 k5 s. a

        
. [  ?0 \5 C3 ]" S% F

            java:comp/env/jdbc/myds

        
! U1 `% b% S7 z3 z

   

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

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

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

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

   

        

   

   
( \& u5 {/ `" J2 m" P6 _

        

            
+ V$ J# j" E" G. ]4 y& j" l

        

   
) s5 u" n% S- {: F

' D$ }+ p, O6 L; f! A

   
9 h4 D9 I: ^3 N

        

        
" O: o* Z1 b+ m! B$ [

   
8 O  q8 f1 [. S' T

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

Spring2.0之前事务的写法 3 l; C/ C9 e+ ~1 F/ x         class=”org.springframework.transaction.interceptor.TransactionProxyFactoryBean” " P2 W. @- v- v * g$ J: S2 C! Z1 t4 L+ m2 F6 `2 r        abstract=”true”> , Z. P) T" V, |6 U$ ]: D3 U 5 f% ~" [& n- ?0 H 6 {, F% A7 i- p0 {2 {! x4 r8 c " o5 t$ H# V6 K                PROPAGATION_REQUIRED,readOnly 3 a% R$ O+ B8 s3 }2 _; t                 PROPAGATION_REQUIRED 4 c  p& m9 w5 V5 W2 m' q & h3 H/ Q; E8 Z

1 ]& [7 ^/ h4 P
9 \" i# D2 ]6 X5 z; a& K( s

• 谈谈Spring对事务的支持
  
  ! t/ T  [6 V9 d+ |# s5 ?

; @: _( p6 @* ]# N9 m1、声明式事务管理：

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

2.做法：

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

2.2

2.3 注入数据源

7 w. B$ j' f* T% T! c4 \



, f9 c. ^) Q. ]4 }6 |8 x
9 B1 A8 z  [5 v/ A5 C

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

% _6 m$ c* F1 w! u8 ?  V4 L

! i( |# t5 M7 X% Z

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

; n* [( ?( H# k" W

6 w3 l: ?& Z$ l1 ~( K# N

2.6 定义切入点

* k3 o  r1 ]' O0 k
0 \$ m, p8 F* r5 o, S

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

1.注解@Transcational

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

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

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

$ G  ^' P+ s) Y2 e  y8 J

如何在Spring中使用Hibernate的事务：
8 h. l$ {4 Q7 s

! Q* I9 j9 }" _

# m0 b3 E) s: _( E

3 s/ M- F/ |" n) @2 s2 d- e

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

, B5 A/ l) O6 [3 b8 H1 c$ I

admin

事务
ACID
  z9 M& s0 q) r3 {- y9 ^/ W# ?. O（1）原子性（A）：一系列的操作具有不可分割性，要么成功，要么失败
1 }* d- g+ [2 h! m
（2）一致性 ：操作的前后满足同样的规则，保持平衡。
2 A  Q# k5 R7 s; U% p+ M7 ^  z
" P; W( Z. a! E& [3 P0 ~- X（3）隔离性 ：在事务运行的过程中。事务内的数据对外的可见性和可操作性（必需由数据库的支持）

（4）稳定性 ：保证数据在事务的操作的过程中不会遭到破坏，而且是永久性存储的

7 M3 I0 d! `1 b$ i  [  |5 S0 Y* C3 q  r: t

; r$ G  L0 n! `事务模型
0 |8 ?! s- @. q: c3 d& P（1）经典事务模型又叫平面事务模型（JDBC） 事务不允许嵌套

（2）嵌套事务模型


% q& s- [( A* P
- D/ \( y4 G- T" l/ {事务的两种方式
, ^% y0 {6 ~; m3 O（1）声明式

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

  z' t! U9 O- i6 b) G; L% a（１）.required

7 L2 t, F9 L. O, h' Q9 o2 x如果客户端没有事务　在bean中新起一个事务

! G1 q8 E$ i2 ?- M# x/ O如果客户端有事务bean 中就加进去

(2)、 requiresNew

5 a7 r. k6 {' X5 M: g/ b不管客户端有没有事务服务器段都新起一个事务
) K* _/ N! e  M6 R5 x( {/ w7 `
如果客户端有事务就将事务挂起
. `# A5 g4 Q8 A, w! s
(3)、supports
3 P3 Y+ c5 ]/ r8 ?5 t- ?# C
7 ]5 C/ D9 u, K5 r9 d如果客户端没有事务服务端也没有事务
$ f6 O6 y2 f+ k
如果客户端有事务服务端就加一个事务
) }4 L& t0 e) }6 U8 e
0 p% I$ e& D) q/ D& D6 \% [(4)、mandatcry

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

/ L# A; r+ z7 a( q# F如果客户端有事务服务端就加事务

(5)、notSupported
* I6 C3 m  |- _5 a0 g- x- }6 A9 \
, e2 _" W9 l8 h4 A$ R不管客户端有没有事务服务端都没有事务

4 n3 f* B3 z% ~' }  z. ^! t  a7 k如果客户端有事务服务端就挂起

$ m! Z' ~/ A3 o" |! ~3 S/ U(6)、never
3 T2 i$ e) z  p4 O8 m% m
不管客户端有没有事务服务端都没有事务
3 \! {6 ~, k9 e- o
如果客户端有事务就报错

! C$ d! r' @" V$ Y（2）编程式事务

8 f) N. i/ ]' q  P2 Z' g. BJavax.transaction.UserTranscation
- U( A. v/ H5 N' H
JTA 事务可以精确到事务的开始和结束
% H9 d9 L. o) G


; Y* R0 ~5 k: y9 [5 z8 k  C; W事务的隔离性
Read-uncommited

; g- K3 P, K$ o/ h* K读取未提交的数据（基本上没有锁）脏读，存在不当读取的问题。
2 c( y% @/ t  i4 S( p. u( ?
# Z2 T* C- ?* J% N# URead-commited
" W' y; x( P/ `3 Z% h8 B9 \0 d  |
: L- p  C& [+ o7 t8 D; `. Z, |读取已提交的数据（行级锁）
! v% c; v6 t* k8 U4 E1 C  G
* z/ N8 m' @- w5 y( [; t, n- U1 [无法读取已经写入，但没有被提交的数据。
6 o7 p# G6 n$ Z
Repeatable_read

: J* {% Z; p5 v4 d4 ~- r% c读取的数据不允许修改或删除

" L; V) U/ p5 p* z- v# h不可重复读（行级锁+不允许修改/删除）

# ?( M# U3 U1 PSerializable

幻影读（表级锁）
1 v4 V' s) g; [2 l- @- r- i
; ?# y: n/ C  E6 D
6 o. w& x  b3 ~- s6 W- ]
, c' q3 Q3 P  A$ Q4 cstruts
2 U3 s9 ^& v1 q& t. W开发流程

1、创建表单

0 u9 I; C5 U6 r2 \1 }: `' `2、从表单中获得输入
! n, }3 e% z0 p2 \' |
3、处理输入（业务逻辑）
2 {& r4 f/ T* S9 E; K; A
7 m; C$ v6 f2 E7 B: M# e4、根据动态输入改变输入流
' v" N# v* q3 J& b6 ^6 I8 ^/ F; R
) A8 w  G/ {% |4 w4 J6 o6 r要完成上述四步，我们需要创建

1、一个ActionForm

2、一个action

3、一个配置文件struts-config.xml
; H; f: L6 S. q* j
: l* E9 U4 Z" j4、创建页面

9 Q% n/ s( V& ]7 x6 u创建ActionForm

2 M% g( B: g" |/ L; N1、写一个类继承ActionForm

" \0 ^7 J) U6 |4 N2、私有的属性

3、相应的get、set方法
, `+ v4 K, x5 n
$ L$ d/ E2 s; ^" ?6 J0 j4、重写tostring、equals、hashcode三个方法
! S: ~$ J! s+ B, W' A! p' x
- w  O8 p% w& L9 M创建action

1、写一个类继承Action

2、实现一个公有的方法（回调方法）
; Q( j- u9 e3 T! Y; @! p
( {6 `. I3 z2 G4 L/ f3 I* L( wpublic ActionForward execute(ActionMapping mapping,

# F- h$ f6 O- w8 p# ]ActionForm form,
: q. s7 v0 H( w( I. O0 f
) U  F  v5 S4 H& HHttpServletRequest request,

HttpServletResponse response)

{

//1.收集参数
8 t7 ?, D9 P! g8 h
MyActionForm myForm = (MyActionForm)form;
5 ~& f4 ^9 c( j; |
//2.组织参数
+ R3 {3 Q7 U7 H6 {0 B* G9 O; B& @
' F, \$ l$ k. N+ C: H& |% V! \

//3.调用逻辑层

boolean flag = true;

//4.根据返回值来跳转到相应的页面
2 a; G* e) x" b; i# B: j
ActionForward af = new ActionForward();
! c' P5 V) G& O6 z1 K5 M
& g' S5 J4 m8 A$ u5 ]5 e- D4 ~) zif(flag){
: [- w( ~4 z8 d7 @3 E2 ]5 o& D. y
3 `! o* n4 d4 n* ?af = mapping.findForward(“1″);
, o" @+ P: w0 Y5 ]4 q2 ~( j
' D: T' ~/ b9 K. p% Z}else{

af = mapping.findForward(“2″);
$ t9 V5 i1 F0 e
}

return af;
' B4 O2 N4 w  R6 R/ H
}
7 B7 ?% I+ p4 V; T$ R, W
, s7 b. d% N/ n: h4 W配置struts-config.xml文件
0 b1 T( ]+ `; a9 D% p$ p
' M! ~% f1 m& }( z  j# g1.<form-beans>
6 p! v& U' W9 v* x
<form-bean name=”myActionForm” type=”全路径.MyActionForm”/>
& O* X' P$ ]+ {- V  G; H$ q
<form-bean />

$ D4 I; ]' |! U/ l0 o$ @</form-beans>

2.<action-mappings>
' _" g. {+ j. _  ?% ^. A0 g9 P- [
1 m! F/ b1 G/ z<action path=”/sll”

name=”myActionForm”

" n( M8 V2 a! |' m+ X7 Vtype=”全路径.MyAction”

scope=”session”

- i5 A6 f7 o: i3 I7 tinput=”错误返回的页面”>

: ^! [1 b" `  m) _1 g; G% R<forward name=”1″ path=”/1.jsp”>
9 Z: t" P( K) R3 l5 L
<forward name=”2″ path=”/2.jsp”>

</action>

5 s8 T! a' G: Z* y</action-mappings>

步骤:
5 v! q6 I/ ]& o
. {0 d9 D" `6 P% ?$ v1.创建一个空的web应用

2.将struts的包放到lib文件夹下
/ Q0 _' r& k, e6 b  @
3.将.tld文件文件和struts-config.xml、web.xml放到WEB-INF的跟目录下
0 N+ a8 M6 ?' a5 {, ?) S
4.配置struts-config.xml文件和web.xml文件
7 T2 J6 ^: G! M! {2 Y& o9 n+ @% ?  M
+ C" l+ R2 j1 S% k5.在页面引入tag文件uri

STRUTS运行机制
& r% b- b6 q' _6 X0 M7 _) k% c' Z# f
1、界面点击产生请求
5 s' m5 D. u0 e$ L+ _
. E" ?4 Y# o9 G: I- q) v4 s2、容器接到请求

3、匹配web.xml文件中的*.do来调用ActionServlet
1 k$ l0 g3 w1 m0 m1 M: T
$ A1 Y% }6 C/ V9 o7 [0 d) f4、ActionServlet的处理

4.1 读struts-congfig.xml文件形成ActionMapping
. Z% O6 z$ Y! _) h! e; }
4.2 通过path 来匹配Action类，通过Action的name属性来匹配ActionForm类
9 ?6 w7 @: \4 i2 r/ {$ `
& l9 O& w( \% e( X4.3 通过反射机制来给Form添数据

1 F) L8 U! ~$ x4 k4.4 由ActionServlet转调Action的execute方法

) a2 E$ V" T  ~4.5 得到execute方法的返回值，跳转页面
$ t2 w" E7 Z# a# v" w5 i3 B
4.5.1 RequestDispatcher

4.5.2 response.sendRedirect(“list.jsp”);
, M+ \8 z& W1 m4 v4 v% z8 X


& t+ c5 }$ z: x$ n4 |* j3 U$ ~# g进入execute方法
  o0 S( F! t9 W6 {8 G
/ q) y. Z' R: q1 收集参数
# m1 @0 U7 p% R; W
! ?8 E1 Z/ i% V. f2 组织参数

) Z- }  W% Q1 }5 U. m6 J. y3 调用，逻辑层

0 P2 f+ t2 Y3 _4 返回值

6 Z) [# |7 Z  e9 J4.1 选择下一个页面 （ActionForward）
8 R, i. l6 q2 X" ?5 s" l8 n
4.2 把值传给下一个页面

: |+ q/ [' {' \2 @  o" i4 c  ~) X
7 y2 X  v% `2 B* h
# c5 f3 I: E. Q8 D% M$ ]: V比较struts和struts2的不同

2 f) p3 M+ }# l' b+ O" r7 zStruts

Struts2

" d. k1 B+ @! C组成        五个部分：ActionServlet，ActionMapping，AtcionForward，ActionForm，Action        十个部分：AcionContext，FilterDispatcher，ActionMapper，ActionProxy，Configuration Manager，Action Invocation，Interceptot，Action，Result，Taglib
, o8 g. a# J0 H# v5 Eurl        .do        .action
分发控制        AtcionServlet        FilterDispatcher
收集参数        利用JavaBean技术，将数据封装到ActionForm的子类中；
6 k5 Y0 x$ e, ~7 P$ I, C一个Action对应一个ActionForm的子类

使用拦截器将数据封装到值栈中。
% Z6 m. ~$ i/ I! h* D" a7 \" _7 J使用域模型，一个Action对应多个值栈中的Model

" I$ _9 f' D' g) x& i读取配置文件        ActionMapping        Configuration Manager
2 z/ j4 U4 I9 D拦截器        无拦截器        执行Action前后有拦截器
返回页面        将字符串封装到AtcionForward，进行跳转页面        Action中直接返回字符串，通过Result跳转页面
6 p! ]$ g1 R& m, J) l) c4 X+ f页面跳转方式        两种：dispatch，redirect        三种：dispatch，redirect，chain
9 s" L: e. R1 Y4 t- c5 H值栈        无值栈，Action通过在request范围内设置属性，向jsp页面传递数据        有值栈，Action和jsp页面通过值栈传递数据，jsp页面通过OGNL取得值栈中的数据
8 O$ Y  e  S4 u- p2 A5 R' h配置文件        struts-config.xml        struts.xml
1 {5 f& ~/ [( H* \中文问题        不能解决（需要使用filter）        可以解决中文问题：
1、在jsp页面添加Meta；

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

admin

其他开发工具和技术
Ant
2 B' G( y1 h- n. K0 _; b: |Ant是基于java的批处理工具

一、配置ant的运行环境
" q2 d) a* {, @* S
1.将ant的bin目录添加到path中
: Q! _: C! E- x) t6 Z
4 ?$ J6 P9 C8 l3 d. J7 D# }" k2.配置JAVA_HOME

) w; Z7 [# s( k8 l3.配置ANT_HOME
" Q. q0 \, b" N; I4 W% w
4 S1 O# F+ A& U, D9 v二、配制build.xml文件，该文件放在应用程序的根目录下
! x3 }% b( c0 U6 N
$ l5 E- l, S  _( l/ @8 O编译java文件
! h" R0 a9 {. p5 ]: i
执行java文件
% W$ j& L: V8 o7 a
copy
8 s- g5 |$ i7 c1 n2 ~- J+ {
删除
' O$ |7 F& ~+ ^
打jar包

8 H5 ]! e+ B0 e3 P+ V2 R- w& t6 [根据注解生成配置文件

* P' R1 W0 A) T8 \2 g- B" P' pXdoclet
通过注释生成一系列文件的工具（txt、xml、java、html等）

. q$ f5 M5 b' x# G( e- [xdoclet本质是摸板技术+字符串的替换
7 }) T4 h6 o  O- p9 G# Z
! e' J* C4 ?5 @+ }1.在java文件中写符合要求的注释（将hbm.xml文件的内容搬到java文件中去写）

1.1 在类的上面 写与表的对应

& _/ m) g6 ?) ]- `& t$ g; V1.2 将每一个属性的注释都写到get方法的上面

2.在ant中引入相应的task来驱动xdoclet


9 `0 {3 B: K" H; V
log4j日志管理
1、是什么？
0 M" Y) f4 R- ]
' O, d. C5 z0 ^; @$ \1 i在开发期间用来测试、对整个日志信息进行管理的工具
! f* N0 @: N( n  ]
2、功能

. J1 O* Q$ m! n0 A' N% B. g- ]1.控制输出的目的地

2. 控制输出的格式
- l* d; b, q0 ?# X/ b
+ C& c  g& k& A4 Q( p' ?3. 控制输出的级别

+ I, W+ n* z- H) @3、日志的级别
7 T3 t' K% g* H2 A  e' `
( N7 g3 L6 O: O& f& C7 B) g3 ^! K. d8 b( ^1. debug 调试

# B1 V) H7 X9 C: T+ y: |. v2. info 给用户的提示信息
0 X4 }$ {3 o4 V) Q
. r* |: P; y6 \% X) q' Q3. warn 给用户的警告信息
! b3 r  b% F9 d* H) L5 m9 u
) m' z0 p# f2 {4 n9 z4.error 给程序员用来调试
# H6 g7 U  k3 o* L" T5 M$ C0 b  H+ R
Debug—-〉info—-〉warn——–〉error

( t, [/ j5 \7 @% [3 n& \  [4、配置
/ z2 l8 b& S' ^
1.配置级别
+ l4 \1 ]0 c; q1 m8 c& `
2.输入源 （控制台和文件）

# h- H  V) J  I' T( j+ w3.可以进行分包控制

& g' b  N& N$ d: wLog4f.logger.包结构 = 级别
) x- y6 z& E: j; B! a, C, Z- ?
: |* _9 D# V& ]. v  e+ P. l5、使用

0 c6 o( R+ E% D! A4 KLogger log=Logger.getLogger(Test.class);
' t" d& Q1 Y) K
  [* f) |0 F( F    public
void t3(){

        log.debug(“this is debug”);
5 `- c, X1 t* y  g+ A" }$ W$ ~+ Y" L6 g
        log.info(“this is info”);

8 m& T* d; J' X: D1 Q! B: K& K        log.warn(“this is warn “);
. J; l$ r2 {, C% k: u) w
        log.error(“this is error”);
3 Z# ]8 L+ r0 b+ ^& q
    }
: Z6 U5 m# h5 r6 R1 W# Z
Junit
1.是什么？
) S: _5 y; E( `3 d# h) y1 n
单元测试的框架

2.怎么做？
5 y( F; j5 C# O' h! I
& e0 B6 |$ g0 K5 s写一个类继承TestCase

测试的方法一般都以test开头并且没有参数
: y7 S/ ~% s$ v0 T; M- }
& m' q- N- Y; \. v在测试方法前执行的方法public void setUp( )
! F2 V+ |6 W# M) ^2 R! D( Y( s
在测试方法后执行的方法public void tearDown( )
# N7 \5 }7 o0 O- P' Y% [5 N7 X
error和故障的区别
$ H4 ]& [8 K2 j" l* U
error ：代码有问题

故障 ：逻辑有问题与祈望的值不相符合
5 n* x+ r" u: m7 J2 s- o
6 b8 V$ A7 i& ^8 B生命周期
3 H& M7 R& ~3 d: N9 d2 {# v' i1 X
! e7 ]9 q, U9 j9 _1 E" Y7 j* U测试—〉SetUp（）—〉testXX（）—〉tearDown（）—〉结束；

3 G6 k8 B! h# t9 m8 K8 o8 S+ sTestCase套件
# i" W9 f7 I3 h% n* ?
0 r$ @: |8 @$ p3 U( [; }public class MyTest{
0 p- e7 A5 ~. Y( h6 }7 @) q
        Public static Test suite(){

TestSuite suite = new TestSuite();

suite.addTestCase(Test1.class);

5 a' D: E* y3 H' x2 Y6 `6 usuite.addTestCase(Test2.class);

; ]1 I8 o/ h3 L" S; R}
/ P8 E7 N, E5 o& Q) i* M
}
! |* ~" p6 {$ e( W8 n5 d
2 V! h6 ^- b5 o

. q# D0 t% b' m) v+ u1 oAjax
是什么？
AJAX即“Asynchronous JavaScript and XML”（异步JavaScript和XML)。是一种创建交互式网页应用的网页开发技术。

无刷新页面。

有什么？
) X9 h  O# {+ ]AJAX是多种技术的综合，包括JavaScript、XHTML和CSS、DOM、XML 和 XSLT、XMLHttpRequest。

能干什么？
使用XHTML+CSS标准化呈现；
使用DOM进行动态显示及交互；
使用 XML 和 XSLT 进行数据交换及相关操作；
使用 XMLHttpRequest 进行异步数据查询、检索；
7 Q6 n4 H4 `6 P2 R3 s使用JavaScript绑定和处理有所得数据；
' H* i5 L' j9 o! G' c
传统的web应用允许用户填写表单(form)，当提交表单时就向web服务器发送一个请求。服务器接收并处理传来的表单，然後返回一个新的网页。这个做法浪费了许多带宽，因为在前後两个页面中的大部分HTML代码往往是相同的。由于每次应用的交互都需要向服务器发送请求，应用的响应时间就依赖于服务器的响应时间。这导致了用户界面的响应比本地应用慢得多。
# z* o' @. O- `' u! g
6 D! o5 O3 g$ \& f$ R5 h5 C与此不同，AJAX应用可以仅向服务器发送并取回必需的数据，它使用SOAP或其它一些基于XML的web service接口，并在客户端采用JavaScript处理来自服务器的响应。因为在服务器和浏览器之间交换的数据大量减少，结果我们就能看到响应更快的应用。同时很多的处理工作可以在发出请求的客户端机器上完成，所以Web服务器的处理时间也减少了。
7 i: G7 M; D& w! L* _: l
# Y, A$ L0 w* G使用Ajax的最大优点，就是能在不更新整个页面的前提下维护数据。这使得Web应用程序更为迅捷地回应用户动作，并避免了在网络上发送那些没有改变过的信息。
+ B/ s$ `5 f  P! O8 C+ z* q
对应用Ajax最主要的批评就是：
1 它破坏了浏览器后退按钮的正常行为，就是用户点击后退按钮后不能看到之前的数据；
2 一些手持设备（如手机、PDA等）现在还不能很好的支持Ajax；
3 用JavaScript作的Ajax引擎，JavaScript的兼容性和DeBug都是让人头痛的事；
4 Ajax的无刷新重载，由于页面的变化没有刷新重载那么明显，所以容易给用户带来困扰――用户不太清楚现在的数据是新的还是已经更新过的；现有的解决有：在相关位置提示、数据更新的区域设计得比较明显、数据更新后给用户提示等;

' \4 p4 \9 f. g& X怎么做？
<script language=”javascript”>
# h) N6 b/ C6 W9 G- h
var req;

' `% S) a8 B, z! q4 k# ?function add(){

, g; G  V# W2 A+ R8 C; p//1:创建用于传输的对象
. |, x1 r! n3 g7 ~
$ b; f" c2 a  P* Y: q+ k( freq=new ActiveXObject(“Microsoft.XMLHTTP”);
3 n. v# I4 e  t2 k( s7 n1 w+ }
( u. Q/ h/ {" Y/ V) L// 声明返回后，处理数据的方法

. Q% z/ Q) Y% ~9 I# u2 _& {& A. f! B2 preq.onreadystatechange=manage;

//2:准备传输的内容
/ b; v9 X) ?3 }% {& o* J
% f) m7 Y8 T; `9 n# Pvar str=”test1111″;
, y; f3 r, M2 L8 z5 J
6 N$ q( c  D/ K' V1 J//3:发出请求
" g3 L% \0 q, ]5 l
! W, h( R7 S: v) N" greq.open(“GET” ,”/others/ajax/test/t2.jsp?str=”+str);
/ W7 H3 J* B( K) _7 {
3 k0 T- R0 L7 ^9 K3 t7 a  _req.send(null);

! V; [1 C3 C) N( I2 i9 S}

2 ^: w$ ^' |, `' O& r//4:接受返回并处理

function manage(){
% {2 N1 r4 ?8 W5 q" g- U
if(req.readyState==4){

$ q1 V: J5 j1 y% _2 O* K" Jalert(“r==”+req.responseText);
& c4 q, s: t# _( R( t6 |
}
& L6 Z! s$ f) k( r
) l! D6 S2 [7 k  x5 G, t}

</script>
3 t5 `$ F2 B  a8 n8 g
readyState的取值如下：

　　0 (未初始化)

　　1 (正在装载)

2 B: _% I: y' i* l　　2 (装载完毕)
0 l0 ~, W9 c/ G: w
6 k6 O" J9 }* e, K　　3 (交互中)

　　4 (完成)
. ?! t* I5 w( J' @( A% D' K# o9 I2 V


原理
1 T( k  u3 e) w$ sAjax的原理简单来说通过XmlHttpRequest对象来向服务器发异步请求，从服务器获得数据，可以是xml格式，也可以是一个字符串，然后用javascript来操作DOM而更新页面。
7 d# k) E* V% C! Q. `
$ e& E; W& T  V) R5 y+ a3 d+ r' qDwr
是什么？
DWR（Direct Web Remoting）是一个开源的类库，可以帮助开发人员开发包含AJAX技术的页面。它可以允许在页面中使用运行在WEB服务器上的JAVA函数,被调用的JAVA函数就像是在页面中JavaScript方法一样。
) s8 i6 M" {' A8 [5 j9 o- y* X
( z% g, E! X; p' @, Y1 B4 [有什么？
4 |/ r: K5 H2 D0 i9 B0 c它包含两个主要的部分：允许JavaScript从WEB服务器上一个遵循了AJAX原则的Servlet中获取数据；另外一方面提供了一个JavaScript库可以帮助web开发人员轻松地利用获取的数据来动态改变网页的内容。
3 o3 B1 l7 V2 e( M  p) U0 L8 }2 X

+ d1 k6 g/ M% e# {+ @, N9 N
能干什么？
动态地把java类生成为JavaScript，感觉调用就像发生在浏览器端，实际上代码调用发生在服务器端，Dwr负责数据的传递和转换。这种从Java到JavaScript的远程调用功能的方式使DWR用起来有种非常像RMI或者SOAP的常规RPC机制。

2 ~7 T7 Z1 d- w1 G; [5 L) M4 Y

. ^9 e* C$ x& y% A$ @怎么做？
  d  }8 s7 a$ l" B, e! }- E  j/ l5 D① 编写配置文件

# a6 w2 c" j6 D: r0 Yweb.xml

8 g( \- L0 }& f- _3 g" F0 }<servlet>

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

: [- e& V- S* I  \; V7 f- k% p: p<servlet-class>
3 h* @% t& @# e) A9 c
) N; |, y, x3 ]4 Q$ \; B% H, Porg.directwebremoting.servlet.DwrServlet
" N; J$ ]6 u( H6 F" m1 b0 f
3 d* O0 H1 S5 |</servlet-class>

0 t3 m3 [, x/ b+ X6 t  R<init-param>
1 n" X& D" T3 x; V- }
6 j2 P& r( h4 }0 l+ I4 M<param-name>debug</param-name>
: R! A& b3 N! }% s5 o% e; e' w
<param-value>true</param-value>

</init-param>
- B6 |" |( c, J7 V
, v0 a6 g5 `! l</servlet>

<servlet-mapping>
2 r& ~8 a$ }7 y, D. N3 Y1 v
<servlet-name>dwr-invoker</servlet-name>
: j2 r+ |5 Q! L1 w, n4 w* n+ b8 e6 B) [9 L
<url-pattern>/dwr/*</url-pattern>
3 q0 o8 O0 s& Y
* W+ ]* G1 J  ]2 q</servlet-mapping>
7 d% @, T; N1 O8 f
dwr.xml
9 _* _* [/ ~( y' X( F! b
<allow>

9 j$ q, r4 H+ t( k# S<create creator=”new” javascript=”kc2″>
* O. h. u4 B: `3 u! @0 t8 K
$ P$ m8 @0 H* m( N7 N* b* C9 ~6 N<param name=”class” value=”dwr.Service” />

</create>

" n2 D: Z/ K% T) a" g3 O( O</allow>

# P9 ?% l& x2 W" ?# ?/ s# H②编写service
, d  h+ V" z: d& N" U
public class Service {
6 [7 W/ k) P: ?7 b6 G
; U3 P3 J+ D$ V8 mpublic String sayHello(String yourName) {

/ p7 P7 H* J. u//可以是访问数据库的复杂代码

9 O( c6 @. ^1 v/ |+ A' |0 Wreturn “Hello World ” + yourName;

  k( J4 J, z) E8 ^" _}

" s: j3 m4 Z! O' c# V' w}
1 ^0 P+ |' l) V" W
# C' c- H6 G3 S$ K9 V7 @③测试DWR
+ b' k7 `( n7 K! J
将代码放入应用服务器（比如Tomcat），启动。

然后在地址栏输入http://localhost:8080/你的工程/dwr

④编写jsp页面

- ~' U1 }& }: r; c1） 要引用3个dwr的js，其中engine.js必须要，如果需要用到dwr提供的一些方便的工具要引用util.js

2） 然后还要引用dwr自动生成的js，dwr/interface/service.js，注意js名字要和dwr.xml配置的一样
1 M8 {3 o( i6 n: V
3） js里的service.sayHello和java类的那个有一点区别，多了一个参数，用来得到返回的数据