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

admin

JEE
! ~- [. A2 ^8 e9 R/ `) y$ y. u/ `简述JEE
JEE　： JAVA　 PLATFORM　 ENTERPRISE　 EDITION
; d( V* d9 f$ d5 \* J) S# K4 X
' h" d+ Q6 y8 |" LJEE是一个规范集；

4 K$ K: F0 w: `8 }) |& q. gJEE是一个框架集；

$ d9 h) c- [: V5 L, {# a# X$ v& V# nJEE是一个技术集或API集；

适用于创建服务器端的大型的软件服务系统
! g% l7 x$ ?. v7 i% {; o

6 q/ s$ A/ w" U5 z3 p* c
5 @/ s2 T; j/ W0 }, [3 j) jC/S B/S 模式
4 T9 f; k. t7 T" M2 C$ U* hC/S client/server即客户机/服务器模式，客户端也参与程序的运行与计算（富客户端、胖客户端）
, G) M+ I, ]& z4 W4 y" m6 y  b/ ~
" R" C% ~* `6 C! ^# r6 G7 C: Y) ]- k1 z2 DB/S border/server即浏览器/服务器模式，又称为瘦客户端，客户端不参与程序的运行与计算
0 I- K0 U$ o/ I" E* G


企业级应用（大规模的应用）的特点
5 j7 s2 Z/ ^- Q- s& E1.生命周期长、稳定、可靠
$ W/ v. N) ^; j/ b; {( Y: Y4 i
. C) |7 Z6 M* v' {2.组件往往分布在异构的环境中，能够跨平台
4 r4 \. I8 U4 J% [* l+ {7 u
4 _/ x: o- K5 a1 {5 o1 K3.维护性、扩展性、重用性
& X9 _4 ]; N: A4 B; D3 ?: S# V0 u
9 f/ N: n1 g! D" j8 r1 N4.有事务、安全、线程
7 A0 f8 l3 _6 ?5 s; Z* v
0 O# P8 |- y$ X

( Q- [0 h9 ^) o  h, V$ Z, Z9 Q什么是业务逻辑？
+ u3 P5 C! |. ]8 h; ^, r  _' S; @依照业务逻辑划分模块，

2 c3 p0 ~2 y( ?  y& V2 q* ~7 V8 |8 g所谓判定业务　就是具有以下特征：

1.业务流程
5 z4 X( v6 m0 g
; j9 o% w7 O' l( j3 n/ i2.业务判断
8 |4 Z$ |3 ?) W6 t$ y: m* R
3.功能组合

$ d( S+ c: k4 f. Q* W+ [1 Y
% r2 j$ _9 c+ D$ P, d! ^/ u+ z1 [
+ L7 ^  ^4 p) s) K平台（角色）的划分
0 H+ d  w% F' k8 @! ^" d1.平台供应商。提供满足API集实现的厂商（BEA weblogic IBM webshphere）
' t  D  U$ ^* N: g) B. A3 i4 @' _2 y
2.组件供应商
: I) V/ }/ c! |- x& y  Y" U
3 y- S' P$ k2 F- C3.组件装配人员
; H$ j# g0 V1 {$ X
4.部署人员

5.系统管理人员

6.工具供应商 提供开发组件所使用的工具（Jbuilder、eclipse）
! j; |7 R- y( I9 S! M) q% J3 j+ a
( }/ Y2 F$ v0 p6 i3 _0 L

java技术分布（设计架构 模块内部设计）
" \2 F& E2 E/ _4 J0 \1.表现层 Servlet、 Jsp、 JavaBean、 Taglib
; D5 f8 J0 t8 D; v& B5 j( _2 J$ w
$ Y  @; g7 B/ q- n( }, G1 R# ~- B2.逻辑层 EJB(SessionBean)

% y  ?# g1 Y" B4 U6 r3.数据层 （　JDBC 　EJB（EntityBean））
3 E  G( D+ z+ t" `: P" W+ H& f% q
. A+ A/ q* P4 }8 ~( M4.服务 JTA（JAVA事务架构） JTS（JAVA事务服务） JAAS（JAVA授权与验证服务）

5.分布式通讯 RMI（IIOP）+JNDI 、JAXP（JAVA 的 XML 架构）
0 {5 U/ C- A/ _" H4 P
JAVAMAIL（邮件服务）、JMS（消息服务）、IDLC、JCA（JAVA连接器框架 （成））
- d. p6 A! D) D


JEE的体系结构： 是一种组件的体系结构
5 G5 d) d* r; g7 G' W2 j6 z1.组件 ： 能够完成一定功能的封状体（独立的功能的集合）

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

( J! S6 x% H* q分为两类：web组件、ejb组件

2.容器 ： 提供组件的运行环境，并对组件进行管理（一段程序）
3 S) z/ f) _& y( H: I0 M
管理组件的生命周期
9 h9 W6 ~) J3 G: q9 O' S
不能单独运行，必须运行在服务器上
* x6 i. K) [: `0 Y( W
6 D, ?* P1 m" a9 A0 C- a3 z+ {程序（组件）通过上下文来调用容器（context）
  i8 }9 b! X* {
组件通过web.xml向容器描述自己，使容器能够认识组件

容器通过回调方法来调用组件
& d9 A4 H' l% Y5 n7 D$ u" ~
分为两类：web容器、ejb容器
9 ~% y3 N0 }7 E2 K$ C# u% E) ?8 d
3.服务器 ： 提供容器的运行环境，提供大量的JEE基础服务

web服务器（只提供web服务）

$ v) ?! `1 l; w. W' U2 x- xjee服务器（提供web、jee服务）
3 m" B+ w4 N0 u- B
7 M( J( x* {. Z/ O0 X. Y0 v; ^* R

什么是回调方法
4 Q7 y2 A7 b3 {' A6 a  G/ }由容器自动调用的方法，就叫回调方法。
6 @8 `* ]8 o0 W& Z+ v8 b- }
3 t$ l0 I1 P4 i) I# j

+ U3 u8 K4 }% PＲＭＩ远程方法的调用机制
( ?5 h( C0 Z! F" ?例如：Ａ主机有Ｂ（）方法，Ｃ主机有Ｄ（）方法，Ａ　想调用Ｃ主机的Ｄ方法
% P2 K) x5 |' ]0 q# P5 S; _
) u1 W. p+ d$ c9 ^( B


: Q' j, ~: A( T/ M0 y
3 e9 U- a/ t: m% |: }学习方法
" d, b! y  F' g( m" E1.规范（熟记） 2.熟悉API 3.多练 4.多想

admin

Servlet
+ D$ p+ N& u5 _' O) u) s

•     描述war包、jar包、ear包的结构
  
  8 P; l$ I, S1 Y
  

war-                            web文档压缩包

—WEB-INF

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

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

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

jar-                             java文件压缩包

—META-INF

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

" n' z' y) _8 d- I# y7 H

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

–META-INF

—Application.xml 配置文件

–*.war

–*.jar

- h; A7 J, O* S* t0 z4 `

• 什么是servlet？servlet主要做什么？
  ( U' X, E1 Z+ W' o6 B) D# ^
  ! \1 E  o/ \: L) X+ O& D7 d
  - [; [# N: X( [7 q0 I+ I  B

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

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

8 B4 l$ T1 l0 }: ~7 z+ e! [$ S

• servlet 与cgi相比的优点？servlet的缺点
  / N" U: \/ u. X+ f  T
  
  3 a- X' Z/ A2 ?1 O) m/ V) h

优点：

性能（线程比进程更快）

可伸缩

Java强健且面向对象

Java平台独立

缺点：

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

• 常用的servlet包的名称是？
  
  6 k& v0 W" C1 S
  ( l6 Z* O* f# h" a

javax.servlet

javax.servlet.http

' y" p/ d1 A- F( X. m

• 描述servlet接口的层次结构？
    \! \- d5 g$ s3 z: D! o" m: v
  
  

Servlet

–GenericServlet

–HttpServlet

–自己的servlet

ServletRequest

–HttpServletRequest

ServletResponse

–HttpServletResponse

• 对比get方法和post方法？
  
  ( ~, K) B( U* f& ]( u0 Z
  ) n& X$ ^0 i& f! L, |+ F4 |# V) l

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

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

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

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

• 归类描述HttpServletRequest接口都完成那些功能
  ( r! `1 o7 h2 w( ^2 \
  9 p9 C( |$ u: F9 O8 s
  
  • 读取HTTP头标
    
  • 读取cookie
    ' l$ D/ V# _% j: _! |( x9 D
  • 读取路径信息
    
  • 标识HTTP会话。
    
    

• 归类描述HttpServletResponse接口都完成那些功能
  
  - m2 @) p: k* ^* L0 [
  
  • 设置HTTP头标
    
  • 设置cookie
    8 E0 E# F+ a) ]/ _- |* ^7 Q
  • 设定响应的content类型
    
  • 输出返回数据
    2 u$ n3 `, G1 u) }8 I
    ' W6 f- o$ Q/ |' q& K0 S( h

: Q1 {: \  I+ D3 r8 R

• 描述service方法所完成的基本功能？默认是在那里实现的？
  : T" N) [# X) h# H2 o( v
  
  $ d; W9 A8 Z5 K

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

实现：默认在HttpServlet类中实现

• 如何开发自己的Servlet？描述应该做的步骤和每步需要完成的工作
  
  
  + }* K# m6 K" V  E4 W& o; r

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

' `1 _: |( _: [% |. M

• 为何servlet需要部署描述？
  
  
  5 J$ R7 A8 n: B5 B. T6 u

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

/ m; Q& U, G; v7 }9 x

• Servlet基本的描述应该是？请写出来
  
  ( }2 J+ Q5 K$ o* |7 v2 E
  

<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
  ! V7 _, I5 z$ f8 Q8 ]! O
  
  

FORM标记

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

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

语法：

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

{HTML form tags and other HTML content}

</FORM>

• 如何接受request中的参数
  
  String userName = request.getParameter(“userName”)方法
  ; s; g9 T/ d# T1 F
  

• 如何接受request中header的值
  ' A/ N/ E* X( a2 v
  4 s4 A2 k" [1 y- T: P; y
  

request.getHeader(name);

request.getIntHeader(name);

request.getDateHeader(name);

request.getHeaderNames();

• 如何输出html
  3 O. {9 g* ^# W% @
  
  3 u7 u  F! O! i$ U, z$ `9 q

PrintWriter pw = response.getWriter();

pw.write(“<html>”);

pw.write(“Hello”);

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

• 如何设置输出的contentType
  
  . d" f/ _) F# A7 X
  

response.setContentType(“text/html”)

• 描述servlet的生命周期？
  
  
  

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

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

• 描述init,service,destroy方法的功能和特点
  
  . Y" ?4 d* |, J6 G$ y0 k
  3 z; `' n/ h. h% Y

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

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

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

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

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

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

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

• 什么是回调方法？有什么特点？
  , g# G3 q. W; f( c! d
  
  

由容器来调用程序的方法

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

% T# m! V9 i4 G, O

• 如何设置初始化servlet的参数？
  
  在<servlet>中添加如下配置
  9 q2 {1 E  o- b! g0 _
  

<init-param>

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

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

</init-param>

6 e. a2 B0 o$ K$ G

• 如何获取servlet初始化的参数
  0 U# S8 P, I# R( f* g9 g
  8 K; k: I$ @  E9 P
  

public void init() {

greetingText = getInitParameter(“greetingText”);

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

}

+ A3 I8 G' T8 e) Z* f

• ServletConfig接口默认实在那里实现的
  ' S' b$ D" B4 T  k: Q9 a
  
  

GenericServlet类实现ServletConfig接口

• 什么是ServletContext？有什么作用？
  : D4 `! ^( N  r/ X. {. r5 n
  
  4 ?) V" R9 R3 \9 O* b* H

Servlet上下文

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

. Z0 k) m" ]! l

• 如何访问ServletContext接口？是在那里实现的？
  
  7 `2 P" @2 y! B4 {" p
  

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

GenericServlet类实现了ServletContext接口。

• ServletContext接口的功能包括？分别用代码示例
  ' `) c1 x. k% C6 @! ]) @
  
  " j8 A/ b  ?% V

只读初始化参数：     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的参数？
  : J* K& x4 u/ H& y9 B! O* B
  
  " a8 S. Z6 t6 T/ N; |

<context-param>

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

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

</context-param>

8 ~' ?" w  v+ [* }

• 如何获取ServletContext设置的参数值？
  
  $ Z5 y  r* [2 |5 Z6 m4 I
  

ServletContext context = this.getServletContext();

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

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

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

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

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

• 如何用代码实现监控Web应用的生命周期？
  
  
  ! y6 B3 p1 g+ n7 ~0 @
  

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>

$ a' t( Q$ A# F1 z$ d

• web应用中如下错误码示什么意思：400，401，404，500
  / p0 i0 O  u, S$ Q, Y
  , R8 h, O  @7 s& F0 ]; Q
  400 Bad Request//错误请求
  401 Unauthorized//未被认可
  404 Not Found//没有创建
  500 Internal Server Error//服务器内部错误
  
  

& g" k9 R* g. S+ g5 m

• 描述Web应用中用声明方式来进行错误处理的两种方法
  . m& }& Z4 f( ]& z/ {" z* P( S
  . S; }1 f8 T2 I3 m' G2 U0 v& @  s
  

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

<error-page>

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

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

</error-page>

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

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

<error-page>

<exception-type>

java.lang.ArithmeticException

</exception-type>

<location>/error/ExceptionPage</location>

</error-page>

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

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

• 描述记录异常日志的方法，都位于那些接口？
  
  ; A! b/ |! P0 z+ Y/ `
  

GenericServlet：

log(message:String)

log(message:String, Throwable:excp)

ServletContext：

log(message:String)

        log(message:String, excp:Throwable)

! O3 A0 S  a7 x$ X8 F# q3 n

• 什么是会话？
  
  2 @0 r) o- o; C
  

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

% P$ K9 B6 L# C; o# P  q  Z7 t$ P

• 如何获得会话？
  
  6 h( T' F( ]8 b% u
  HttpSession session = request.getSesseion( );
  
  1 l8 ~9 y* t; _0 x9 i# N: O8 c

9 i+ H6 t7 p" H4 U

• 会话Api的基本功能？
  0 [* {8 S$ u8 ^! u% l# _2 t& b
  4 p) q/ y5 `0 a' i8 f4 P" g
  

getID() :String

    isNew() :boolean
6 R# h3 h' k* W: Y

    getAttribute(name):Object
" ^9 y6 z6 t3 ?

    setAttribute(name,value)
  D, Z1 E% v( m3 r' g

    removeAttribute(name)

• 如何销毁会话？
  ! I* D  u7 }7 k
  2 x7 ]5 x# O5 Y
  

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

<session-config>

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

     </session-config>

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

invalidate()
& L$ G! i* g$ f

     getCreationTime() :long
- S2 D: B' q8 Z" A( z7 l; e

    getLastAccessedTime() :long

    getMaxInactiveInterval() :int
1 Z6 F, b6 g# b( B6 l* C

     setMaxInactiveInterval(int)

6 O" d( l5 p' w9 b9 q" d

• 描述会话保持状态的基本原理
    w' b8 k+ k8 M$ K, e5 z
  
  

0 ]# t7 F1 f% {, [) R1 X

    client server

1 X! O' f: h; v* e3 Q

request

response (sessionid)

request (cookies)
$ s3 _5 A# n+ e) V, u+ G

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

; a7 _& y% P, M9 T

• 请描述session和cookie的异同之处
  0 Y1 h+ T( l  u/ E5 a$ X% F- C+ i6 z
    \, B- _2 {) c# K6 f0 X. |
  ) ^2 R' s! Q& X3 d9 Q8 g

  Z' p. d& v3 q( Y6 N. M/ W

• 如何读写cookie，代码示例
  * j# c& C4 L: l: F) Y
  
    T: [" Z& s4 L0 f$ ^3 S

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

response.addCookie(c);

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

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

            String key =cookies.getName();

String value = cookies.getValue();

System.out.println(“cook”+i+“:key=”+key+“,value=”+value);

     }

• 什么是URL重写，如何实现，代码示例
  
  
  , Y3 B% C* {: W2 G

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

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

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

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

; u: N. i; y4 M+ [; U( o  l

• 描述web应用的4种认证技术
  
  5 ^6 P6 E, t' z! y2 J
  9 c) P7 Y0 i: [$ T0 p8 L6 z4 @

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

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

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

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

+ k9 [" j9 G# J1 u: r9 }

• 什么是授权，什么是验证？
  
  
  9 L1 I% h6 B+ _6 [

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

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

2 `* ~; g6 U" t) t0 P& i

• 什么是HTTPS
  
  
  ; e# p' S% m' W5 ^1 s

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

• 什么是审计？
  
  + \5 T! a2 m+ z. B; q- s# l
  & ~/ ~0 a' m/ {; L  U4 I

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

• 如何实现声明性授权
  
  , n# t3 B! x# p' G/ E! d
  4 p1 w4 ~# u9 }) ~* W" o) i1 O

1、标识web资源集

2、标识角色

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

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

在 web.xml里配

• 描述servlet并发问题？
  " Q8 v0 A, a% k+ b
    J- ], _4 c# `1 P* u5 k5 M
  5 x# s  M! H7 R2 g) u

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

• 描述Web应用中的六种属性范围
  
  
  

局部变量（页面范围）

实例变量

类变量

请求属性（请求范围）

会话属性（会话范围）

上下文属性（应用范围）

• 指出上述六种哪些是线程安全的
  
  
  " W8 {' j) r/ H* X8 d

局部变量和请求属性

# b$ I5 {$ a( f( s; {1 p0 Z2 m  w

• 什么是STM？如何实现？
  ( |0 |$ \) }2 k, S, w  X1 v4 f
    u$ R5 k, P/ U2 R  l
  

SingleThreadModel接口

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

• 如何实现并发管理？
  
  
  

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

使用synchronized语法控制并发

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

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

5 @- _; i5 \8 @

admin

Jsp
什么是Jsp?
Java Server Page    结合java和html在服务端动态生成web页面的技术
; F# {% e' {/ x2 N$ Q% T& b9 ?- G5 d
1 f2 U( n$ X' s: ^+ }; Y- V6 j

描述Jsp页面的运行过程？
第一步：
0 b1 i" C. T; e' J
5 D& w- A0 S( A9 e% [* _  V请求进入Web容器，将JSP页面翻译成Servlet代码

, V8 S, A& ^" ^第二步：

% R- d: R- {! R# X! f编译Servlet代码，并将编译过的类文件装入Web容器（JVM）环境

第三步：

- ]4 ?1 D$ j' N  EWeb容器为JSP页面创建一个Servlet类实例，并执行jspInit方法
* s: m8 \. M- k2 G$ y
3 I7 \  P, |0 G$ }8 B第四步：

4 {# X6 g9 g+ D% {6 b" uWeb容器为该JSP页面调用Servlet实例的_jspService方法；将结果发送给用户
* G8 l$ i: n0 F5 m, Y
5 `! ]: F) j; g7 P' _" ?
! u  I* u9 H+ e6 s
- Z+ {  ^' J7 T4 y  q, y9 W描述Jsp页面的五类脚本元素的功能、写法、并示例
/ o# `1 [6 y4 J- V0 I1 f/ K注释 <%– –%>

<HTML>

* W/ D# J6 }' q6 f) W" m<%– scripting element –%>
; H1 `  F* T% ]: t/ f
</HTML>
- p, d  i8 \# ^) O" i7 p& F
' y% s/ B9 L2 X0 F0 q# g% [# D指令标记 <%@ %> 指令标记影响JSP页面的翻译阶段
- X6 C  N- P) a. R1 E  q, G
9 w8 N6 O, s5 B' u2 x<%@ page session=”false” %>
- H5 w$ H3 `( q# e, `& w
声明标记 <%! %> 声明标记允许JSP页面开发人员包含类级声明
7 \6 E: a  q$ e, N/ n" q4 X4 c
<%! public static final String DEFAULT_NAME = “World”; %>
; f) |& Y3 w, B) a
    脚本标记 <% %> 脚本标记允许JSP页面开发人员在_jspService方法中包含任意的Java代码

    <% int i = 0; %>

  M9 \, k( i. I4 d2 L: [表达式标记 <%= %> 表达式标记封装Java运行时的表达式，其值被送至HTTP响应流 <B>Ten is <%= (2 * 5) %></B>


! P# C" V) e$ H* i
5 o: m. t9 d$ X; ?! z% P. |描述Jsp页面中的注释种类和写法
HTML注释
2 t- m" T' \5 G* M
& G. `! s3 d9 D9 b9 F& p. b<!– HTML注释显示在响应中 –>
' a& v+ Q3 h$ G" Y: e2 `6 T' ?
8 q- k7 {# m2 @& w" a5 nJSP页面注释
% [/ n$ {1 f7 O3 _( v& F
# b6 B1 q- g! @<%– JSP注释只在JSP代码中可见，不显示在servlet代码或响应中。–%>

3 r3 y; j0 |5 v: ]! V! {Java注释
5 |* a" R+ o( V' M, z2 W$ x$ Z
<%
: S8 E2 O! F0 V4 e* Z
/* Java注释显示在servlet代码中，不显示在响应中
4 b6 K. Q& w" c" y7 y
( e  B. y% z5 J6 O*/
' ?' |2 O- A. C% b' n) G
%>
7 v0 \8 s/ M7 t( e' i0 `: [( V

" r) w4 j+ ~% i  l
描述Jsp页面的指令标记的功能、写法、并示例
指令标记影响JSP页面的翻译阶段

! [: f- q7 z7 e8 P; r+ v* @<%@ page session=”false” %>
5 e% C% _% \9 y  C/ t
<%@ include file=”incl/copyright.html” %>
8 V3 X' v. U# u$ d- e5 d$ L
# b" H' V8 z: Z) S, |<%@ taglib %>
. `9 C: V2 c8 Y3 n# F( q, j( o

, t! M- r: U( a9 n# `5 B# S
% @% D. M% _, v: {& v描述Jsp页面的声明标记的功能、写法、并示例
; ^( F; ~; X" G, _# r! x声明标记允许JSP页面开发人员包含类级声明

写法：
' d% r9 z, F" Y4 G
<%! JavaClassDeclaration %>

1 \! i- s1 O/ c- h1 ?例：

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

# b$ n/ K8 \1 `8 K9 t: T3 r" ^<%! public String getName(HttpServletRequest request) {

9 I$ i* z9 \3 `5 Z% H0 L. Breturn request.getParameter(“name”);
  }+ s& _7 ~( x5 }7 D
: _" h* C5 q# a0 B% {* I- c}

/ `( q# L3 P% ~* y: D0 F%>

<%! int counter = 0; %>

0 n+ ~/ c( l( l, `
$ I+ R' F) c) H. i+ _
描述Jsp页面翻译成Servlet的规则
6 M: l2 x! [% _. rjsp中的注释标记被翻译成Servlet类中的注释
4 y4 ]' t) U& `6 K) J: u9 L
jsp中的指令标记被翻译成Servlet类中的import语句等

jsp中的声明标记被翻译成Servlet类中的属性
( N% t+ F5 v" H
2 Q4 J2 @$ z' \0 B- Jjsp中的脚本标记被转移到Servlet类中service方法中的代码
" z/ q" J' D  ]
2 a, t* {* i$ u" ~8 B. F% L9 zjsp中的表达式标记被翻译成Serlvet类中的write()或者print()方法括号中的代码

6 u; u" G# C2 x' e6 Z

描述Jsp页面的九个预定义变量的功能、用法、并示例
& B# }! Q7 y. [6 B) T6 z6 A: grequest 与请求相关的HttpServletRequest对象
7 [! M/ ~* \4 s) B1 r2 G
response 与送回浏览器的响应相关的HttpServletResponse对象
. d/ u; S- K- s3 W: I
out 与响应的输出流相关的JspWriter对象

: [- z$ V. @' ^& r' T* n$ G    session 与给定用户请求会话相关的HttpSession对象，该变量只在JSP页面参

与一个HTTP会话时有意义

    application 用于Web应用的ServletContext对象

config 与该JSP页面的servlet相关的ServletConfig对象
5 Y+ G# z9 u0 m- d+ q, t
pageContext 该对象封装了一个JSP页面请求的环境
1 x/ T6 h4 R3 K. U
page 该变量与Java编程语言中的this变量等价

+ q1 c0 B6 X# ]" ]5 d  A+ I    exception 由其它JSP页面抛出的Throwable对象，该变量只在”JSP错误页面”中可用

, N2 d) X% ~* R  L; d) ?" }& _
/ {. a+ J7 D) s9 f$ l, Z; c
; P, ~1 z, }$ Zpage指令的功能，写法、并示例，并描述它的如下属性的功能和用法：import、session、buffer、errorPage、isErrorPage、ContentType、pageEncoding
8 \: }7 `8 U7 K6 X( @import import 定义了一组servlet类定义必须导入的类和包，值是一个由

$ ~( K  z/ ^) M6 s' D! h1 u逗号分隔的完全类名或包的列表。

% i, w, Q% s2 v" K0 F7 L+ N. tsession session 定义JSP页面是否参与HTTP会话，值可以为true（缺省）
' E4 W, \. e  ]" E" S& a/ N
或false。

+ t) `; a0 W; `) e. c3 u: m7 I7 `  vbuffer buffer 定义用于输出流（JspWriter对象）的缓冲区大小，值可以为
/ W8 I6 }2 B: E! R6 f
none或Nkb，缺省为8KB或更大。

errorPage 用来指定由另一个jsp页面来处理所有该页面抛出的异常
0 Q6 D' M# \, v' {# n8 H
: a! ~& y. T2 T- t. U2 z: M7 iisErrorPage 定义JSP页面为其它JSP页面errorPage属性的目标，值为true或
/ s& q" |( g* j0 p5 B( H( G& W" b" r
false（缺省）。
; ~, G" W( ~8 R9 d: t4 N! s2 D9 `! x
$ n. Q* _* P; W& c6 `* \ContentType 定义输出流的MIME类型，缺省为text/html。
$ b) i+ S; g7 e# z
& i$ ]7 }1 G9 s6 Z; R+ r3 A3 G! hpageEncoding 定义输出流的字符编码，缺省为ISO-8859-1
9 T9 p% F5 p( }; @* Z' q1 ^+ `


描述MVC各部分的功能？MVC的优点？MVC的缺点？
MVC各部分的功能：

0 d  S5 C! e0 f. u8 i# v$ H$ ^Model（模型表示企业数据和业务逻辑）

% T: [& `/ T, k封装应用状态

响应状态查询
. D( q4 i- F# m4 v7 A0 f
暴露应用的功能
0 r$ o3 r" G- Q' S! k! T1 U" [4 A
' H5 s) C7 _9 v. I7 @2 `; N# ?Controller（控制器接受用户的输入并调用模型和视图去完成用户的需求）

4 R, |# @' ~) P3 ?* d9 ]* |验证HTTP请求的数据
( h9 ]+ k8 o# {  _  q, R4 J
. s/ ^' P; F1 l7 _' d" l将用户数据与模型的更新相映射

选择用于响应的视图
  B  W  o/ d* `: d+ c* G+ U
' O4 n. w  F6 K: hView（视图是用户看到并与之交互的界面）
9 B+ V1 M) T+ o. k7 O. j0 T- Q& [: M
4 w! P7 T) j6 R; u7 I+ ~5 G7 `产生HTML响应
' g# J' K. y+ a$ e. [
请求模型的更新

+ l( r9 R! f( u1 Y5 j提供HTML form用于用户请求

5 f$ u! y& X" k! B% M) PMVC的优点：
" ?/ ^) [/ E4 V- l6 ?0 A  s+ b" r
6 J' ?5 X% Q2 c8 ?! o6 ^        低耦合性：视图层和业务层分离
0 |8 }/ y4 L9 T; o
7 B) w$ T9 z. V2 s$ }8 H# W# d高重用性和可适用性

4 j! Z4 C; M  u' E- Q% [较低的生命周期成本

快速的部署
' Q/ M. ]" F) I
可维护性
1 Z2 f7 R2 O* _' t  B/ T
$ x" a+ p) D( |有利于软件工程化管理

: Z( d  ^1 g  }. q提高软件的健壮性

1 l# d. x- [0 v& aMVC的缺点：
; _' n  v& o0 n/ U" w( s. _6 q
- j& @; |8 S) h  K3 {& `8 a+ B        工作量大，增加工作的复杂性，MVC不适合小型甚至中等规模的应用程序
/ ~9 g0 b9 @  U  O: n. G
6 h2 @% E; ~1 H; {# k; P+ Q' N6 H
1 j' u8 H5 J# w0 h' ]( I
什么是Model 1结构，以及结构中各部分的功能
结构：jsp+javabean
% E( \8 H( [. R6 A7 x
. x! ]- ^% N+ TModel1中使用jsp来处理web应用中的视图控制部分

$ Z. P! r' [0 J" w9 cJavabean收集参数


( ?0 P% e8 \; k+ L0 p- S- D. o. m8 W
什么是JavaBean?
用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。
% E4 T. L( k/ Y0 S8 @  w
: H# A! m* K5 ~" t
' p- q7 V8 D; z- _
$ {/ |. `3 E. p7 _% Z5 a- {JavaBean的规则？
使用get和set方法定义属性
$ u5 e8 J  P! k! B- _
4 q0 Z' o& w- V7 Y" n一个无参构造方法

无public实例变量( 所有属性私有化)
- C! b! i/ z3 S/ W
' @6 r. }6 N! e# q7 N
* @7 S9 d+ {4 y: Y, F: i) J4 r8 o
什么是jsp标准动作？包含那些？分别都是什么功能？如何使用？
JSP页面中使用类似于XML的标记表示运行时的动作
7 T& e4 \; i' ]
jsp:useBean

jsp:setProperty

: K4 Z$ U. N% x( R( M, }8 ajsp:getProperty
! b9 ?5 M1 T: t5 K, b$ G
jsp:param

jsp:include
4 ?' f/ y. _, ~3 j5 O9 X! r9 b
' ~1 S/ o3 h" P7 _6 R. N: Njsp:forward
1 D' f8 v' }- A: z* B


用代码示例如下标准动作的使用：useBean、getProperty、setProperty
<jsp:useBean
, E, K1 U% \2 N' ~/ Z+ ]- f$ f+ n
+ V, A5 M; t5 A9 Tid=”myForms”
; c+ _; j5 H- f4 G- P
9 E/ s) w2 D1 d" Z6 j: Vclass=”com.base.mystruts.forms.MyActionForm” scope=”session” />
" P3 Z  c. \8 |* p
    <jsp:setProperty name=”myForms” property=”name” />

  W+ y& k; R7 |) b3 Y% D<jsp:getProperty name=”myForms” property=”id” />

7 v; Q) `* D; j7 {/ O. i

8 c  o) W6 r1 `) i4 X描述说明Bean的四种scope
2 }/ C( m' I& D- V) jpage
0 Z( Q* W2 l$ W
, u( M% I' d/ s( wrequest

. X$ o1 M5 Q+ \1 B9 [session
  X+ I( |5 ~7 ]& [
application

% s1 @3 n5 N1 {5 K# X
7 R: h; e. k3 r9 P; S8 D
, L5 e8 U2 U7 L& v' n; i1 [描述说明页面上的字段和Bean中属性的对应规则
9 l' I% ?% a6 H0 h+ I4 q# a5 u8 pid 指javabean的变量名

class指javabean类的全路径

; x0 d% F2 f8 ^5 k5 X/ hscope指javabean的应用范围

& ^' {# C. `+ Oname指所用到的javabean的变量名
9 F$ W) R8 {6 a% C4 }4 ]/ ?
    property指javabean中的属性


+ ^3 A) A4 M4 [3 v
7 W/ M9 E# _/ @% G描述useBean动作的处理过程
使用id声明变量
' U1 g5 S- H# Y1 A7 M' i
6 p/ }/ D- r2 R6 c+ P  R" j& G试图在指定的范围内查找对象

( `/ Z, U4 n, z/ P如果没找到
. P  L9 b4 ]) j5 e% W7 t
- _6 @% G" j' b# R# z; v创建一个类的实例
! R) M" p7 r/ ]8 ~
执行useBean标记体初始化对象
$ ]' @0 V  t6 C1 i6 y6 K
7 V) R) X2 a8 [1 T2 D) T4 v( k如果找到

, |- A+ c0 v& t! H, [( q# \8 D* }     将对象转换为类指定的类型

# v3 \9 ^: _) {' G- l9 d
2 n2 ~& Y! c/ G. r* w5 C
1 v. c/ m4 X6 B+ a& E描述forward动作的功能
, J7 _9 t6 g6 h. |* F5 R) G2 y使用脚本代码处理请求时，可用jsp:forward 动作产生一个不同的视图，
/ Y. B2 a  }& @# ?  {. l
使用同一个request：

  W, Q6 b+ m$ F5 H/ e' N1 g

. p/ w: j1 t. H5 D' {' r* a! U5 k什么是Model 2结构，以及结构中各部分的功能
jsp+model+servlet

! C' M. \3 l, H% K. }% d  {2 c1 @+ IModel 2架构使用MVC模式，JSP页面充当视图，Servlet充当控制器
1 y( L. ~* j: K# H) u
3 ~8 Y  `. b* C. y5 t3 [; gServlet控制器：

验证HTML form数据
9 R3 Q+ r& B6 N3 c8 M( O, t
2 U. f# `, C' X3 O% w调用模型中的业务服务
( G$ w9 ]. j0 n& z/ `8 Z8 f9 z
/ A: o& X+ J9 n3 R' ?存储请求（或会话）范围内的域对象

选择下一个用户的视图

JSP页面视图：
  [6 n- c. v: W& E, E- r  Z2 h
# y  N( ]% F9 a+ N6 |- m4 C使用用户界面（在HTML中）

! X( e' c! m. C/ D" h) w        访问域对象

# M( _: C$ I  K2 Z! P
9 l4 M. B( y4 a4 \
/ H, B9 q# p" r) J- T: J' [) r如何获得分发器？分发器的功能？
上下文对象中的分发器：
7 u; n( ?  s8 z  A
ServletContext context = this.getServletContext();

RequestDispatcher servlet = context.getNamedDispatcher(“MyServlet”);
* z1 C& Y" {# T2 ^' r4 R2 o2 B
# x# m/ k) x2 t8 T$ a% |servlet.forward(request, response);

  h: L) l. \9 o8 Q请求对象中的分发器：
# j, H. Z4 v  W* f1 M
3 k8 A- v! G9 g$ b0 ?" N# PRequestDispatcher view = request.getRequestDispatcher(“tools/nails.jsp”);
6 R7 g8 r  u0 i  T$ e0 i1 S  y- x
view.forward(request, response);

可以将请求转发到另一个jsp页面，并保持请求的传递性

, k7 S2 Y) b7 D# T* c
. v( t& w3 x0 J
Jsp中页面跳转的两种方式？
使用分发器跳转页面
8 g2 k3 N7 H6 x8 b3 l9 q( oRequestDispatcher dispatcher = request.getRequestDispatcher(“url”);
6 d) S4 r0 z# N' J8 n9 A7 T
dispatcher.forword(request);

7 l8 i. M& ~3 D! d% A; Y2 M9 ^# {    特点：保持请求的传递（上一次请求中的数据，在下一个请求中仍然可以得到）；

        转发的页面只能是同一个Web应用程序的其他Web组件

0 P& `( Z/ l: C; l7 f" d1 j使用重定向跳转页面
+ b6 E# ~- V2 W) O6 M% }! `6 u8 Gresponse.sendRedirect(“url”);
) O# U  {7 I2 l& I
    特点：产生全新的请求，（上一次请求中的数据，在下一个请求中不能得到）；

3 H' @4 N' B: o! b% e" S# k        重新定向的页面可以是任意的URL
- C5 @# A( F+ [
7 E7 P' Z" s0 d

描述Jsp中引入另外页面的两种方法，并比较两种方法的特点？
<%@ include file=””%> 在编译期间把另一个页面完全嵌入这个页面,可以说是一个页面
/ j9 y! M. C3 k9 y5 E' Q: o8 G
6 k& R" J) A. I" t在这里可以共享变量
6 k/ E# \) R* Z
( X5 P9 m2 D$ }& P" k0 J<jsp:include page=””> 动态的再运行期间把另一个页面加入这个页面,可以说是两个
0 s# n. f+ ]# m, l
' A$ _* v" s3 a' q. w页面，不可以共享变量
, K6 x- \. G3 n# H0 i* x
$ p  l1 P! |# F% q0 z

! P  S, O2 M% i7 n$ l/ r' N& v: B+ ~什么是自定义标记
, C: g' R, m  ~. ]7 U# H0 _! t, ^自定义标记库是一个Web组件，
4 r8 |. s+ x1 M9 W3 C9 |: K
包括：
9 X$ T5 C9 Q# V; R" T. N: p3 g
一个标记库描述符文件（*.tld）
4 @6 C% S! @; l& [' R
所有相关的标记处理器类(*.jar)
3 V* B/ O0 ^( z' B% j
% U" j1 c3 u, Y0 A2 h" o

描述使用自定义标记的步骤，以及每步详细的工作
) i% F6 t# n) ~& o; W: E( O使用自定义标记前，要拿到.tld和.jar两类文件

6 E: D% O( f& X1 e  l# x- t) _- n5 u把.jar文件放到WEB-INF的lib里面。
把.tld文件放到WEB-INF根目录下。
7 h) y; \! v/ y8 I( p8 V% o  P* J在web.xml中配置。
. B$ q7 c  F' }<taglib>
1 e' h4 C( T' L/ p$ w) I
<taglib-uri>http://java.sun.com/jsp/jstl/core</taglib-uri>
/ K8 P- p6 a3 |6 G( D& G
     <taglib-location>/WEB-INF/c.tld</taglib-location>
' l3 X6 s4 s" u
</taglib>

在页面中引用。
5 V/ R$ V1 A5 D; q3 K& p1 t* f4 i) m7 z<%@ taglib uri=“http://java.sun.com/jsp/jstl/core” prefix=“s”%>

" U2 s1 {8 H1 V9 k4 Uuri必须与web.xml中的uri对应

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

使用标记
格式：<prefix:tag名称 属性>
' [% U. _; L/ {. O- ]
6 D$ i. A2 e$ ]0 j; w/ q) `" z( \1 l<s:forEach >

admin

在tomcat下配置数据源
5 D5 z* T' f0 m; J. l; m4 u1、服务器与数据库的连接

配置server.xml文件

# [% {3 Q7 l- g( \% T) g! l1.oracle

) Q8 p" K4 Y+ D0 \; E" X& _, e<Resource name=”jdbc/company” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”
4 C8 G  e6 m  s
                        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”

url=”jdbcracle:thin127.0.0.1:1521rcl”
" o* G8 X! g$ X. R
* K8 q8 c4 b2 Y8 \$ NdriverClassName=”oracle.jdbc.driver.OracleDriver”

- O) I9 E* L* L+ g* susername=”aa”

/ {6 G; s/ ^6 Y4 F; mpassword=”aa”

maxActive=”50″
1 `( Y8 m* H6 y) {( S% x9 ^; N
maxIdle=”10″

& K. W8 F$ e2 a. |% I- Y2 nmaxWait=”-1″

% n  T3 K# |0 I/>
7 m* i7 w0 w: B
/ _6 P( b' G% s4 t/ c2.sqlserver
1 P4 n7 V1 P& m  D9 y) @0 `) a
6 S4 ?& X+ ]& ]9 o- ?6 w<Resource name=”jdbc/webpage” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”
7 q6 A. \& j3 ]2 A1 X' d- P4 a
3 b# X3 z2 _* k% e/ I        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”

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

# r' H/ W9 L: VDatabaseName=webpagetest”

8 Z4 t! g/ |5 P( i7 gdriverClassName=”net.sourceforge.jtds.jdbc.Driver”

username=”aa”

5 a1 K4 e9 g* I. |. Npassword=”aa”

. C8 H1 V- L& l/ i+ G2 h; rmaxActive=”50″

4 D4 g3 }5 P* q1 I) Y; b& x4 I- ImaxIdle=”10″
+ Q" Q1 x9 }# j$ @! k3 s1 Y
maxWait=”-1″
% Z$ R& t$ n5 P, `
/>
- l& A9 Z3 S- q
2、配置自己的web应用的xml文件
/ K7 ~+ z5 L2 D& c


; O7 c( p9 g4 O<Context path=”/eb03web” docBase=”F:/workweb/eb03web”
2 G0 I5 o2 Z% w* B4 V8 y
privileged=”true” antiResourceLocking=”false” antiJARLocking=”false”>
. R7 Z5 f! F; m+ }3 N" J
<ResourceLink global=”jdbc/company” name=”jdbc/company” type=”javax.sql.DataSource”/>
: J7 t" a) K; T3 d0 P
</Context>
" ?" J* N$ s9 _% {


3、配置web.xml文件
, }' E% h* L7 H* B+ B3 f2 v
与服务器建立连接
+ l, N  @2 p3 U7 `; e
0 ?( m  |: j% P# A, }. G<resource-ref>

<res-ref-name>jdbc/company</res-ref-name>
1 B; [: i" _/ z. o7 B
" M4 [; {9 l: j% O) e<res-type>javax.sql.DataSource</res-type>
  s6 ]' \( A# |" O
$ A- o( D4 h. Y<res-auth>Container</res-auth>

2 W4 J1 P3 J- P7 U: R</resource-ref>

$ P) c; Z9 ?9 H6 `+ n& s$ Z5 ~0 {4、在应用程序中不直接与数据库连接，通过DataSource连接池建立连接
  O! x9 q; g+ X8 p* l
//1.在程序单独用时设置系统的属性，在tomcat下可以不用配置，

System.setProperty(Context.PROVIDER_URL,””);

System.setProperty(Context.INITIAL_CONTEXT_FACTORY,””);

//2.创建一个上下文对象

' M5 j, l" t  m1 w$ HInitialContext context = new InitialContext();

//3.通过上下文对象在连接池中查找DataSource
+ \& `8 s( `% B6 D/ R
DataSource ds = (DataSource)context.lookUp(“java:comp/env/jdbc/company”);

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

% G2 i9 s0 ~# Y0 g" \ds.getConnection();

admin

ORM对象关系型数据库映射
9 p; ^' d, K) J6 ^(Object Relation Mapping)

一、映射的特点
* |# e, P3 Z( J+ V
% S% K. F/ s/ F3 v0 v/ P4 i1.一个对象可以对应多个表
, |) e3 {) f! h9 X4 f* \5 Z
2.一个表可以对应多个对象
' p7 u0 |5 _- L" Y
2 {2 k2 \0 W$ N$ i3.对象和表的关系不用完全对应
* M; {; B0 K; M+ I% O; D/ J
+ E/ Z: I+ O+ N% B( [3 d5 Z8 \4.对象的属性的名称和表字段的名称可以不同
8 s( N. R/ [/ F/ {
4 a/ E9 f; P" Q7 f: \$ y5.类型可以不同，但数据类型之间可以转换

1 U/ [7 P2 D& h/ B! K4 w4 G5 R/ P6.对象中必须有主键，数据库的表对主键无所谓

7.数据库中有主外键关系时，对象中可以有，也可以没有

9 }3 b1 l1 b, A, C( m
1 K& d! D  l' K4 `1 l
6 ?$ D3 A# R, Y: n二 、有一个映射的描述文件————>xml
' s! e* O, `8 u6 k4 [; D% u, n
三 、怎样实现描述文件————>一段程序

对象 映射（mapping） 数据库
- {. W8 W" u* z! X* h
, e+ H  X9 b' p+ M3 m( S7 guser

id=11
# ?1 Z: ]; A% ^' ?. h
& v& I3 ?/ O' g6 ~; g2 S4 Mname=”张三”———— > (1) —————> tbl_user(id,name,age,tel,address)
0 b7 a! [. F6 x) V9 a
' ~- n5 x( b& Y2 f# p" _4 p( `# lage=25 <————(2) <————
1 s$ u* O, G! j, {
1 }2 `1 t4 N# T  \
: z+ ^- ~8 T9 z! V
3 ]2 d/ k- l6 X2 y(1)从对象映射到数据库
, g7 f* {( V' X+ {' u
1.JDBC
9 M( r. _) k/ t, o. g
2 O7 \' |+ _# S: Y/ T! q& ~2.根据描述文件来动态拼接sql
: C! @% @8 N. o8 Y1 w
& l' \) U, O/ j/ O8 i$ W3.执行，添加到数据库中

& M' G# _" F1 o: w0 H4 o/ P# C

(2)从数据库中映射到对象
3 X( B0 T+ @' I5 ?& Y$ f" l
1.JDBC
- p, m( I' B+ _
" l3 G7 E5 I$ C5 t% B2.拼接查询sql

# P4 d1 U- @+ o. f& F3.ResultSet
& O: ^6 g/ k+ e- A. ^
* Q# }% n$ O" |4.Model
1 O1 E4 H" }0 ^0 }- i7 t* [9 j


hibernate
& H( _) G4 @% h- x开发流程：
) n. ~1 |3 x" B5 Z8 E7 h" z
是什么？
hibernate是一种基于orm 的轻量级的框架

* b/ V0 b! `" T3 l! L3 C

( m( b1 P' u2 A; M5 ^. N有什么？
2 t/ `8 M( T7 }8 K% ~  c0 r7 r1. session 保持连接状态（依赖事务和连接池）

4 j% g& Q1 L' D5 E) b) g2. Transaction事务

# m( [! J  O% ?9 d3.
Connection Provider 连接池
+ o5 O" z, F% O' @' T3 K0 ]! B
# K2 ^/ D" Y( m' H# p  O7 O
3 s* U) A" _+ H: W2 V$ x
$ M- B6 X9 j6 Z8 ]  {能干什么？
1.orm
4 J( p. E8 s2 Y, ~( y5 h* h2 F/ e
; l. p6 N6 M' }2.提供操作数据库的接口，简化数据持久化的编程任务
: m7 v& z7 e8 f( m! p0 v

8 S& F8 a& A3 Z
, W9 o' G! W6 c  f怎么做？
& S& w5 K8 {/ m/ M. ^1.搭建hibernate的运行环境，将hibernate的包和hibernate所需要的包拷贝到lib 文件夹下
9 m2 k* ]( X- z" ^
: s0 z: V& E. |9 J6 C4 U) P2.O（vo）

7 ?0 L# B9 V4 r4 _! ]: d0 Q& o3 c3.R （关系型数据库中的表）

/ \' ~3 y. C9 y: C* q- |4.配置文件
* j5 p1 B) q$ H0 H) {& {! y- U
4.1 cfg.xml 放在classes根目录下，默认名字为hibernate.cfg.xml
  q* E4 u' ]; ~2 _9 k' E
$ Y6 v4 t7 h, _+ Ca.与数据库的连接

0 x* [5 c$ @" F$ J5 l3 nb.可选配置
. c3 @( [' K! i0 E
c.映射资源的注册
  w) c- Y4 f+ Q, h0 C4 R  c
/ ~, y6 K& u2 h; K3 U4.2 hbm.xml文件 名字与类名相同 并且与类放在一起
% L( [8 y% F% p! b4 O% a8 T# M) q2 G; R
$ \2 A9 ]) E3 ba. 对象与数据库表之间的映射

, ~! l: e: p: U( N4 O0 O1 {b. 对象的属性与数据库表的字段之间的映射

c.组件之间的映射
) r0 `$ w( h; |
d.对象与对象之间的关系映射
: i( z6 a' c$ T$ R& }3 ?4 @5 }
5、客户端

1.得到SessionFactory

$ p* w6 K3 R3 F  X% R7 U$ M2.通过SessionFactory 工厂来创建Session实例

3.打开事务
0 |3 f9 E9 \" I- E% m1 [
  r9 k  Z- {4 g+ X( |4.操作数据库

& K1 X+ Z  f  _+ M5.事务提交
6 s) T) h1 h6 f
$ b. y0 f2 j- c, m6.关闭连接

运行流程：

整体流程
1.通过configuration来读cfg.xml文件

' M' C9 k0 W& f9 w/ d1 v; e2.得到SessionFactory 工厂（根据数据库的连接来创建sessionfactory）

3.通过SessionFactory 工厂来创建Session实例
5 _1 D! |, O6 [
" P% d/ \2 B; l0 E3 }" l, p& w" c- x4.打开事务
. t; J0 @& v. W# h7 k6 [; r% v
1 ~1 E+ U9 T* M* o5.通过session的api操作数据库
! @$ T% J7 m1 {# s
5 P7 E3 s; x- y" @8 N8 Q% L' [: ]# q$ k6.事务提交

7.关闭连接
1 H. X* P$ w' n4 b( [/ d! m
# J& B3 j8 L4 o/ c6 b) B0 t: B
, x5 I, j. _; {2 D; P  A# B& e- w
save
+ T# a8 n* {( N- U* ]" @8 N$ c1.to—>po
$ f! ~+ |8 _* R# J' D. [" R+ m
* I; S1 F2 B( M# M2.根据model和cfg.xml中映射文件的注册来找到hbm.xml文件
; }, F* |- y4 t# d& M! ]
3.根据hbm.xml文件和model来动态的拼sql

4.客户端提交或者刷新内存
4 p3 }, p/ {# F" q7 ~2 N( a
0 V, `( Z9 G& T% K1 E; f7 a9 \) E; Q5.执行sql，值放到数据库



update、delete
; X# `, e3 H( W# c1.根据model 的id在内存hibernate的缓存中查找该对象
3 a" F: a9 a# H/ P! H* I
( C8 |. o' p' g7 b如果内存中没有就到数据库中查找来保证对象的存在
3 t2 M; k4 c, {, e! j$ O& \9 x+ d" a( F
2.根据model和cfg.xml文件中映射文件的注册来找到hbm.xml文件

- V$ d5 u2 f: _1 @3.根据model和hbm.xml 文件来动态拼sql
1 N" X( \6 \- j" K. e2 Q* `
4.客户端提交或者刷新内存
. t7 q3 i5 r  t4 b3 S
* V0 ?) L# b# o% R5.执行sql
2 ]% G8 o0 e+ e: W  E6 a/ ?! T
4 o. t% a, W, O' Y5 g

Query
load
% M7 o4 t1 i0 T
1.根据model的类型来找到hbm.xml文件

  ^  y$ u6 ~, e8 {2.判断id对应的对象在缓存中是否存在，如果存在，就直接使用，如果不存在就进行下一步。

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

4.执行sql 查询（先在内存中查找，如果没有找到（会抛出例外），就去数据库中查找）
" e3 a8 J, K$ ]; T
5.返回一个model类型的对象

$ [5 X+ z6 U0 [' Aget

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

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

4 l* G( F3 o7 V3 Y& Y" Y9 B3.执行sql 直接在数据库中查找，如果没有查到就会返回null
2 A. U5 N8 I8 o2 N0 M
query
& k: \6 S9 E) H0 Q
4 o0 Q) {( l' ?# x7 o( V6 G& X, o: ~1.分析hql语句，得到model的类型

! Q* a- J5 D5 r4 H2 {! E2.根据moedel和cfg.xml文件中映射文件的注册找到hbm.xml文件

3.根据model和hbm.xml文件来动态拼sql
6 j/ `3 P9 w% i' j1 X7 u
& u0 a- v' v$ l, |' m+ l$ u8 @4.执行sql查询数据库

5.返回一个resultset
3 J. \, M$ C% D4 R
6.循环resultset的值，放到model中在放到集合（List）中


- C/ q/ y* y6 ?1 E* R
4 v7 Q& H4 ?: o谈谈hibernate缓存机制

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

' z" F& I5 _1 i3 X1 k) m4 i

  l2 I2 ?! F0 vhibernate使用的是二级缓存，有两个级别，分别是Session，SessionFactroy级别，一级缓存是Session级别的缓存，Hiberante来管理的，这个我们一般不用管，二级缓存是SessionFactory级别的，可以进行配置和更改，加载卸载，就是我们平时用的hibernate配置文件中的配置SessionFactory的属性。

( P+ F: }" d( C2 s; U
, [8 `" L$ O, T* z+ ?# v! }0 W6 K
对一级缓存中的session事务进行数据的预存取，数据在各个session的上下文中存在（单例），当session关闭时，就是session.close( )，整个所有session范围内的数据全部清空；二级缓存默认的情况下是不开启的，如果开启，数据库汇总的所有数据都先copy到二级缓存中，这里要注意的是，一级缓存是每个线程下创建的session缓存区域，可以是多个，二级缓存只有一个区域 ，画个图比较容易理解。



| 一级session缓存| | 一级session缓存| |一级session缓存| |一级session缓存|

| | | |

| | | |
7 |5 n9 F/ K, r6 f
—————————————————————————————————
. Y+ U# {7 `7 I4 A4 c! a1 K( p$ R
$ u$ T4 O; h4 n1 @4 y/ msessionFactroy级别的二级缓存
5 h+ N% q9 m7 _2 R5 D% ]1 H! ]
——————————————————————————————————————-

! q6 Z# l3 q( c3 i3 C/ K* c* ~7 B|
# I( l5 c" f  L8 Y2 w: ^
. Q' r: W' w; Z9 T|
* Q% y* P6 O: ]) Q
7 `' p' e7 T! K, [3 Q+ p|

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

DB

" k/ ]: q+ U& z% B—————————————————————————————————————–

admin

Spring

• 是什么？
  
  . N. p% o9 H1 K, i

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

; n/ L- G8 H" Q6 t

• 有什么？
  3 l# O6 K# }. R( `2 t* x8 Y: p6 V
  ' o  l! r2 D/ k

4 ]1 k! p* P7 a, a3 f% K

每个包的功能：

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

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

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

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

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

AOP ：面向切面编成

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

/ h' R9 o8 n9 Y7 V8 M

• 能干什么？
  
  

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

' j  o' [1 ]+ ~

• 怎么用？
  
  
  • 搭建web工程，引入spring的jar包
    
  • 在web.xml中添加如下配置
    
    
  
  
  9 G5 @; o) Q1 O" F5 B8 V: B: }

            contextConfigLocation
1 `, P: ^6 d9 e! C0 n; E6 V; F

            classpath*:applicationContext*.xml
1 L) S7 E$ _! k/ U

   

        

            struts2

            

                org.apache.struts2.dispatcher.FilterDispatcher

            
2 W7 C5 g- b' r( U- x

        
; i0 h3 T: ^- u9 s; [( e

        

            struts2
4 {3 [+ q4 }% j( p/ f2 I

            /*

            

                org.springframework.web.context.ContextLoaderListener
' T9 ~3 N" v! \& }

            

        

• 部署
  $ ^5 @( V+ J" M7 ~$ T7 E; d" _9 C
  

( D* y6 x0 n% n- |; U+ Q
% M! j& b, H5 r- C. c: B5 R

• 容器和bean
  " F* t# ?. z5 ^

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

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

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

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

• IOC控制反转
  
  
  
  ) h+ l+ V* \0 ]2 j7 c
  ! D( u7 m8 q- ?
  从前的应用程序想要得到A的实例他会直接主动的去拿，当用了sping后，应用程序由主动的去取变成被动的等待，由spring来控制应用程序所需要的对象
  
  
  • IOC的优点
    
  1.可以通过IOC来获得实例
  2.可以通过DI来获取注入的资源
  • 配置IOC的原则
    
    • 一定是可变的资源才采用依赖注入
    • 一定是层间的接口或者是模块之间的相互调用才采用依赖注入
      

• DI依赖注入
  3 v5 l8 }/ _- M, X

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

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

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

例如：

在配置文件中

. _. t7 M+ E: ?4 [

在应用程序中

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

3 ]+ e$ \( w& b, L

• Aop面向切面编程
  
  

1.AOP面向切面编程 一些较好的模式或者是示例—-范式
" g' x! i  n/ U: B

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

2.AOP的思想： 主动—->被动（追加功能）
/ b7 }' `5 \4 a  k* L

3.AOP 的概念

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

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

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

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

5.引入 ：扩展的功能

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

7.aop代理 ：实现机制

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

4.AOP的事件机制

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

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

3.找到切入点

4.确定连接点

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

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

; e* i" ]9 E$ y& r1 s/ i, q


% r) m3 c: r9 g0 f5 _9 k
0 u  R5 d; _6 u' `8 [  Y( w! ~

5. AspectJ

5.1.在xml中配置比较烦琐

所有的入口必须从一个代理（ProxyFactoryBean）开始
! o$ I& y( `! y( F/ I/ B

5 T) N: C. i7 g! M: [  t* H5 I3 K2 t

         

. ]& v% q* X) e9 k
         
8 d! d' r' [$ ]

        

        

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

        
+ V5 a* a1 X) }8 f4 l

        

   

6 R' E4 Q0 [- ?, l" Y3 d$ [$ q1 S
3 L  z- |9 n. k1 s

5.3.使用注解的方法相对简单
3 `4 r* Y( I" g5 A: l

@AspectJ的基本语法
: c# `3 L0 T+ t3 i

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

直接在类上定义@Aspect
$ ]/ B) `/ }& _3 W; W0 }

2.@Pointcut声明切入点
: }9 f' h, u% W1 g& p$ }+ s

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

2.2、可以使用匿名的pointcut

2.3、执行切点的几种方法

2.3.1 execute（public * 包结构.*.*.（..）） 可以指定到具体的方法
! c8 f3 K5 R: ?) w/ D5 |

2.3.2 within 指定到包，不能指定到类
3 d. F3 L5 a3 y0 X

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

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

2.3.4 target 指定具体的实现类
9 _) N% E, D+ n( j8 S) A# r

5.4.advice的五种类型的示例
' e! ]4 H( w( O( @- ?( G

　　　 客户端必须从接口走才能得到监控，实现想要追加的功能
. `- z$ O1 v) q6 d4 L: k( \

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

追加的方法的参数名字一定要与retrning的名字相同
- \6 h) o: _8 {, s! ]$ S5 M( g7 ~2 b

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

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

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

完成追加的功能
$ p& Q7 Q* S! }+ o' S3 D- ~

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
, Z( _) \( h& [2 R4 [; ^3 z

(1).@AfterReturning(“com.javakc.spring.schemaaop.TestPointcut.t4()”)
# u& s2 w6 P  A5 M4 I8 Z& m4 {# x  i4 m

(2).

     2.直接引用匿名的pointcut

     (1).@AfterReturning(“execution(

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

     (2).@AfterReturning(pointcut=

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

args(str)”, returning=”retVal”)
! [" W; |/ \! T) ~

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

public void testAfterReturning(String str,Object retVal){

    System.out.println(“afterReturning1=>”+retVal+”=>”+str);
: \0 c, \; v- u% u, P1 a

    }
% }# \6 Z4 N  u( }/ `

5.4.2.@Aronud
! R& [8 T) n- `2 g

     注解@Around环绕追加功能；

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

     必须有参数；第一个参数的类型必须为ProceedingJoinPoint；
! A" H$ q8 y0 |) z  {" h

     通过ProceedingJoinPoint的实例的proceed来调用所监控的
: z0 C5 x2 m& N) f1 C4 e

目标对象的方法
! V9 E3 S# m, b

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

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

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

&& args(str)”)
! |0 Y) D0 _; @0 @& g7 _  R

2.直接引用匿名的pointcut

     (1).@Around(“execution(
/ R7 z  f$ \' n) Z/ B

* com.javakc.spring.schemaaop.Api.test1())”)
+ I$ P* T) L- O0 t6 I

     (2).@Around(“execution(
' P3 [1 Q; a7 B6 V' C4 P* ~

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

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

     @Around(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
! U8 Y* o2 A+ p7 f# T1 h  q2 M/ X! o

public void testAround(ProceedingJoinPoint prj,String str) throws Throwable{
6 G* i  ~  M7 k- o4 T( q/ t6 J  x

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

        Object obj = prj.proceed();
5 T' Y2 l+ M- v; \( W& q

        System.out.println(“around1==========after1pointcut==>”+str);
5 N  ]/ `% S6 ]( h

    }

5.4.3.@Before

注解@Before在执行目标对象的方法前追加相应的功能
5 ?6 f% J% a5 e+ x) C0 f

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

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

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

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

2.直接引用匿名的pointcut
3 ]* A6 g* m- q5 J/ J

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

(2).@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
$ F( c# E# y! Q! X5 [7 n

注意args后的名称与参数名相同
# T1 S/ K- G  `% a! O2 h2 k6 e) J6 C( E

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

@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
0 k, B6 `& S, S* Y& V

public void testBeforeParam(String str){
6 C  ]0 J/ \: j9 ^

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

}
8 {/ ]+ J9 Q0 O

5.4.4.@After
. B0 i+ X  z- C; {5 I2 F6 G. _

注解@After在执行目标对象的方法后追加相应的功能
& _: B0 s$ D3 U

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
; _3 L( @  C3 V+ N7 j

     (1).@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
& v9 i0 x8 @7 }( r6 Q

     2.直接引用匿名的pointcut

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

@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
- n0 Q# S& N0 `% t

    public void testAfter(){

    System.out.println(“after1== >pointcut”);
* e# q+ H/ n; \7 b9 N

    }
: V" L% Y. d" V, Z) G

5.4.5.@AfterThorwing

- l+ @* y, s3 U# I0 [
! M' s5 U3 {: ?2 I6 o9 T, b

• 描述一下spring中BeanFactory和ApplicationContext的差别
  
  9 o/ r+ H% ]% g# f, |3 @" O8 b

BeanFactory是一个Interface,这是Spring的核心。它仅仅只是提供的一些基本功能。ApplicaionContext 也是一个interface,这是从BeanFactory继承过来的所以它具备了BeanFactory的所有功能。但它也从其它的类或interface得到了一些特性。比如提供国际化的消息访问，资源访问，事件传播。

但其主要区别在于BeanFactory是延迟加载,如果Bean的某一个属性没有注入，BeanFactory加载后，直至第一次使用getBean方法调用此Bean时才会抛出异常；而ApplicationContext则在初始化自身时检验，这样有利于检查所依赖属性是否注入；所以通常情况下我们选择使用ApplicationContext.

代码示例：

BeanFactory beanFactory = new XmlBeanFactory(new FileSystemResource(“beans.xml”));

ApplicationContext cxt = new ClassPathXmlApplicationContext(“beans.xml”);

• 谈谈spring对DAO的支持
  ) {+ X) O0 p0 S7 B. V5 b
  # [* y& |6 F8 ^2 f$ a% e  d+ L. E

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

简化 DAO 组件的开发。
Spring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法，用来简化代码开发。
0 Q. y9 m! P& h, [

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

面向接口编程及 DAO 模式的使用，提高了系统组件之间的解耦，降低了系统重构的成本。
# {1 O- {% o& A3 s

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

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

' ^+ S+ G# R4 I, X% S0 e3 f
3 K6 m* O* @: {6 J, W

• 谈谈spring对hibernate的支持
  " r( `' x- E5 M- c
  

在所有的 ORM 框架中， Sping 对 Hibernate 的支持最好。如 SessionFactory 的注入、HibernateTemplate 的简化操作及 DAO 支持等。另外， Spring 还提供了统一的异常体系及声明式事务管理等。
! d; ~, x( {% g) m7 k; `  A7 @% _+ `

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

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

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

        

            oracle.jdbc.driver.OracleDriver
' S0 A# E1 z6 p: V0 p/ W

        

        

            jdbcracle:thinlocalhost:1521rcl
0 m* L# O- V2 }

        
. W1 G' P8 Y$ Q0 T+ F8 X

        

            javakc2
7 {/ w" Y( y- B. b

        
  i0 y) r% c* g, k4 L# m) S! M

        
2 D$ G1 t5 J) k* {4 V- x" V

            javakc2

        
0 e1 p1 p% e, i. k8 a; n

   

' e8 J1 R' w* E  S# w, ?/ A

   

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

        
4 U9 q9 [* }' Z4 G

        
; P$ N" V) A4 F) P

            

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

            

        

        

            
0 p8 i# g; o& D) S3 U* k

                hibernate.dialect=org.hibernate.dialect.OracleDialect
( U5 T) I1 o3 ]5 j4 t

            
( R5 ~: C1 K/ U' \: J8 {

        

   

   
4 T' l* f) c3 B) X

        
- a. G: w' k" L

   
9 n( P' A: S- N: x+ j8 q5 @

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

   

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

        

            java:comp/env/jdbc/myds

        

   

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

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

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

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

   

        
8 Y+ \2 {7 d% r; D- q) b

   
6 U3 q4 _4 e2 R

1 q, Z9 u7 x+ E) K( @

   

        

            

        

   

   

        
1 z  c0 w1 L( ^4 J" k9 |1 C

        

   

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

Spring2.0之前事务的写法 7 [; s$ T4 s! ?9 I* d 7 m0 P0 ]4 c8 e  A! r * |. \  U: C! |3 ^1 M        class=”org.springframework.transaction.interceptor.TransactionProxyFactoryBean”         abstract=”true”> . Z) Z/ W/ Z- k  P  k/ ~" l 2 D" a2 |  w! D8 N9 E  @ . B' V1 Q5 N9 `! d4 w                PROPAGATION_REQUIRED,readOnly                 PROPAGATION_REQUIRED 8 _' B% c* J; v- |2 ]9 B- x% y

• 谈谈Spring对事务的支持
  
  

1、声明式事务管理：

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

2.做法：

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

2.2

2.3 注入数据源

( F! K7 t  r' I* y

& s% `* _. K; W& j0 z

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

. Y9 ]2 t# Y. L. m+ u9 }

2 ~! W" M* @2 T. Z+ x6 ]9 \4 h

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

+ f9 O2 z; ?+ l8 M; C

2.6 定义切入点

, n' e, F2 O0 w, [6 i' ~- D

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

1.注解@Transcational

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

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

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

1 n9 o! f" E1 b( a
) e0 k5 v5 F1 y4 n1 B% p/ T% U

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

9 k5 Q# `# p- R# N* t, U3 r  i5 o

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

admin

事务
ACID
5 B/ G7 {" D+ }; ^  s; @! Y（1）原子性（A）：一系列的操作具有不可分割性，要么成功，要么失败
/ Y4 t# j* n( h' F, {9 X, _
( T0 T* `" B3 W3 d, w+ P" b（2）一致性 ：操作的前后满足同样的规则，保持平衡。

# H" [& X' m9 s. N! |, i（3）隔离性 ：在事务运行的过程中。事务内的数据对外的可见性和可操作性（必需由数据库的支持）
3 [8 K2 ]/ ?* h7 r; \: J
& n2 N' |% A) r0 S. n7 s2 k' q（4）稳定性 ：保证数据在事务的操作的过程中不会遭到破坏，而且是永久性存储的

" z  Z, o  d# g  P* o
# O  w; `- u( J: S/ U# L- v
( q7 P9 S. C9 n! U事务模型
, W$ m. Z: v$ E& @$ k% E5 ^1 O* E（1）经典事务模型又叫平面事务模型（JDBC） 事务不允许嵌套
2 N' t0 }; w- _: X& s
; S. X; M2 k- Z; ^+ _+ W8 d* ]( I3 y（2）嵌套事务模型
: r+ M3 _! B$ M! G/ o


事务的两种方式
/ o2 E+ F5 ]: w（1）声明式
3 A& O$ W- P! m' J2 a/ U. _4 o
在配置文件中设置以下6项

（１）.required

3 j# c) M% c% J" ]4 e+ R% J如果客户端没有事务　在bean中新起一个事务
/ u2 o6 C. i" _% O2 G3 r& D# P; T
4 ]; F  Z8 T+ p" \1 }% ~  u2 I/ e+ v如果客户端有事务bean 中就加进去
1 b2 H& G! k9 Q5 A  T; _
$ N3 c; o$ ^1 W- @(2)、 requiresNew

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

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

(3)、supports

" G( W2 M* s  |& n, S9 v. q( l. R如果客户端没有事务服务端也没有事务
* u0 X. M6 j, F$ t/ Y2 S, b, s! V
' Q9 u. f  ]! t  `- W9 e如果客户端有事务服务端就加一个事务

(4)、mandatcry

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

. S: g# a! k+ C. i; q如果客户端有事务服务端就加事务
$ {4 v5 _' K9 R$ ?5 S
+ c3 ?; c# I3 U7 F) |(5)、notSupported
& v$ q( }' g  y2 f; c2 Z! I8 y
( S+ X2 T1 a2 Y9 i4 |( Z不管客户端有没有事务服务端都没有事务

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

(6)、never
$ z& ]% Y) D) K: {9 B5 c6 n
2 a# [; E5 F8 \8 H0 j. V不管客户端有没有事务服务端都没有事务
6 V& M% n5 i5 ]* K/ P" s
如果客户端有事务就报错

（2）编程式事务

Javax.transaction.UserTranscation

+ h, N- U0 _  k2 E6 @1 s' aJTA 事务可以精确到事务的开始和结束
; Y4 |& L: M9 ?9 W


事务的隔离性
Read-uncommited
8 {- ^4 D" S5 w- N: g+ k
! e( l( X8 K$ E9 K读取未提交的数据（基本上没有锁）脏读，存在不当读取的问题。

+ G% S2 ^! d& l+ z) }: s* H/ aRead-commited

' x8 U0 a$ V8 Y; n读取已提交的数据（行级锁）

+ ^$ W, t: U% j$ b" V无法读取已经写入，但没有被提交的数据。

Repeatable_read

读取的数据不允许修改或删除
- Y- s9 _* J- m+ S
不可重复读（行级锁+不允许修改/删除）

5 [1 o" v9 `* b( T$ \' SSerializable

. H8 Q0 w8 V) K$ \幻影读（表级锁）


+ T0 e) F) N, V& V. l7 O4 [
struts
+ \3 g; c7 e6 H开发流程

1、创建表单
$ N) q, H8 a3 f: I3 @7 n) D; P/ `- D
# ?  P+ C! g2 u; s2、从表单中获得输入
; n6 O# \% a5 m1 x2 l+ Z
, S  x& `0 ]  x3 b& V3、处理输入（业务逻辑）
/ p2 }% i, O7 D+ z2 Q3 U
4、根据动态输入改变输入流
; Z/ ^- ?' ~& i) F! B  y3 T  g! @. d
; h' |: T: a' Y, A# ^, f0 a. n; {1 ]要完成上述四步，我们需要创建
" w+ k# ]# M) \, W6 h/ F
- s0 S  z8 D! }% q$ B% Y" ]  F1、一个ActionForm

% m7 J8 h5 S4 R2 i2、一个action

  t) h8 P0 A% @' n& g- A( c" Y3、一个配置文件struts-config.xml
! _( y5 f( X4 e) }' c0 `' P1 k  }
4、创建页面

创建ActionForm

1、写一个类继承ActionForm

& B2 i; o4 L9 m0 E6 Q3 |8 r4 Z( q  b2、私有的属性
* S8 K# m, B% j1 t6 w3 w' k4 G: y
3、相应的get、set方法

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

+ W" E( [, K1 S7 n1 Y8 O% B8 W3 e创建action
3 s# E( i9 x# {# c! q# e( L+ P
- \- y" N- F$ r! T) y4 X1、写一个类继承Action

4 ?$ o$ A2 G% _1 B2、实现一个公有的方法（回调方法）

public ActionForward execute(ActionMapping mapping,

2 c' M2 U+ l+ x" I8 x' U: E, L/ A) iActionForm form,
$ q$ H: D6 `: [# X& M' }
HttpServletRequest request,

HttpServletResponse response)

/ z9 r, [1 H7 T( }5 f{
8 _) {' M: ^; i
//1.收集参数

MyActionForm myForm = (MyActionForm)form;
: [! o0 X1 m. C+ _( w: x
//2.组织参数



//3.调用逻辑层
0 E- D) P# G' p) Z. i
boolean flag = true;
$ o0 p% X# a/ Q" z/ J
. L6 e0 w# W" V3 k+ s//4.根据返回值来跳转到相应的页面

+ `2 q, Q8 F+ R# C' F" L. c/ n. iActionForward af = new ActionForward();

0 S/ d  q8 {9 Uif(flag){

af = mapping.findForward(“1″);

}else{

* R7 L: e" C" c  d! [af = mapping.findForward(“2″);
  a# s, Y: {' I4 K
* Q% A3 d! j* t}

0 y+ v3 c7 i+ |, ^: Jreturn af;

0 D- S+ C- x# U- Y2 H}
8 f6 u, `, i5 q5 ^% M
% b% D* j7 b3 S! h4 y配置struts-config.xml文件
4 n9 r2 l, Y$ o* s7 J
- Z3 \. W0 {6 p4 j2 b1.<form-beans>

<form-bean name=”myActionForm” type=”全路径.MyActionForm”/>

9 J2 G3 z2 ]' ]& z& Z+ ~5 _<form-bean />

</form-beans>
, a  Z( }. Q" x4 @' t
2.<action-mappings>

<action path=”/sll”

name=”myActionForm”

type=”全路径.MyAction”

scope=”session”
& ]! {+ d& b* s* t
input=”错误返回的页面”>
% r) h! n' m2 A8 i
5 S6 `, Q# b) e7 k. x: l<forward name=”1″ path=”/1.jsp”>
+ F9 R$ J1 c* a0 y
<forward name=”2″ path=”/2.jsp”>
. v( O0 _/ B7 p" u
</action>
1 p6 P" t! b7 Z  T8 O
</action-mappings>
* Q) u2 a1 \- C# l" _( ?1 w7 X/ f
; r0 W9 N* f! _7 x, b! E  f步骤:

! o+ E3 C  t9 G$ k5 n1.创建一个空的web应用

2.将struts的包放到lib文件夹下
) K4 P" }9 [3 e1 S- i: b
. |1 A$ K8 {% h( J/ [6 n. y  v3.将.tld文件文件和struts-config.xml、web.xml放到WEB-INF的跟目录下

( l2 Q0 ?% [' y. Q6 @. S6 p4.配置struts-config.xml文件和web.xml文件
6 y* g' c! Q- c
5.在页面引入tag文件uri
$ z& n+ c/ S2 i# l
STRUTS运行机制

1、界面点击产生请求

/ p8 t( ]& B2 n* a, {9 K0 E6 c2、容器接到请求

3、匹配web.xml文件中的*.do来调用ActionServlet

% K) `4 S+ P8 e) T( N4、ActionServlet的处理
0 R6 K- ]  h- s! X3 r* H0 u8 ~4 s; g
& r, `* I: [7 A$ D! u4.1 读struts-congfig.xml文件形成ActionMapping

* e9 V; i  D/ l4.2 通过path 来匹配Action类，通过Action的name属性来匹配ActionForm类

4 c& k; P8 s- J3 y4.3 通过反射机制来给Form添数据
% p2 |: M; x9 ^: i" ~
+ r4 h: }+ O% p6 S3 {' x4.4 由ActionServlet转调Action的execute方法
2 s9 g5 R5 a0 G9 d$ }
4.5 得到execute方法的返回值，跳转页面

$ }: d% q! o  a* k2 \4.5.1 RequestDispatcher
5 X3 X7 R9 S; Q1 {; ~7 M
9 X0 v6 `( Y/ G7 s' {4.5.2 response.sendRedirect(“list.jsp”);



, T5 r/ c  p4 h& E2 `进入execute方法

  B6 n( {  J1 O% ~/ n. W1 Q% ]1 收集参数
. _8 k; ~9 _! D
2 组织参数

! }& S( r. f; H, S* [7 e1 D+ S3 调用，逻辑层

& _1 M( G- `) M6 I4 返回值

- G0 ]4 G  g# @9 ?+ l3 M- c1 l: Z  a4.1 选择下一个页面 （ActionForward）
" T5 V8 t3 Z+ }; U/ X3 K, q
" j1 D. L$ L* z, F& Q6 D/ I4.2 把值传给下一个页面
8 t6 g# ~( u: [9 [' O0 `8 P6 ~

- I: c0 M; a2 Y% z
比较struts和struts2的不同
+ I* `8 J( s2 K; ]: A8 u
- y, D$ C4 m' u+ R" Z+ B" C& HStruts

; P3 f" ?0 e& N. @5 c& kStruts2
6 d1 y6 d' q; r5 e9 ?% {8 ?
组成        五个部分：ActionServlet，ActionMapping，AtcionForward，ActionForm，Action        十个部分：AcionContext，FilterDispatcher，ActionMapper，ActionProxy，Configuration Manager，Action Invocation，Interceptot，Action，Result，Taglib
url        .do        .action
. N2 V& x8 x7 h7 u7 e7 l分发控制        AtcionServlet        FilterDispatcher
收集参数        利用JavaBean技术，将数据封装到ActionForm的子类中；
/ T4 M5 |9 |: N, b/ @; d0 c一个Action对应一个ActionForm的子类

使用拦截器将数据封装到值栈中。
0 ?) l* Z  N2 K0 n! \使用域模型，一个Action对应多个值栈中的Model

6 o& e  C0 @  ^7 h读取配置文件        ActionMapping        Configuration Manager
. z1 U+ J( U; K/ ^; T6 |( J拦截器        无拦截器        执行Action前后有拦截器
返回页面        将字符串封装到AtcionForward，进行跳转页面        Action中直接返回字符串，通过Result跳转页面
" f$ ^$ V  x. _页面跳转方式        两种：dispatch，redirect        三种：dispatch，redirect，chain
7 V6 N$ n9 X2 z, m) z值栈        无值栈，Action通过在request范围内设置属性，向jsp页面传递数据        有值栈，Action和jsp页面通过值栈传递数据，jsp页面通过OGNL取得值栈中的数据
9 L. t/ Z% M0 I8 u: S# W配置文件        struts-config.xml        struts.xml
& o' i/ b3 P  ?; \中文问题        不能解决（需要使用filter）        可以解决中文问题：
- U+ B0 g$ @6 R1、在jsp页面添加Meta；
* C+ ]  ~2 h+ P3 _* g
/ Q1 Y9 J, O/ O$ ~2、修改struts.properties中的设置。

admin

其他开发工具和技术
. _9 V" W" T3 K" m9 p( y1 HAnt
Ant是基于java的批处理工具
; ]4 g- x$ k- ]
: N# ?+ ^+ m2 Y2 S# |# ~2 e一、配置ant的运行环境

2 J, W0 ], }% o  U4 g# C1.将ant的bin目录添加到path中

2.配置JAVA_HOME
$ [7 u, |( a9 }$ z5 n; O, l
3.配置ANT_HOME
2 n/ v) @6 M3 n' R& r& N1 ]
* b. Z& r( l' ?- c二、配制build.xml文件，该文件放在应用程序的根目录下

编译java文件

执行java文件
' b2 [3 @) |( s& z
* j2 E% q5 s  A* ]9 scopy

删除

打jar包
1 J6 `* J5 K# [, d5 A' V; m( _! ]
! h9 I) B# r1 }! Z7 U( k根据注解生成配置文件
7 w9 O2 b; w) X$ D  T9 M1 v
Xdoclet
通过注释生成一系列文件的工具（txt、xml、java、html等）

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

7 n+ r, q+ ?; d1.在java文件中写符合要求的注释（将hbm.xml文件的内容搬到java文件中去写）

1.1 在类的上面 写与表的对应
' M7 I# h) p6 O; C
( T9 F# ?3 a/ c1.2 将每一个属性的注释都写到get方法的上面

/ r7 G" Z+ e9 ]2 f+ q7 Z" U$ L2.在ant中引入相应的task来驱动xdoclet



, ^! }* S" n/ E: Y: d# `( ?log4j日志管理
1、是什么？

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

# ?% E( q. g  N% q* l/ e2、功能
  ], t1 [( z6 Q; T
1.控制输出的目的地

, l7 }# h( i) T! ~  c, e2 S# r) A2. 控制输出的格式
# X2 s6 X3 [3 Z3 b
4 M8 j5 M( K1 R! N4 C3. 控制输出的级别
: T! i& ^1 E' h& L8 S
2 W+ M, S# \( L3 R3、日志的级别

0 u7 b4 T7 c7 ?3 v! k1. debug 调试

/ |+ a$ o4 U+ P2. info 给用户的提示信息
% a0 |* E: _+ F) Z
3. warn 给用户的警告信息

' z* n0 }" O" i; C4.error 给程序员用来调试

Debug—-〉info—-〉warn——–〉error
6 j( h8 @% V7 W) Y, J: a7 z9 Y
4、配置

1.配置级别

3 P$ D3 S9 j5 i3 j3 Y2.输入源 （控制台和文件）

- ^7 j( N& d' D0 q! Y3.可以进行分包控制
( g6 c; j. R9 m
Log4f.logger.包结构 = 级别

* K' `' j% `0 I9 f# e* U/ x5、使用

: B4 F" D" [' \/ m8 ALogger log=Logger.getLogger(Test.class);
1 P8 |/ ?) D( N6 Y4 z' \3 x
    public
void t3(){

        log.debug(“this is debug”);
* V) Y# W# s. W
        log.info(“this is info”);

7 v! D* H" G, ~: q/ ?3 L' l        log.warn(“this is warn “);

        log.error(“this is error”);

% [7 \% ?. Q- b' z& d    }
8 s4 Z+ Z) _3 `4 o* Y3 l
. H* e: Z5 o% ^) gJunit
+ E0 e+ r* I& _" {: d1.是什么？

; z1 c. [" h( l  z. z: P- o单元测试的框架
1 b3 B3 L; E$ ~, e( }
2.怎么做？

写一个类继承TestCase
2 H  X  k. F" x6 z6 c" N% U
测试的方法一般都以test开头并且没有参数

在测试方法前执行的方法public void setUp( )

在测试方法后执行的方法public void tearDown( )

error和故障的区别
, t4 O4 z3 a2 z4 ~
error ：代码有问题

. T* G2 L# f7 Z2 ?) |2 G故障 ：逻辑有问题与祈望的值不相符合
* p: L2 q$ ]% {
生命周期
( E8 |  s# U; f
2 A1 Z; M7 \) h9 H" J0 ]7 \4 y测试—〉SetUp（）—〉testXX（）—〉tearDown（）—〉结束；

TestCase套件

" O) w7 Z$ N* Tpublic class MyTest{
. K8 A! A6 z1 R, N* S" J, b
        Public static Test suite(){
( m. ^, ~. L0 u" j3 D5 u
TestSuite suite = new TestSuite();

4 y! |: h- n. l7 X8 l( I/ Ksuite.addTestCase(Test1.class);

suite.addTestCase(Test2.class);

}
) Q4 X3 `/ \$ |! Q0 K* o; e
}



- r8 w- i/ D5 \Ajax
是什么？
( u, n, W8 [! Z$ }$ q* o0 _AJAX即“Asynchronous JavaScript and XML”（异步JavaScript和XML)。是一种创建交互式网页应用的网页开发技术。

无刷新页面。

& W3 D% Y- d4 [+ f5 F$ _4 e有什么？
' k9 A% z& D3 g6 b2 a, gAJAX是多种技术的综合，包括JavaScript、XHTML和CSS、DOM、XML 和 XSLT、XMLHttpRequest。
+ C3 `, ?& X- I6 ^: [
. E3 M( i+ Z  C4 z" v5 c/ ^+ t能干什么？
, r4 p2 V& R  i$ V使用XHTML+CSS标准化呈现；
3 x4 O  P6 z* N: Z- @/ t使用DOM进行动态显示及交互；
使用 XML 和 XSLT 进行数据交换及相关操作；
' @3 H2 c  R/ y' x  ~使用 XMLHttpRequest 进行异步数据查询、检索；
使用JavaScript绑定和处理有所得数据；
. `; [2 _' ~* L8 E7 |' G
* @$ p/ Y" s( u6 K" M传统的web应用允许用户填写表单(form)，当提交表单时就向web服务器发送一个请求。服务器接收并处理传来的表单，然後返回一个新的网页。这个做法浪费了许多带宽，因为在前後两个页面中的大部分HTML代码往往是相同的。由于每次应用的交互都需要向服务器发送请求，应用的响应时间就依赖于服务器的响应时间。这导致了用户界面的响应比本地应用慢得多。
1 u$ g! [) s  Z. ]
与此不同，AJAX应用可以仅向服务器发送并取回必需的数据，它使用SOAP或其它一些基于XML的web service接口，并在客户端采用JavaScript处理来自服务器的响应。因为在服务器和浏览器之间交换的数据大量减少，结果我们就能看到响应更快的应用。同时很多的处理工作可以在发出请求的客户端机器上完成，所以Web服务器的处理时间也减少了。

0 L  d2 ^5 S4 p" z使用Ajax的最大优点，就是能在不更新整个页面的前提下维护数据。这使得Web应用程序更为迅捷地回应用户动作，并避免了在网络上发送那些没有改变过的信息。
4 |* K: I% I. Y5 p/ g" ~! S# \& Q
8 w, B4 g) [) B. F4 H$ n, ~对应用Ajax最主要的批评就是：
1 它破坏了浏览器后退按钮的正常行为，就是用户点击后退按钮后不能看到之前的数据；
( }# H% |+ R" _9 F2 一些手持设备（如手机、PDA等）现在还不能很好的支持Ajax；
3 用JavaScript作的Ajax引擎，JavaScript的兼容性和DeBug都是让人头痛的事；
- m+ K1 k# [: ^/ p: U1 p4 Ajax的无刷新重载，由于页面的变化没有刷新重载那么明显，所以容易给用户带来困扰――用户不太清楚现在的数据是新的还是已经更新过的；现有的解决有：在相关位置提示、数据更新的区域设计得比较明显、数据更新后给用户提示等;

) H& x# |. E* f9 S怎么做？
' ^. {% @, R# C% X<script language=”javascript”>

var req;

function add(){
0 [/ J; p8 ^& |  B& L: F: ]: u/ [
7 W0 i" L5 H2 ^9 F- u) Z//1:创建用于传输的对象

  u7 x4 v! R( q( A3 {. }req=new ActiveXObject(“Microsoft.XMLHTTP”);

+ }2 g5 X1 L& G' s  ]// 声明返回后，处理数据的方法

req.onreadystatechange=manage;

//2:准备传输的内容

5 A4 J3 C0 M. }# o7 _5 b6 L7 x0 \var str=”test1111″;

//3:发出请求
. F/ c1 l: |4 P4 s/ t
req.open(“GET” ,”/others/ajax/test/t2.jsp?str=”+str);
. z& K0 {( W, f3 r( `
  l. ~4 Z/ m' h5 z. Z4 Ereq.send(null);

}
. a: w: C# _! C
8 f0 Y, h3 K  d+ R$ l- r( Q//4:接受返回并处理
$ S' Y* Y; ^7 |' J+ |( c
function manage(){
- i5 Q" d4 r; j( M' E( C' L8 b
if(req.readyState==4){

0 W) j& r: K" b1 ^5 n  Q6 palert(“r==”+req.responseText);
% p- A" \$ Y/ k1 B) i: |
}

}

; ]4 F, [( Z# b1 H/ T6 \. J</script>
* ^3 n( M% F# x9 ~# \. m: ?: R( G
% Y% j; Y' A6 g7 z+ r6 ~readyState的取值如下：
- E( y" N% ?7 y, G% P0 W
: l) Z* n! ]7 {4 g/ S　　0 (未初始化)

　　1 (正在装载)

　　2 (装载完毕)
; `# x6 E/ C. k- _; f: r  D( x. K
　　3 (交互中)

　　4 (完成)
* Q! r. }; H/ E) w  v4 f2 W0 \; T
2 W# ^6 |; u, t6 v+ X8 s, m* N

# n( B5 w/ T- A$ e6 P3 k$ a  L4 L原理
8 S$ E4 A0 I) A/ dAjax的原理简单来说通过XmlHttpRequest对象来向服务器发异步请求，从服务器获得数据，可以是xml格式，也可以是一个字符串，然后用javascript来操作DOM而更新页面。
( Z3 i! E, A! D, K
& w4 a6 |" o  @' J$ `Dwr
是什么？
DWR（Direct Web Remoting）是一个开源的类库，可以帮助开发人员开发包含AJAX技术的页面。它可以允许在页面中使用运行在WEB服务器上的JAVA函数,被调用的JAVA函数就像是在页面中JavaScript方法一样。

! m/ G) K4 L: @" R; j2 w0 D8 V# L有什么？
它包含两个主要的部分：允许JavaScript从WEB服务器上一个遵循了AJAX原则的Servlet中获取数据；另外一方面提供了一个JavaScript库可以帮助web开发人员轻松地利用获取的数据来动态改变网页的内容。

9 w/ ^+ x& t& B* `' h; j7 S1 s
% W8 h/ {' ^7 k: m
能干什么？
动态地把java类生成为JavaScript，感觉调用就像发生在浏览器端，实际上代码调用发生在服务器端，Dwr负责数据的传递和转换。这种从Java到JavaScript的远程调用功能的方式使DWR用起来有种非常像RMI或者SOAP的常规RPC机制。

! K, A/ c) @  g: E
; W- Z0 u9 F6 V; d9 G3 a. v8 \4 V, W
怎么做？
1 V1 V( N& p" |① 编写配置文件
2 v+ \$ e4 ]- {+ {5 v
/ O% q' x) F- fweb.xml
5 _% @0 x" S5 I  x+ }8 a
<servlet>
! P" i& c8 O0 v; x
; d$ r+ @' A( D: I$ w<servlet-name>dwr-invoker</servlet-name>
9 m9 D- `3 [; K. n
<servlet-class>

' C4 a* w+ t" ]5 [* {: H9 Y7 korg.directwebremoting.servlet.DwrServlet
2 u& F/ Y  k% W$ i) I
</servlet-class>
: v+ v/ W+ h6 s3 e0 P) \8 _2 N
<init-param>

<param-name>debug</param-name>

& C/ D$ {  s  m' T<param-value>true</param-value>
$ U' q! z0 S! r: n9 c! T9 W) k
' f  g3 b, U8 Z# G* r1 c</init-param>

</servlet>

<servlet-mapping>
/ {3 d: T9 V8 I5 I
<servlet-name>dwr-invoker</servlet-name>
8 p0 }2 \8 M- Q- G& g( K8 ?" R! W
<url-pattern>/dwr/*</url-pattern>
0 \$ ]: P. T9 {0 y, J5 z
</servlet-mapping>
" [# g' }/ v1 n4 v
dwr.xml
# _# v: {8 l( e
<allow>

0 ~* ?3 `  d" P: H5 H<create creator=”new” javascript=”kc2″>

<param name=”class” value=”dwr.Service” />
" ?! `$ j$ }% n- B" ~
</create>
1 I3 K+ w' k8 B
</allow>
  b) w8 t( d# `& r# `9 O
/ t" x% \' x  W9 N2 N1 R②编写service
: p: V6 S& B. F& q. M
, n2 B- {* Y5 v& ]) g* r& spublic class Service {
% {  y7 m! \$ z! q, n0 r% Q
% v5 V( _9 \* {  n$ B5 Q& Vpublic String sayHello(String yourName) {

//可以是访问数据库的复杂代码

. c) \  h! c! n' C4 d2 v. Greturn “Hello World ” + yourName;

( H$ N* |1 k% a5 Q2 a& p( Q}

}

③测试DWR

将代码放入应用服务器（比如Tomcat），启动。
! h+ V3 [1 B* m
然后在地址栏输入http://localhost:8080/你的工程/dwr
, V8 I& E& {( @  Y: W8 L% d) L
④编写jsp页面

8 }' z: w+ L0 @+ j9 y) [0 ~1） 要引用3个dwr的js，其中engine.js必须要，如果需要用到dwr提供的一些方便的工具要引用util.js

2） 然后还要引用dwr自动生成的js，dwr/interface/service.js，注意js名字要和dwr.xml配置的一样
% E8 E+ R. r7 X* n4 b. k
+ y, f) s& F7 ^$ ~8 c3 b3） js里的service.sayHello和java类的那个有一点区别，多了一个参数，用来得到返回的数据