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

admin

JEE
  s. t6 I) V# X0 C, G1 B简述JEE
JEE　： JAVA　 PLATFORM　 ENTERPRISE　 EDITION

JEE是一个规范集；

JEE是一个框架集；

4 w' T, E+ x- {6 zJEE是一个技术集或API集；
) k( |4 k. k/ W
适用于创建服务器端的大型的软件服务系统
3 c. j4 k' \+ E: J: C: v4 O
( r! n5 N, @; s
2 T$ z- I9 }5 @9 W
5 E! d0 `4 r# s2 ^9 S* R, n# wC/S B/S 模式
C/S client/server即客户机/服务器模式，客户端也参与程序的运行与计算（富客户端、胖客户端）
6 w& d# i9 N( q& g: g0 Q9 f! s2 q
' v  o0 w, R5 D: a3 |) O9 pB/S border/server即浏览器/服务器模式，又称为瘦客户端，客户端不参与程序的运行与计算
6 Z7 B) O% [2 _$ }. R# U. ?6 N

( j% Y& f. I: s
企业级应用（大规模的应用）的特点
5 K% _' e2 H3 L$ B5 M. j1.生命周期长、稳定、可靠
( {; l$ g1 U6 N# r) y/ R
2.组件往往分布在异构的环境中，能够跨平台

  t2 D7 S3 R) ^) G% u3.维护性、扩展性、重用性
6 o! ~- e/ _$ V) t- ?7 s
4.有事务、安全、线程
' k( z: a8 m9 {5 q/ Z: ^" }
$ i- H" n& q2 X, `# b7 W6 r
4 Z( p) ~" ?" p! N" e
什么是业务逻辑？
依照业务逻辑划分模块，
% q) \/ ~+ G0 C" s+ V9 N( p
所谓判定业务　就是具有以下特征：

" M& B/ E' g" u7 j) U1.业务流程
5 T/ [$ }$ o- m
2.业务判断
0 A$ V. T2 b. P! Q
3.功能组合

5 l' F. O( z" z7 g- Y
# k* `! s& R1 y+ N& z% s
平台（角色）的划分
5 n. b3 c8 K: p' E1.平台供应商。提供满足API集实现的厂商（BEA weblogic IBM webshphere）
2 |" `* M. i. t  A) ^5 Y% m
4 g) r5 b# j5 k# }8 n8 a2.组件供应商
8 e' i. p* v2 J6 \
2 l3 N8 l7 D% q+ e& e  {3.组件装配人员
0 j0 G/ }' J3 z- w6 u; x; ]3 e$ B
4.部署人员

' s& O* f5 n5 [& M; {9 h, X$ h5.系统管理人员

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

, e; y; Y& M8 C0 j; ?8 N6 O( n
3 o" b1 z7 d+ S
java技术分布（设计架构 模块内部设计）
! G% J  e# {/ S0 B, a7 h1.表现层 Servlet、 Jsp、 JavaBean、 Taglib
0 S! o$ v7 l8 }- g
2 L2 [! `8 Q$ B* E/ Z6 o- R1 A2.逻辑层 EJB(SessionBean)

3.数据层 （　JDBC 　EJB（EntityBean））
9 b: T4 p! Q+ z, t
; u% r5 U/ R4 E# b4.服务 JTA（JAVA事务架构） JTS（JAVA事务服务） JAAS（JAVA授权与验证服务）

9 T5 }  M/ G/ S5.分布式通讯 RMI（IIOP）+JNDI 、JAXP（JAVA 的 XML 架构）

JAVAMAIL（邮件服务）、JMS（消息服务）、IDLC、JCA（JAVA连接器框架 （成））
& f: p" d& q% L2 n3 d' O$ _; h


: l1 ?" D( i: `! M- @JEE的体系结构： 是一种组件的体系结构
1.组件 ： 能够完成一定功能的封状体（独立的功能的集合）
9 V4 q7 }! I- l( q
不能单独运行，必须运行在容器上

  h" U6 S5 g+ E) [0 F$ [分为两类：web组件、ejb组件
2 A! L/ g5 Q. P7 U
2.容器 ： 提供组件的运行环境，并对组件进行管理（一段程序）
4 u" a) ^' ~/ p; G
, k3 l& _0 k3 J) H! _9 Q管理组件的生命周期
* |0 m" J. y/ Y1 u. l
不能单独运行，必须运行在服务器上

程序（组件）通过上下文来调用容器（context）

: ?# z& _  b; h组件通过web.xml向容器描述自己，使容器能够认识组件
5 d# X- H7 S0 y" W
容器通过回调方法来调用组件

; [7 m  l/ k2 V) z5 p. c分为两类：web容器、ejb容器

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

! G# D$ n/ _. \web服务器（只提供web服务）

jee服务器（提供web、jee服务）
) r2 a( r- k3 [/ j7 ^) ~. R


什么是回调方法
; o4 C$ \/ P* J  S由容器自动调用的方法，就叫回调方法。
2 c9 U# W, y4 R1 s6 l
( }7 ^' B2 i# H- k" r
6 e, T/ ^' U/ H
ＲＭＩ远程方法的调用机制
( Z0 P! g$ N$ i; @+ E例如：Ａ主机有Ｂ（）方法，Ｃ主机有Ｄ（）方法，Ａ　想调用Ｃ主机的Ｄ方法
. \+ j/ i; W# F3 w5 z  w

" y: P; a- ^+ [) o+ h
" v6 Z+ r! s4 q

* i( B, [1 T+ [$ Q0 ^# P, D3 J学习方法
% i% Z; q& O+ w1 n1 e9 o1.规范（熟记） 2.熟悉API 3.多练 4.多想

admin

Servlet

•     描述war包、jar包、ear包的结构
  
  
  $ S1 ^1 k8 k+ v5 T. R* ^+ F

war-                            web文档压缩包

—WEB-INF

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

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

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

; ~5 Z, N; F/ Q& Q& i

jar-                             java文件压缩包

—META-INF

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

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

–META-INF

—Application.xml 配置文件

–*.war

–*.jar

& O# I$ W" U; @+ F2 y9 n

• 什么是servlet？servlet主要做什么？
  
  
  $ p* ]# f% t' N  o

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

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

• servlet 与cgi相比的优点？servlet的缺点
  ! a- w; c9 Z2 v2 U; u8 ?& L* P
  8 U. q1 m; r, B7 {5 ^) Q- V  v
  : y5 o9 O8 W$ D/ x

优点：

性能（线程比进程更快）

可伸缩

Java强健且面向对象

Java平台独立

缺点：

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

9 B& H* ]/ Z! X5 N' M- F

• 常用的servlet包的名称是？
  
  
  

javax.servlet

javax.servlet.http

0 j$ R* `# o, d; {

• 描述servlet接口的层次结构？
  
  
  9 ?/ A& @7 y0 y. U* |/ G

Servlet

–GenericServlet

–HttpServlet

–自己的servlet

ServletRequest

–HttpServletRequest

ServletResponse

–HttpServletResponse

, L, b! F5 k: q; F0 }) b- v$ G

• 对比get方法和post方法？
  
  
  

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

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

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

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

• 归类描述HttpServletRequest接口都完成那些功能
  8 _; c( U. q- D  E+ L
  : A" u. ~* _: [6 b+ ~. b
  3 F- h" X2 M' C: T" w- J
  • 读取HTTP头标
    ' H( ?- }* D1 k. H, I. i2 F
  • 读取cookie
    1 {* r- P, F0 w( d" p
  • 读取路径信息
    
  • 标识HTTP会话。
    ; }( R' d. E6 N- Q! s) R
    

- @& h2 _  `# h0 @3 W5 V8 n! t

• 归类描述HttpServletResponse接口都完成那些功能
  
  
  $ u) K0 B# G- b
  • 设置HTTP头标
    
  • 设置cookie
    
  • 设定响应的content类型
    
  • 输出返回数据
    % F. G& D* H7 n+ G6 `2 l
    

% G4 h6 {" x) i, o# t

• 描述service方法所完成的基本功能？默认是在那里实现的？
  - s: J' s0 S- S' n
  
  

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

实现：默认在HttpServlet类中实现

• 如何开发自己的Servlet？描述应该做的步骤和每步需要完成的工作
  
  
  # r  r! \& ~. b2 V# T" \

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 E  i* m- t4 X( c& C# t& W

• 为何servlet需要部署描述？
  / G% C: Q9 k! r, I& {1 L
    p: e' A6 n" J; P9 K' H) F
  ; J) T$ E. T! x4 Q# r" z

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

• Servlet基本的描述应该是？请写出来
  ! |8 i$ e! q0 \: s, d/ w7 D7 D; w4 R
  
  3 H8 A( f2 X6 r' g/ c! M

4 G- s/ Q( f$ M7 O8 t

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

1 w! e( B" H1 E

• 如何在html中使用servlet
  7 L% k$ r! N3 `& Z5 P
  : Q7 z& S8 H4 l+ t4 l
  8 b" I% Y9 K$ k$ Q, J6 _, v

FORM标记

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

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

语法：

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

{HTML form tags and other HTML content}

</FORM>

7 m: t, f* N9 J) W) r

• 如何接受request中的参数
  
  8 |& E) I4 A3 P- ?$ u: N7 G: [String userName = request.getParameter(“userName”)方法
  3 v% F* \5 C& S/ ~6 m; ~
  ; D9 m; c9 i( k+ `8 Q* l

• 如何接受request中header的值
  
  
  

request.getHeader(name);

request.getIntHeader(name);

request.getDateHeader(name);

request.getHeaderNames();

7 P# o. l- ~; I/ b9 G

• 如何输出html
  & [2 D' H/ m' F) O) }5 u/ _' K! r
  
  

PrintWriter pw = response.getWriter();

pw.write(“<html>”);

pw.write(“Hello”);

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

• 如何设置输出的contentType
  
  
  ; U! Y2 V4 L% I$ N7 l8 {

response.setContentType(“text/html”)

* p' D8 |+ S9 A5 b5 Z

• 描述servlet的生命周期？
  0 q; \9 c+ [" [+ Y
  
  $ }* [# W1 b. l; z, k

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

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

• 描述init,service,destroy方法的功能和特点
  
  . x% B( z( j! M5 p2 O( _/ B
  

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

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

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

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

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

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

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

: \" p5 ]; v+ X: r

• 什么是回调方法？有什么特点？
  4 P& G$ G- s) \+ R% U2 b: j
  # m# k: c9 x- k" V+ Y
  $ z! ^$ j% J; Y4 U& i

由容器来调用程序的方法

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

• 如何设置初始化servlet的参数？
  
  " j! y& g  ]. E$ V1 F在<servlet>中添加如下配置
  % ~4 s+ @% i# R  X/ B
  

<init-param>

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

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

</init-param>

' f/ r+ @: ]% e1 z8 c3 Z3 f

• 如何获取servlet初始化的参数
  8 ]' V2 r6 F+ r) z: Y# b8 A
  . ^4 U' o- f* r7 D
  ! S* W6 f9 d8 h: z( B: L3 q: x

public void init() {

greetingText = getInitParameter(“greetingText”);

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

}

• ServletConfig接口默认实在那里实现的
  
  
  

GenericServlet类实现ServletConfig接口

• 什么是ServletContext？有什么作用？
  ) |2 F$ d0 t6 a, s, F* j
  
  : B9 p" V3 `7 h* [

Servlet上下文

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

; G; \8 {4 s4 h$ f% s! V

• 如何访问ServletContext接口？是在那里实现的？
  0 `, C( a/ z+ t; n* e
  0 H- Q# T4 Z+ K5 |
  

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

GenericServlet类实现了ServletContext接口。

• ServletContext接口的功能包括？分别用代码示例
  
  
  % Q6 l4 p  i7 p6 g( P/ {8 ^

只读初始化参数：     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的参数？
  5 B/ l% ]4 b# Q$ j. F
  
  

<context-param>

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

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

</context-param>

8 |6 i" A! J5 P/ z/ T. ]( X' g

• 如何获取ServletContext设置的参数值？
  * `, h8 O7 n2 j- x! }& h/ A9 q  X
  ; d% O* j. D: R) \) P
  - B$ G6 T- S/ b; O4 l8 O, G0 K$ W

ServletContext context = this.getServletContext();

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

' W( ^  A: X7 |1 V: c) i

• 描述Web应用的生命周期？
  4 D7 o! A, a' W: ^9 I8 T
  ! A* x$ K/ V4 ~) G
  

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

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

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

• 如何用代码实现监控Web应用的生命周期？
  
  
  5 x! g, X" S0 B! L6 m7 f
  

public class Test implements ServletContextListener{

public void contextDestroyed(ServletContextEvent arg0) {

System.out.println(“web 容器销毁了+++++”);

}

public void contextInitialized(ServletContextEvent arg0) {

System.out.println(“web 容器启动了+++++”);

}

}

# A, L; w) b' j

web.xml文件中的配置：

<listener>

<listener-class>

com.csy.Test

</listener-class>

</listener>

• web应用中如下错误码示什么意思：400，401，404，500
  
  ) X' J: c# l7 i7 K  n. k5 w
  400 Bad Request//错误请求
  401 Unauthorized//未被认可
  404 Not Found//没有创建
  500 Internal Server Error//服务器内部错误
  
  # X+ p0 ^( q* l$ z8 x% P  h6 q9 _2 \

• 描述Web应用中用声明方式来进行错误处理的两种方法
  3 R4 U- M3 x  h) _1 L
  
  

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

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

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

• 描述记录异常日志的方法，都位于那些接口？
  
  
  & k) _' \6 f% N. F$ i8 X) O' M% n

GenericServlet：

log(message:String)

log(message:String, Throwable:excp)

ServletContext：

log(message:String)

        log(message:String, excp:Throwable)

• 什么是会话？
  
  
  

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

• 如何获得会话？
  
  
  HttpSession session = request.getSesseion( );
  
  . v% B) I8 f7 @% g

• 会话Api的基本功能？
  * @1 ?4 t2 K4 r. C/ k0 ?
  5 ?+ U+ ]( n+ N9 J. G6 t1 E; Q/ ?
  0 P- B+ W$ ]( u, X! k

getID() :String

    isNew() :boolean
. Q  c$ x/ `$ a# D5 ^2 e

    getAttribute(name):Object

    setAttribute(name,value)

    removeAttribute(name)

• 如何销毁会话？
  ( D( n. E- N+ U2 N1 l$ j! }
  
  

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

<session-config>
' p0 _% f9 t2 u' l! f( n' G

         <session-timeout>10</session-timeout>
" V' |, [; I8 M1 ~3 u4 H

     </session-config>
" J! ]& `: p: ?( v4 v& G/ V* J

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

invalidate()
+ S" D9 L2 x) T* R/ F' z( u% \

     getCreationTime() :long
" ~1 n' J* L- U% ~1 G& r$ Z1 ?

    getLastAccessedTime() :long
+ a, i2 V2 x' [. N! V* Q

    getMaxInactiveInterval() :int
' y& @/ F7 d* T5 i1 ?

     setMaxInactiveInterval(int)

• 描述会话保持状态的基本原理
  1 B/ [3 ^2 |7 W
  
  

    client server
" ~1 k+ S2 R9 h9 {0 d+ Y; J

- H# q8 m: E8 a  T  w0 {$ t

request

response (sessionid)

request (cookies)

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

4 n! a% W2 q, Q/ J

• 请描述session和cookie的异同之处
  ) z- Z& r: x. _' H3 r4 j0 z# {  I
  
  

+ S; t  @  y1 ]6 m) |7 ?: Z. f

• 如何读写cookie，代码示例
  
  
  * z& Y0 E+ q; L3 @5 j# U

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

response.addCookie(c);

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

        for ( int i=0; i < cookies.length; i++ ) {
* x) ^' y+ ]0 y* X8 {* V) W4 M

            String key =cookies.getName();
% b8 |" Y3 g& i* l# S4 n& |! {

String value = cookies.getValue();

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

     }

0 U' c% R" }3 p% Q

• 什么是URL重写，如何实现，代码示例
  
  
    ?! y5 W% M8 S

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

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

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

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

8 R1 E% E; H  C% V0 m

• 描述web应用的4种认证技术
  9 m' @" ~9 k& A9 k8 K
  9 `3 M0 G5 o7 V( D( w4 O6 W
  / r# U7 |8 `. u; V

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

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

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

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

$ d0 z6 l5 F1 K8 g

• 什么是授权，什么是验证？
  " h. W4 O2 }7 D2 z' v* {
  
  

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

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

! J) d) l) C0 t2 ?

• 什么是HTTPS
  * m7 Y* P. M6 G" P) g+ l" a* J
  1 K% a6 m, h( M& X6 ^: X
  

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

• 什么是审计？
  $ u( l2 S( q! c2 K& E
  
  

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

• 如何实现声明性授权
  , R: l5 @0 v! t1 A& ~; x! A3 i
    L1 H, w: o( h( |7 t- _
  3 ~! \0 P' H; n2 C$ @/ U

1、标识web资源集

2、标识角色

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

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

在 web.xml里配

• 描述servlet并发问题？
  
  
  

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

• 描述Web应用中的六种属性范围
  8 O" i- [3 U# Z; e4 M
  8 d2 X7 J  C! U& X/ y* G4 z
  

局部变量（页面范围）

实例变量

类变量

请求属性（请求范围）

会话属性（会话范围）

上下文属性（应用范围）

• 指出上述六种哪些是线程安全的
  
  
  

局部变量和请求属性

• 什么是STM？如何实现？
  4 L0 H* Q$ f3 k, J9 v: Z
  
  

SingleThreadModel接口

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

• 如何实现并发管理？
  
  / `8 _% O/ K* e# `% [: O3 b$ [
  . p5 [8 A3 n; F# w

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

使用synchronized语法控制并发

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

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

admin

Jsp
什么是Jsp?
Java Server Page    结合java和html在服务端动态生成web页面的技术

5 x2 y* W3 o; ^  R0 F$ p; B
4 E1 h( h0 S; c# n: L
描述Jsp页面的运行过程？
第一步：
& I" w$ m+ D: \9 n! }
/ j/ x; P; @+ I( M# h请求进入Web容器，将JSP页面翻译成Servlet代码

; g4 y( f3 c3 }; H; R2 O6 o( c" a; G第二步：

) k- c: |# N1 Z# o7 {; ~编译Servlet代码，并将编译过的类文件装入Web容器（JVM）环境

& F/ m% O' i: f% G/ f第三步：
( I0 v3 D, H7 C" i7 L
Web容器为JSP页面创建一个Servlet类实例，并执行jspInit方法

第四步：
3 G6 R# V, z/ Y+ P: |* j- {
Web容器为该JSP页面调用Servlet实例的_jspService方法；将结果发送给用户


1 s8 F, ]1 z6 D& p
; _3 [/ }8 X: I7 ^5 M描述Jsp页面的五类脚本元素的功能、写法、并示例
7 @1 d$ F: ~5 N( U, N注释 <%– –%>

<HTML>
7 c7 D9 f# c( e# n0 d
) y& Z. {6 _8 t<%– scripting element –%>
7 q0 t, w/ @1 T% h! I) i5 k4 u: }
( ?6 }7 ^/ `9 x1 R5 K) M</HTML>
" t8 U& O: k9 C  m$ `# h
$ Q* L% ?2 _" G9 d( f2 D指令标记 <%@ %> 指令标记影响JSP页面的翻译阶段
2 P  W- L* x7 X. _: }+ M: V
. k* Y. p. @7 V1 h  B<%@ page session=”false” %>
7 I+ i/ _& a  @+ c- u# o
声明标记 <%! %> 声明标记允许JSP页面开发人员包含类级声明

, \- [* v5 C( _4 P% l" P<%! public static final String DEFAULT_NAME = “World”; %>

' u2 K. f5 c; k- q    脚本标记 <% %> 脚本标记允许JSP页面开发人员在_jspService方法中包含任意的Java代码
3 I& K$ r7 z+ z! y" `$ r
    <% int i = 0; %>

7 H, V* _/ R/ y+ |( j8 _# ]! ]表达式标记 <%= %> 表达式标记封装Java运行时的表达式，其值被送至HTTP响应流 <B>Ten is <%= (2 * 5) %></B>
, @$ O- F9 Z5 n! w


描述Jsp页面中的注释种类和写法
HTML注释
; R3 m/ l* x4 N7 G
( B+ G( [/ y5 n) P7 G<!– HTML注释显示在响应中 –>
  v9 v( w/ x: A- N; n  v
JSP页面注释
7 S) `% W4 B7 R/ ~7 f2 K+ {
<%– JSP注释只在JSP代码中可见，不显示在servlet代码或响应中。–%>
; s# M% z: O9 |$ p+ J
' P. V* G5 Q) ]% x7 n' _1 Z3 XJava注释
  h2 B! h& y  T, P$ X$ T# T
$ P5 x% {( D! Z* H4 ?" D0 E5 A<%
4 i+ K# h+ X/ Y
9 y) C, H4 X& B1 r8 J/* Java注释显示在servlet代码中，不显示在响应中
4 s# H  A) a% R: H) C$ [& u2 H
1 |* M( G( ~7 l' ^9 g( E! G$ p# Y*/
7 m% p$ Y$ H! C0 j) K3 N
& C% i( H6 |3 f* [- L+ a; ]6 |/ G%>
) y: t( v( O" u% c* v2 C
0 d$ x6 G+ D7 D9 `2 b/ W# @
7 |! B: a9 ]( `1 P& B' x
1 ]4 C# }1 F) c, n' y描述Jsp页面的指令标记的功能、写法、并示例
指令标记影响JSP页面的翻译阶段

<%@ page session=”false” %>

<%@ include file=”incl/copyright.html” %>
2 k* p4 P' N7 \" G  H4 f( X
' g) S  Z! o0 K$ y" e<%@ taglib %>

0 {. ]. X; o" o+ ?: v

描述Jsp页面的声明标记的功能、写法、并示例
声明标记允许JSP页面开发人员包含类级声明

写法：

<%! JavaClassDeclaration %>

$ i& L# E. u, L  }: Z8 e) p例：
6 e- A1 p, [/ i" Y8 E1 K" l
<%! public static final String DEFAULT_NAME = “World”; %>

* P; Q) V# ?3 `8 ^' `: j<%! public String getName(HttpServletRequest request) {

return request.getParameter(“name”);
* K7 ^9 {3 k4 W& `5 x
}

%>
* H# `$ Q8 V( w! L  \# P) L
<%! int counter = 0; %>

  l: L; e5 Y# P4 j

# ^* u& O5 b7 O# |6 a描述Jsp页面翻译成Servlet的规则
) D5 J- m: X& S+ v& V4 P2 `# D% Ijsp中的注释标记被翻译成Servlet类中的注释
# Y  y% K- s7 ?6 E1 Z0 Q+ y) h( S
jsp中的指令标记被翻译成Servlet类中的import语句等

1 k( W& `7 k& X. h7 xjsp中的声明标记被翻译成Servlet类中的属性

- H# ^1 ~- i) S4 ojsp中的脚本标记被转移到Servlet类中service方法中的代码

+ X. Y1 b  n+ Rjsp中的表达式标记被翻译成Serlvet类中的write()或者print()方法括号中的代码
0 c( Y# j5 w3 V7 w. w* o0 ^( \
8 Q$ U6 z2 [  U$ d! x& p* y1 [
2 e& ~$ [" C" e5 c- R
# D; {0 d2 p! j描述Jsp页面的九个预定义变量的功能、用法、并示例
% |9 ]# B: _8 P& Hrequest 与请求相关的HttpServletRequest对象
3 \9 @) A' d. A
! m8 ^4 j& d3 k5 @, e! s  dresponse 与送回浏览器的响应相关的HttpServletResponse对象
* u% P! k% C( q. [
# e3 I- a( |' P* s7 ]. N  Eout 与响应的输出流相关的JspWriter对象
9 H' L, |+ A+ E6 ~6 ^% g! I
    session 与给定用户请求会话相关的HttpSession对象，该变量只在JSP页面参

9 d: N2 s% S+ f8 R8 Y9 r9 P6 Y. j与一个HTTP会话时有意义
: u! S- k$ B' N. ^0 m6 Z
    application 用于Web应用的ServletContext对象

) n: z& b) r% a6 \: E+ Z4 nconfig 与该JSP页面的servlet相关的ServletConfig对象

; p, }; D- l1 h0 f! e; K" KpageContext 该对象封装了一个JSP页面请求的环境
" N" \  [  p$ P, L
# x, l# ~7 M( o7 ^1 Spage 该变量与Java编程语言中的this变量等价

    exception 由其它JSP页面抛出的Throwable对象，该变量只在”JSP错误页面”中可用
: _% h0 g; }+ M3 Q; S! o
! Q2 Q* Z% i, P* ?# n+ E* G. {/ s

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

6 i- f7 u1 b/ `4 n% S* g逗号分隔的完全类名或包的列表。

session session 定义JSP页面是否参与HTTP会话，值可以为true（缺省）
0 ?& e: q% T& Y/ R
  g# v! {: C1 V0 H4 r或false。

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

: C- X5 t. _3 s+ S7 q9 _! Y5 C8 ?none或Nkb，缺省为8KB或更大。
1 @6 I- B9 D& E2 u0 C
* g! J7 }, |' C' ]- o: ^errorPage 用来指定由另一个jsp页面来处理所有该页面抛出的异常
$ u- R6 e, l8 s- R0 R
isErrorPage 定义JSP页面为其它JSP页面errorPage属性的目标，值为true或
8 e! U& j7 }# P0 W$ X
false（缺省）。
4 R7 l5 x$ S  Y. A# a
ContentType 定义输出流的MIME类型，缺省为text/html。
: k7 i% D6 D0 Y" ~) ?0 C% Z
; u9 Z3 b3 f! E8 C# k' kpageEncoding 定义输出流的字符编码，缺省为ISO-8859-1
, \6 H) i/ E. w9 f. l: M

% t2 \( {+ W+ o6 R( B: R' p
描述MVC各部分的功能？MVC的优点？MVC的缺点？
4 M- p; t! q5 `3 A  PMVC各部分的功能：

) r1 |, z( Z/ H, t1 s! J% }) wModel（模型表示企业数据和业务逻辑）

2 m5 _( Z) R/ V3 Z封装应用状态

响应状态查询
! t3 H$ E! _- m1 h0 {$ y' ~6 y
& U$ b* o+ F5 P/ q3 E6 l# ~) `暴露应用的功能
6 ]5 G; H0 S5 D- S5 v# v; k
Controller（控制器接受用户的输入并调用模型和视图去完成用户的需求）

% v; H: p% c8 o7 E验证HTTP请求的数据

1 N! D3 C" b. ?+ z# J* y' W3 ^将用户数据与模型的更新相映射
6 L( x5 ]! T- \4 P4 S
选择用于响应的视图
+ p: s8 ~2 x: b
View（视图是用户看到并与之交互的界面）

9 ?; p3 |- [+ y6 N! ]: `/ \产生HTML响应

! x$ n& n% C& r3 D) ?/ z请求模型的更新

7 u/ c; d/ Q& M) t; R% M提供HTML form用于用户请求

/ M* j2 |  a2 l* _0 F6 p0 k* OMVC的优点：

        低耦合性：视图层和业务层分离

高重用性和可适用性

较低的生命周期成本

快速的部署
: b. ~- m6 \7 y1 j0 F
可维护性
* T1 V9 m: B/ s; A/ }8 m  e
# ~2 }: \  {% M7 g. i有利于软件工程化管理
2 F7 A% v2 H) L: D, E- A
提高软件的健壮性

MVC的缺点：
. r9 c* U! w  J% E
        工作量大，增加工作的复杂性，MVC不适合小型甚至中等规模的应用程序

. _" y2 n! C) x
9 E" S; e& |8 m, H  ^7 F: x
什么是Model 1结构，以及结构中各部分的功能
结构：jsp+javabean

Model1中使用jsp来处理web应用中的视图控制部分
( r2 r" u  X) {- I* p# ?
Javabean收集参数

/ H# K) k/ L" R7 [
4 E4 M: R  w9 T8 E9 P3 l
什么是JavaBean?
! t& T# P* s0 T' @用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。

' u5 N$ I; u, y, N5 f7 u/ M* D, p& P: _

: B% E6 y+ p+ J' V5 [! [4 }JavaBean的规则？
使用get和set方法定义属性

& s) g" P2 ?1 s+ \  Z一个无参构造方法
! e2 a7 ~, @- t' y  a1 y! z) [
( _3 F. D) |, J无public实例变量( 所有属性私有化)



什么是jsp标准动作？包含那些？分别都是什么功能？如何使用？
) y; M  p* D# a/ ~# }- AJSP页面中使用类似于XML的标记表示运行时的动作
$ f2 I5 h$ _. A" j0 m& h7 g
jsp:useBean

; i9 K" G/ S+ n) R) z: }1 D7 Xjsp:setProperty
$ n( ?- p9 v. V# K. R4 W5 ^. l. N. q4 l
* z5 I- ^  n. qjsp:getProperty
5 C/ E% A1 E9 ^- c/ H1 H
9 S# D0 q& _4 \* \( c6 h2 ^jsp:param

jsp:include
% q, F: n; L. P" |/ R- S6 F0 ]
jsp:forward
& a* ?) F6 Q' m


8 [$ b# d0 ^+ G" W& e& y# D用代码示例如下标准动作的使用：useBean、getProperty、setProperty
<jsp:useBean

* e$ A* ^1 ]# X4 Iid=”myForms”
( I$ P* \/ G+ j, g8 P
- f8 I! w5 ~9 }" fclass=”com.base.mystruts.forms.MyActionForm” scope=”session” />
: }' G$ P# V1 ?( G; i% f( d
) H7 B2 o% K7 u6 J# V9 w- B2 K    <jsp:setProperty name=”myForms” property=”name” />

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



描述说明Bean的四种scope
page
4 I+ m/ d" F: x) b8 K! n2 }0 x
request
2 g, V% R9 h0 C
session
" }9 B: F$ k! l- w6 u
application
  l& l; S5 ~5 h) H

0 y" D, c5 }6 s% `" m3 d
描述说明页面上的字段和Bean中属性的对应规则
8 d7 u7 |8 e" ?. U3 }id 指javabean的变量名
9 B& {( n2 G+ ^$ v- y$ g% p9 R
class指javabean类的全路径
& p2 ^% W: \+ m2 b2 {. u6 t9 F
scope指javabean的应用范围

7 ~- s0 [( n: u; d4 l- Yname指所用到的javabean的变量名
7 T( l3 M3 s( L, o% c
6 ]& N2 B8 j1 ~    property指javabean中的属性
# ]  ^7 V1 u" @+ u
' @+ m2 X$ i' S4 o8 j3 C

描述useBean动作的处理过程
  L7 ~$ K- m- A- F  e使用id声明变量

: |5 W% r% l: Y6 b9 M试图在指定的范围内查找对象
( y0 X) ^# E6 f9 W' H. q
) t: f' l! M7 }, X3 e$ ]如果没找到

5 x, W& F( s- T2 g. H创建一个类的实例

6 x& G: b, Q2 z执行useBean标记体初始化对象

, p- q% b6 H% w# l9 c+ e如果找到

+ s- _( P, w+ `4 K; ~     将对象转换为类指定的类型

! T2 o3 n+ Y# U& R7 l
8 |% \/ q' D% k, r
4 E2 S0 ^* l% D5 l1 {描述forward动作的功能
使用脚本代码处理请求时，可用jsp:forward 动作产生一个不同的视图，
# w1 }7 C: K- G1 {  X, H' m
使用同一个request：

- O; y9 m& S$ H8 F( m$ d
' r+ R8 l6 l- D5 \  P8 j
* ?# F( C. [$ s# T, E1 ?什么是Model 2结构，以及结构中各部分的功能
jsp+model+servlet
) L# t; f2 S3 H1 e
1 J: a: L" m4 W7 `: @3 ]' ZModel 2架构使用MVC模式，JSP页面充当视图，Servlet充当控制器
2 `- e3 C- M7 r  R
& d7 g! n' ^3 e, L- B  FServlet控制器：
: B, P4 U7 H. |; T4 ~
8 n! j3 @5 s7 v! J% u验证HTML form数据
. S6 @# T( R9 |6 |; g
- v- C! t$ i5 Y7 n& i: a调用模型中的业务服务

存储请求（或会话）范围内的域对象

选择下一个用户的视图
% x. \& x+ A( {
JSP页面视图：
. ]/ r! }' {! I! P: P/ v: k8 D
使用用户界面（在HTML中）

        访问域对象
1 Y6 u/ h" I& ?. Q

4 ]$ @0 Y: Z7 W7 @! Y1 q' z
# p8 v& c- }5 \& Z# T- G如何获得分发器？分发器的功能？
6 D# M! b( F' H上下文对象中的分发器：
" {5 Z2 ?" E/ f# _2 d9 u1 a, ~
ServletContext context = this.getServletContext();

9 a& {5 ^& j- w0 t% d9 LRequestDispatcher servlet = context.getNamedDispatcher(“MyServlet”);
& R" Y6 N# B8 y; b6 {
servlet.forward(request, response);
0 H! H1 o! G6 z6 g* R: I" `
0 n7 E& f  X7 ~" P; |5 E请求对象中的分发器：
3 r  S$ i6 D9 ]" c
/ l1 F; l( k; i$ ?: H8 u) K9 kRequestDispatcher view = request.getRequestDispatcher(“tools/nails.jsp”);

7 B0 @% V6 v5 l+ q- B  Z  f9 F" Zview.forward(request, response);
  O  F: z7 a+ [; e+ L
可以将请求转发到另一个jsp页面，并保持请求的传递性


5 L. p; H+ a% p$ \* h5 a
Jsp中页面跳转的两种方式？
使用分发器跳转页面
* \# ^" V! _5 ~2 ORequestDispatcher dispatcher = request.getRequestDispatcher(“url”);
7 s& k* O$ G$ e4 T# z/ T/ J- [% K+ I; g
8 w: \8 `: r$ G# ]( g  ^dispatcher.forword(request);

    特点：保持请求的传递（上一次请求中的数据，在下一个请求中仍然可以得到）；
0 y1 P$ l# d" w, w( k
        转发的页面只能是同一个Web应用程序的其他Web组件
* x2 A! C* w1 i1 z. K; |9 a2 ]  m
使用重定向跳转页面
" W1 k2 q; m/ Iresponse.sendRedirect(“url”);

    特点：产生全新的请求，（上一次请求中的数据，在下一个请求中不能得到）；

! K2 y  J( p5 j3 |6 K        重新定向的页面可以是任意的URL

7 q8 I& c% h: r) N

% {( i- V6 K6 F描述Jsp中引入另外页面的两种方法，并比较两种方法的特点？
<%@ include file=””%> 在编译期间把另一个页面完全嵌入这个页面,可以说是一个页面
$ M1 ^7 l/ e. P& @2 r
在这里可以共享变量
, d; w* r7 ^2 r
<jsp:include page=””> 动态的再运行期间把另一个页面加入这个页面,可以说是两个

9 q* ?+ @7 S( P# {. \* j3 U页面，不可以共享变量

# p" R3 _2 _% }1 @1 o
( D9 a3 V. |/ n6 L6 Y- Q4 h: J
什么是自定义标记
3 ~2 X2 n" k9 B4 F8 x9 c8 M- t自定义标记库是一个Web组件，
3 f; r. j5 S+ h+ E
包括：

一个标记库描述符文件（*.tld）

所有相关的标记处理器类(*.jar)
: `2 C+ A; _: H/ W. Y

1 M$ k7 b  E- Z; A+ t
) O, {6 p$ Q5 [( [描述使用自定义标记的步骤，以及每步详细的工作
使用自定义标记前，要拿到.tld和.jar两类文件
- h; @4 s! X5 l: y4 B
' z# j4 _5 x& q( R把.jar文件放到WEB-INF的lib里面。
0 L6 W9 ^' r! S% d* G: w. B把.tld文件放到WEB-INF根目录下。
在web.xml中配置。
<taglib>
6 V/ l0 |0 S3 Z2 v* ]; {2 l
% U; B8 b: r: O! d; Y<taglib-uri>http://java.sun.com/jsp/jstl/core</taglib-uri>
6 U( ^8 A( h3 g( x0 Q
     <taglib-location>/WEB-INF/c.tld</taglib-location>

</taglib>
, x! }1 q$ h1 _& t5 h' y9 i
8 g  A& ?% ?0 x; s( _在页面中引用。
<%@ taglib uri=“http://java.sun.com/jsp/jstl/core” prefix=“s”%>

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

prefix是前缀，用来区分是哪一个taglib
( z% r) X  i& x
9 B, V% J5 a: e$ V. T& v使用标记
* i, |0 t  P( l* q0 T5 q' u4 a( u格式：<prefix:tag名称 属性>

/ ]  V; {8 x3 q3 L+ m<s:forEach >

admin

在tomcat下配置数据源
1、服务器与数据库的连接
* G4 I. @) ?4 y. x
# g+ W0 |9 E. l4 m9 L4 e# D; o  [配置server.xml文件

1.oracle

% d, G  I* V0 B0 @7 K! z<Resource name=”jdbc/company” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”

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

3 d8 E7 e; u+ D, {* W) x7 Q: Yurl=”jdbcracle:thin127.0.0.1:1521rcl”

9 G' f( u: {1 @4 C! n9 N3 _driverClassName=”oracle.jdbc.driver.OracleDriver”
% w$ h2 r+ L3 ^- n
username=”aa”
! R- O: J) T  i- z0 x& v5 h
# ]: K8 _( C5 H; m4 T# T$ Jpassword=”aa”
  {* o2 ^, G2 s4 J% h
6 Z7 D: u, R8 m- |; jmaxActive=”50″
' ]3 u! m( j+ N" K" t( O
; a' z! P$ Y0 n! |  \maxIdle=”10″

maxWait=”-1″

# Y/ |$ [4 d' b  Z( g! x/>
4 y# |0 D2 ]( a7 Y( _
  T/ Z& ?" b+ h+ Y& E2.sqlserver

) Y" ?: N# [- Q<Resource name=”jdbc/webpage” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”

" o0 G0 U) K0 ^! J5 o        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”

" ^4 `) H$ R, I; b8 d7 uurl=”jdbc:jtds:sqlserver://localhost:1433;SelectMethod=cursor;
5 J+ }9 R# g0 }6 U4 X3 g; `& y" L
DatabaseName=webpagetest”

driverClassName=”net.sourceforge.jtds.jdbc.Driver”
4 o- X/ Y1 K% }* i3 Q3 @6 L/ W# |. k- j
8 D2 h9 L5 N" |. e* L$ `' P& Susername=”aa”

password=”aa”

maxActive=”50″
; A" s* n, I, }0 B8 R# Y) l* n
maxIdle=”10″
, a7 E0 ^2 `' ?) _% C  e7 |2 v$ f. x. i
maxWait=”-1″
  g0 {+ ]# V* q; R. Y, F1 Q8 S
% c( E$ z2 I0 }$ o/>

2、配置自己的web应用的xml文件
$ D$ q7 k6 O. t; I7 ]; l: f
( }/ v8 S! O- x3 o  l2 V
6 P: [/ D1 Q% D% m" B- F9 W  D
<Context path=”/eb03web” docBase=”F:/workweb/eb03web”

privileged=”true” antiResourceLocking=”false” antiJARLocking=”false”>
; @- U2 g" j1 v2 s  [9 Y
<ResourceLink global=”jdbc/company” name=”jdbc/company” type=”javax.sql.DataSource”/>

</Context>


( g+ c6 M/ f% N. f# w- h4 X% ?
# F# j% d3 G1 o3、配置web.xml文件
* ]' M, O; `5 t1 J
8 ]: i+ z/ p3 u: W# {, e与服务器建立连接
! J% B, h% q* C' J$ [/ g7 f
<resource-ref>

' [  V, U7 g1 G, d: W7 F4 f! a4 t1 m<res-ref-name>jdbc/company</res-ref-name>

<res-type>javax.sql.DataSource</res-type>

3 M0 X  i& a6 }3 f* n<res-auth>Container</res-auth>
7 X( i5 v- N, U. E  S- |  |1 x
; B% g1 b! y% S# q! l! B</resource-ref>

4、在应用程序中不直接与数据库连接，通过DataSource连接池建立连接
9 W2 M: d1 u  ^( ]
//1.在程序单独用时设置系统的属性，在tomcat下可以不用配置，
, o* _2 u7 V; a- N$ t# u
System.setProperty(Context.PROVIDER_URL,””);
3 k/ c' O: ]$ j
4 Y; t; @  r6 y$ ~System.setProperty(Context.INITIAL_CONTEXT_FACTORY,””);
+ ]# ~/ k; [: O3 d% j/ W7 H; G* b1 [8 J
. @* U, S, M' ~( ?* e//2.创建一个上下文对象

InitialContext context = new InitialContext();
; h- P3 r) F' [3 I1 f
( J5 d8 }) s( w; o( w% S//3.通过上下文对象在连接池中查找DataSource

DataSource ds = (DataSource)context.lookUp(“java:comp/env/jdbc/company”);
" H: t0 g+ Y8 ?
+ r- ^' K6 J9 o& r//4.通过数据源建立连接
4 e7 O2 B. K/ |
ds.getConnection();

admin

ORM对象关系型数据库映射
(Object Relation Mapping)
4 K& M/ O- F3 o' e: b) K
* l8 h# E0 V% [: h4 p% G一、映射的特点
, N' n% D8 P) K) K( e+ R9 n
1.一个对象可以对应多个表

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

3.对象和表的关系不用完全对应
# U8 }% T' y. ^; t2 u
% M- d8 l- R% a3 k# C4 V4.对象的属性的名称和表字段的名称可以不同

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

; }: @0 x# g% D) A: q# y6.对象中必须有主键，数据库的表对主键无所谓

' b# N1 W0 I) c" T) N7.数据库中有主外键关系时，对象中可以有，也可以没有

( P! ]& w6 V  N! W  L( m

3 D# S% f0 Y& ?7 p! H, C二 、有一个映射的描述文件————>xml
( r1 K) l+ Q) i5 |: ?+ H
三 、怎样实现描述文件————>一段程序

对象 映射（mapping） 数据库

user

id=11
1 F5 Z& E( Z2 @2 B. U$ }
) g! D; [" N5 O  i; Z8 G5 L6 iname=”张三”———— > (1) —————> tbl_user(id,name,age,tel,address)

age=25 <————(2) <————
8 o4 o5 S1 L4 Q- J+ f2 Y+ z- I, p. T


5 T. m8 n6 D& s8 ](1)从对象映射到数据库
' U/ T& U2 s9 [
1.JDBC

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

+ x  r2 [! A% x7 y: h3.执行，添加到数据库中


/ I2 e+ ?2 g; p% N
(2)从数据库中映射到对象

1.JDBC
2 a; `5 {) j, K0 u/ I* k
8 m$ X  a: W' A- q0 J1 \- V6 x2 m8 H2.拼接查询sql
3 u. p  x9 L  ]/ t: w
3.ResultSet
0 T$ U: L% b) r& ]
# _$ ~$ }# z  C$ ?. @: P. c  x* j4.Model
2 R5 U& }2 x3 c# c  }0 c
- D' Q# ]7 E& n$ l5 P( J

: E7 u2 ^; J/ n# ^hibernate
开发流程：

# s1 y2 ], D$ i/ H) T是什么？
4 S  x' M5 n2 I/ p: U" H% Khibernate是一种基于orm 的轻量级的框架

+ ?2 L, ?& O) B) B

2 E& a( h9 d, `0 ?7 y0 i5 G! m, O有什么？
1. session 保持连接状态（依赖事务和连接池）
. o$ i$ B# o' q8 V0 D
" k$ \3 j/ J: o5 B3 N& {2. Transaction事务
' n5 j$ w3 c1 [. t& I' v
; ^! R  i1 h- q3.
  |# I6 |8 Y1 a7 q5 m! t5 qConnection Provider 连接池
% t. }6 x( A1 X" c


能干什么？
1.orm
) R3 w; O- M' M/ d7 }
  q2 o; }" ]/ c0 c+ k0 Q2.提供操作数据库的接口，简化数据持久化的编程任务

" @+ t7 i# ~& [: w

怎么做？
8 G& p7 ?; C0 _. Y* ~1.搭建hibernate的运行环境，将hibernate的包和hibernate所需要的包拷贝到lib 文件夹下

2.O（vo）

, x1 ~6 B2 H( R# j0 W5 v  M2 X$ n3.R （关系型数据库中的表）
6 i4 Z, F2 }! D, q8 S
4.配置文件

4.1 cfg.xml 放在classes根目录下，默认名字为hibernate.cfg.xml
1 @" |. c1 V- \
a.与数据库的连接
# O8 J5 ?& F) w* ~' I
b.可选配置

c.映射资源的注册
% v: c2 Z' x2 `/ O( P  T# V
4.2 hbm.xml文件 名字与类名相同 并且与类放在一起

+ J% R  Q6 Q) J+ wa. 对象与数据库表之间的映射
$ p0 _: p( y* v/ y
/ m% L) r- t) J. q9 b9 Fb. 对象的属性与数据库表的字段之间的映射

. t& w( g& M/ \0 uc.组件之间的映射

' x8 B7 z! `9 L" J8 u6 M, n1 Kd.对象与对象之间的关系映射

5、客户端
- q8 G0 M/ |2 |, w' r2 S7 h
1.得到SessionFactory

2.通过SessionFactory 工厂来创建Session实例

. X; Z2 r9 |; g' P3 v1 M3.打开事务
( f5 M/ J- \6 \1 N: ]9 v
* I5 Q8 ~6 R+ B1 A& Q  W5 G4.操作数据库

# F  o# Q3 s2 h6 f# s( D5.事务提交
* T3 o! i: L! j7 v. ]* m; F+ ^
2 ~# K0 \3 H2 J& |# m6.关闭连接

2 W) [2 ^9 L( \7 ~3 l$ l# R1 s4 m运行流程：
1 Q8 A  C5 D5 G" _/ q$ O
整体流程
1.通过configuration来读cfg.xml文件

9 n  f- C! u5 u2 x2.得到SessionFactory 工厂（根据数据库的连接来创建sessionfactory）

3.通过SessionFactory 工厂来创建Session实例
# X  N- w3 \: z8 s4 }
4.打开事务

, S0 \# z$ O) l( S3 w5.通过session的api操作数据库
5 x, i9 X; b& {  ~: l5 G5 u$ G
! y' Y& j# E5 N5 O$ r& V1 ^6.事务提交

7.关闭连接
2 l: Y/ b2 p6 {0 m
# q1 P& A$ t- o, s% v

save
1.to—>po
, E7 V- V+ j  p" @' q
. K. \5 A* E8 O) M0 ]1 p2.根据model和cfg.xml中映射文件的注册来找到hbm.xml文件
* e" }. I0 _. V; z: w, C
3.根据hbm.xml文件和model来动态的拼sql
/ P8 U% n' T3 _  J5 ?$ A" A8 e+ J
7 A- I& o  y8 X! I& x4.客户端提交或者刷新内存
7 X9 N+ [  T) s6 M1 {" u( R6 c
( G+ ^  W; }5 X1 z6 U5.执行sql，值放到数据库
$ Z9 j- e3 S& C
& A5 F. q" V0 O( n( D( I" d
4 i, z9 v4 a$ Q# r/ K
6 x9 o5 S! ], r: Q- t9 ]update、delete
1.根据model 的id在内存hibernate的缓存中查找该对象

/ T9 D$ Q& C3 {如果内存中没有就到数据库中查找来保证对象的存在
: M. g0 R& X# g, v2 H
2.根据model和cfg.xml文件中映射文件的注册来找到hbm.xml文件
$ g  |$ G  @* h1 a0 A6 o
3.根据model和hbm.xml 文件来动态拼sql

( ]% _% i/ }. t; r& W' B$ L2 f7 W4.客户端提交或者刷新内存
! R8 Y7 q7 e1 ?  y% W
+ ~6 d6 f- L5 J9 j3 p5.执行sql

6 D4 t0 }) [; W% L( F

# `! L' W8 }+ v" f+ |Query
load
% t; }3 e% B0 U& C% L& u, L
9 M0 M3 v. {: ?" i' G( o1.根据model的类型来找到hbm.xml文件
- {% ?$ l7 }- N( n. }9 b
2.判断id对应的对象在缓存中是否存在，如果存在，就直接使用，如果不存在就进行下一步。
4 Y+ j. y# C1 `6 D, }4 b
3.用id做为查询条件来动态拼sql
$ t: L$ h* E9 g
4.执行sql 查询（先在内存中查找，如果没有找到（会抛出例外），就去数据库中查找）
0 D% z8 o1 z3 Z/ m7 x: \
5 P# I! Y% o. }* D3 F5.返回一个model类型的对象
  e( i6 _! r6 V0 V4 H
' C5 E* U. Z# I% V( Iget
- a8 R) r) l" O" Z  K2 J" y2 @
6 Q5 B' [- d# x    1.根据model的类型来找到hbm.xml文件
+ ?  G3 l8 W- V1 S% |! A
# i; S) K2 ~- t2.用id做为查询条件来动态拼sql
# u3 |6 G8 D8 H: A( O
3.执行sql 直接在数据库中查找，如果没有查到就会返回null
! {; q) T6 |0 ?0 G* h$ o
( Z' [$ s! L, J- u2 G5 squery
4 n* r7 o  p; j7 Z
( U5 n/ O9 F# H8 b# i' {8 u& T* t1.分析hql语句，得到model的类型

/ P5 X/ }  c7 A6 d& Z, M2.根据moedel和cfg.xml文件中映射文件的注册找到hbm.xml文件
% c! g8 s7 s+ b5 v1 o+ o
" k* \5 s, @1 o2 J9 \5 ~$ K3.根据model和hbm.xml文件来动态拼sql

4.执行sql查询数据库

" D7 R: A6 H" o- U5.返回一个resultset
+ T4 ]1 }6 e; Y. @
6.循环resultset的值，放到model中在放到集合（List）中

5 c8 |+ E  f3 k, K# K  U
$ w& y" [. N9 e& m# p8 x
谈谈hibernate缓存机制
7 }5 {9 S8 U7 Q6 ?6 H6 I
缓存其实很直观的理解为放到内存或者硬盘上的一块区域，缓存就是一个缓冲的作用，有很多时候，我们的数据需要经常访问，如果放到数据库中，不是不可，只是效率上低，如果有了中间产物来代替数据库，就省很多事情了。打个比方，去买酱油，不一定一定要去酱油的生产工厂去买。代码中需要数据的时候，可以先到缓存中查找，如果存在，就直接拿数据，不存在就去数据库中取，也省了很多事。
' X/ @% }6 E3 h/ g9 b0 k1 a7 O

) `! Z3 `* i. j
1 H0 t/ t8 X' khibernate使用的是二级缓存，有两个级别，分别是Session，SessionFactroy级别，一级缓存是Session级别的缓存，Hiberante来管理的，这个我们一般不用管，二级缓存是SessionFactory级别的，可以进行配置和更改，加载卸载，就是我们平时用的hibernate配置文件中的配置SessionFactory的属性。

2 J' G% j% c; A
8 `& @: w1 `" m. j
: M: ?& V- T% {% \2 ~. Y对一级缓存中的session事务进行数据的预存取，数据在各个session的上下文中存在（单例），当session关闭时，就是session.close( )，整个所有session范围内的数据全部清空；二级缓存默认的情况下是不开启的，如果开启，数据库汇总的所有数据都先copy到二级缓存中，这里要注意的是，一级缓存是每个线程下创建的session缓存区域，可以是多个，二级缓存只有一个区域 ，画个图比较容易理解。


/ g4 |7 ]! D# n
| 一级session缓存| | 一级session缓存| |一级session缓存| |一级session缓存|
3 r2 F9 e! i) q1 R: H6 D& R. C
2 r0 y( c( y& c- z$ H, a! W| | | |
* @' |( c0 m( b% Y; d; b3 r
| | | |
% e5 F( g% J7 H3 i
—————————————————————————————————

1 S" {9 K- H9 ?3 W: z' w! p# _$ ?sessionFactroy级别的二级缓存
' r% ^0 Z9 w+ `' E2 k
——————————————————————————————————————-
1 Z2 \$ e" Q# p1 o! j- X
|

|
+ Y9 |" F+ H; i1 \. x6 b
4 ~0 e& ?4 T  z( K7 v% l) P* x" O|

2 c  t* o/ z# C——————————————————————————————————————

# e  d7 U. V( }- P, oDB

! X) F' b: S1 O' ^. N—————————————————————————————————————–
3 c; e$ ~, b2 g+ R

admin

Spring

• 是什么？
  ( `0 E  q; l# k; G1 M0 q1 ^- ]
  $ f* \( I- q. D  o* U, Z7 h

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

7 a2 f8 }) @) b; d7 I8 x

• 有什么？
  1 c& Y# E! N, v! b9 |$ I. J% U; l( [
  

每个包的功能：

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

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

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

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

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

AOP ：面向切面编成

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

• 能干什么？
  
  

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

5 p+ n% p  y+ R* l; p

• 怎么用？
  
  ) J4 Q' E& P* C2 @
  • 搭建web工程，引入spring的jar包
    
  • 在web.xml中添加如下配置
    
    
  
  - D. ?' y! Q: ~
  

            contextConfigLocation
; r" M1 N$ ~/ q) z$ a( v

            classpath*:applicationContext*.xml

   
. L: \) j1 n+ _7 c* E' B% U" X5 i

        

            struts2
8 p, b, i) B* k' e7 A+ Q4 l6 S+ _, k

            
3 M- E3 C( n4 u& G

                org.apache.struts2.dispatcher.FilterDispatcher
, H6 Y' O5 d1 e% N, g- ]

            
. G7 b" b' S# M# ]$ [

        
# v- K6 R& [' W7 @" o7 L

        
7 }  n8 [: l  {1 S+ S

            struts2
9 O7 U6 L7 s# a4 j3 R

            /*

            

                org.springframework.web.context.ContextLoaderListener

            

        

• 部署
  
  ' S! U% U3 T/ O. n: H1 w

• 容器和bean
  

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

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

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

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

0 |7 b7 P: ^  U/ ~+ j5 |* F

• IOC控制反转
  5 }" \% C: }' Z' [% I6 K1 i
  
  
  ; F9 h* D, u3 e
  - o# K$ x* E- t7 n2 X8 n
  从前的应用程序想要得到A的实例他会直接主动的去拿，当用了sping后，应用程序由主动的去取变成被动的等待，由spring来控制应用程序所需要的对象
  
  
  • IOC的优点
    
  1.可以通过IOC来获得实例
  2.可以通过DI来获取注入的资源
  • 配置IOC的原则
    / \4 X% U2 S( g" |1 k
    • 一定是可变的资源才采用依赖注入
    • 一定是层间的接口或者是模块之间的相互调用才采用依赖注入
      

• DI依赖注入
  

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

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

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

例如：

在配置文件中

3 _+ F" `! r( [( H5 D
/ U; m; r7 `0 e

在应用程序中

Public DBDAO dao ;

Public void setDao(DBDAO dao){

This.dao = dao;

}

3．构造器注入

- }2 B! L6 S( {: q6 w6 Y5 y% T

4．ref 表示参照其它的bean

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

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

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

6.lookup注入

7.singleton

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

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

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

8.DI的优点：

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

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

, M' E0 V+ F, T

• Aop面向切面编程
  ) s, c% l0 C) D3 n# f
  * D9 L2 f4 ^2 d. X

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

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

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

3.AOP 的概念
+ U8 J# V9 t; ~0 l3 N

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

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

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

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

5.引入 ：扩展的功能

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

7.aop代理 ：实现机制

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

4.AOP的事件机制
4 B0 l3 I3 J2 A) A% t. J5 l- I! z

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

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

3.找到切入点

4.确定连接点

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

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

7 c: ^2 ]2 ]  J% T( ]5 e

' R/ @. z& p" x- e9 n


6 K3 D! S' L; K: \
5 I$ ~+ {6 q: l! H: d8 Q2 ~

5. AspectJ

5.1.在xml中配置比较烦琐
/ V. A+ l4 m$ P: ?  l' J

所有的入口必须从一个代理（ProxyFactoryBean）开始
8 K) N' w, |: W6 i4 m1 A

1 ?6 y( F6 s. E% o( _5 ^& a% m

         


. F( V$ p3 O" T- m; r3 m         

        

        

/ e- F  j; h! A% {/ z# Fexpression=“execution(* com.javakc.aop.MyTarget.t*())”/>
* c" f! x* ~: t" k( P

        

        

   

" O$ [# ^; O8 s& C! [

5.3.使用注解的方法相对简单
. E  G# s9 S: G

@AspectJ的基本语法
& m) U: [& e2 V- O, F! {

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

直接在类上定义@Aspect

2.@Pointcut声明切入点
2 }" }4 B/ C* \4 l' c3 b

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

2.2、可以使用匿名的pointcut

2.3、执行切点的几种方法

2.3.1 execute（public * 包结构.*.*.（..）） 可以指定到具体的方法
+ J: w! s4 }6 {' G

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

within（”com.javakc.spring..*”）
1 P% V/ m5 V* ?) S

2.3.3 this 指定到实现接口的所有的实现类
! B' L6 ^: |7 K. s% y) ]$ _

2.3.4 target 指定具体的实现类
7 s5 y; [; O) K6 H3 s% I1 C0 h. Y

5.4.advice的五种类型的示例
' C& m# Z( h( b9 I+ N( i

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

5.4.1.@AfterReturning(pointcut=”” returning=”retVal”)
5 z8 h; S0 ?6 `2 y' g# {. H9 w

追加的方法的参数名字一定要与retrning的名字相同
9 Y$ x. |1 e# g, y) K2 _

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

pointcut指所要监控的目标对象的方法
) K* ?* e+ {" \6 Q. L' t  {7 T

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

完成追加的功能

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
- {: L$ h) l+ l0 K% _8 F! S5 }

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

(2).

     2.直接引用匿名的pointcut
& p# n) z/ i0 Z  S- U0 T

     (1).@AfterReturning(“execution(
4 m- u! y5 s. d" i- O

* com.javakc.spring.schemaaop.Api.test4())”)
" P" R9 ^1 ?# P5 O  Q1 a, L0 W

     (2).@AfterReturning(pointcut=

“com.javakc.spring.schemaaop.TestPointcut.t4() &&
9 d. t% Q( A  Q! j! f2 C: E: N

args(str)”, returning=”retVal”)
+ _- ]) \0 ?# N4 [0 k$ e! l

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

    }

5.4.2.@Aronud
/ n' f3 W) _3 v! q5 t

     注解@Around环绕追加功能；

     在执行目标对象的方法的前、后追加功能；
+ T- x" M4 i/ i% f4 f8 ]5 z6 d

     必须有参数；第一个参数的类型必须为ProceedingJoinPoint；
: @* Q' i  U+ |. }

     通过ProceedingJoinPoint的实例的proceed来调用所监控的
; J; \) j0 ^; H6 b$ {

目标对象的方法

     1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
# B' @5 c2 z# M4 h

     (1).@Around(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
( j3 v2 {$ {+ t

     (2).@Around(“com.javakc.spring.schemaaop.TestPointcut.t2()
' F& P& M, s  G8 C

&& args(str)”)

2.直接引用匿名的pointcut

     (1).@Around(“execution(
4 a) W7 _3 r( {* x$ P2 U

* com.javakc.spring.schemaaop.Api.test1())”)
( ^5 Z, S4 H+ _2 E0 l7 {3 M

     (2).@Around(“execution(

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

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

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

public void testAround(ProceedingJoinPoint prj,String str) throws Throwable{

    System.out.println(“around1==========before1pointcut==>”+str)
) S. p2 Z$ B' P, r7 l

        Object obj = prj.proceed();

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

    }
3 `& [! e# [+ R) Q9 \

5.4.3.@Before

注解@Before在执行目标对象的方法前追加相应的功能
$ f% A& N; K8 r" E9 C" G

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
2 K. z* {( ~3 \8 Y& s6 K" ?

(1).@Before(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
+ A# g+ h0 b6 s5 Q2 O

(2).@Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
7 H/ R6 I# U" f3 R3 @8 K/ |

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

2.直接引用匿名的pointcut
" ~- o& \4 P  C* Z% _

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

(2).@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
/ ]0 ?8 R0 u' e! [- a( e* \8 w

注意args后的名称与参数名相同
$ U' P$ _  P& A" l

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

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

public void testBeforeParam(String str){

    System.out.println(“before1=param=>”+str);
& h$ E1 w4 N2 o7 A1 j

}
% r' e6 u7 D! C$ h/ y# ^. d

  t8 u5 s  s2 \" Z+ e0 Z

5.4.4.@After

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

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

     (1).@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
$ C9 t- J2 Q/ \5 K* _

     2.直接引用匿名的pointcut
# B4 t7 Z/ ?# j9 r

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

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

    public void testAfter(){

    System.out.println(“after1== >pointcut”);

    }

5.4.5.@AfterThorwing

• 描述一下spring中BeanFactory和ApplicationContext的差别
  
  ; M& _* x  M  G! y( d3 a

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

, r8 h( Y! I+ X: }; [

• 谈谈spring对DAO的支持
  
  & i: s& i0 J5 i, H) W

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

简化 DAO 组件的开发。
/ ]+ W9 O- c0 _- G  z0 B, eSpring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法，用来简化代码开发。
5 [/ S7 B% Y9 ?  ~3 f1 I  T

IoC 容器的使用，提供了 DAO 组件与业务逻辑组件之间的解耦。所有的 DAO 组件，都由容器负责注入到业务逻辑组件中，其业务组件无须关心 DAO 组件的实现。
3 l9 H9 _. x1 z' P" m, ]" x

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

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

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

3 [) E6 m0 [- `2 ?! d8 H

• 谈谈spring对hibernate的支持
  " r& o$ W3 G( @8 R2 F: L
  

在所有的 ORM 框架中， Sping 对 Hibernate 的支持最好。如 SessionFactory 的注入、HibernateTemplate 的简化操作及 DAO 支持等。另外， Spring 还提供了统一的异常体系及声明式事务管理等。
$ b7 x2 n. c( {/ |" @5 c

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

1、通用的资源管理: Spring 的 ApplicationContext 能管理 SessionFactory，使得配置值很容易被管理和修改，无须使用Hibernate 的配置文件。详细配置如下：
9 @9 n: i2 P! |' d! {( C! V" a

' ^9 _6 Z' O# [5 @

        class=“org.apache.commons.dbcp.BasicDataSource”>
5 v) Z4 n# Z: m0 m' ^( B1 r

        
# C4 A: X; B! p. v

            oracle.jdbc.driver.OracleDriver
5 r: L4 i3 o, f

        
6 j3 g& P) B5 _6 x$ h9 o" i

        
4 Q8 j2 T1 M. L" {: h1 G4 z# E

            jdbcracle:thinlocalhost:1521rcl
* ]1 b0 d) i4 |7 B" b+ b

        

        
! X3 r& t9 Q2 J( k& g; e! m& i: x

            javakc2
; i. {( |; g$ K7 L! I- \6 c. e

        

        

            javakc2

        

   

9 W! D. z% D  y7 X, W

   

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

        
* C5 y- R3 n3 W" U$ `& t# Q" a% c

        
; w/ ~. W9 {: p6 A% ~4 ]8 C/ {

            
' b2 v6 I, O2 T" P/ D/ Q

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

            
* E6 f: K# I8 {+ |9 G* y" N; f

        
! T, T) F3 D6 y: l2 D4 s

        

            
( x2 t0 `4 Q+ j5 Z$ h) R: o

                hibernate.dialect=org.hibernate.dialect.OracleDialect
, y  ?: h5 e0 L7 Y) I4 _& e

            
9 q- \8 c+ K. B6 S

        
+ q' S& a# t; w

   
% R  d; s% H0 R9 c- t4 P- [$ T0 ]

   
. B/ V7 }  ]1 @8 _

        

   
; u' `; _* S. M4 D( k" d

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

   

        class=“org.springframework.jndi.JndiObjectFactoryBean”>
$ v6 e; K% i1 K  p, A- R0 j

        

            java:comp/env/jdbc/myds
2 g" L, o- h4 {% e

        

   

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

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

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

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

   

        
1 p3 B$ J5 N! H* C; P7 S( Q7 S% v9 U

   
. k4 M0 r/ D# a* z, f% G" j6 C8 ]) E: L

   

        

            
, p" ~6 I- P" Y* N

        
2 B: _8 N+ Q* r8 d  d

   

& u, k$ Y: P5 l( c" U* g3 v6 ~

   

        

        

   
" `4 g: o  i6 l8 z) Z2 C& ~

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

0 E- Y7 Y9 J9 {" }, |% U1 L" v

Spring2.0之前事务的写法 ' A% L4 f+ X) V" N6 u  _: E         class=”org.springframework.transaction.interceptor.TransactionProxyFactoryBean” : k$ n2 ~& P) z         abstract=”true”> $ a. e; k" v! n) @( N / j: ?5 s9 \& ?6 M2 g. ?0 M                PROPAGATION_REQUIRED,readOnly                 PROPAGATION_REQUIRED ; K7 f9 c4 h0 Z# C # \2 Y" p1 U  t. {* O 9 _2 R7 y( u8 W) \ ; V5 U4 E9 b8 J

3 \! d3 @, y6 B: N

• 谈谈Spring对事务的支持
  
    u  t& G. R) H5 M4 @

! U% J1 }1 v& @* r9 J* K# c1、声明式事务管理：

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

2.做法：

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

2.2

2.3 注入数据源

( i5 ~& x- F1 K( U1 U7 ^


0 g8 R% g9 {  f: ^% C# c

4 P( f: L( s4 N) Y7 y

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

! W& D9 K1 ]3 k4 ]# k

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

8 Q# |3 u( Z" T: B; T+ t3 J( _' _

8 i+ j3 k1 j: D5 G6 ?3 p! u
- s$ t5 ]( l/ C( u- I$ y2 G

2.6 定义切入点

, `9 }; u7 D$ j+ p" L  f+ T$ q4 ?
6 s' m4 j) u0 U6 V8 L+ y

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

1.注解@Transcational

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

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

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

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

如何在Spring中使用JTA的事务：
/ b; h* b5 W" x, R

  C' v1 p2 k$ @3 H

admin

事务
ACID
（1）原子性（A）：一系列的操作具有不可分割性，要么成功，要么失败
6 T5 Z1 r: x9 U: k! Y9 T9 `
: V" s# o( b8 o) F" C（2）一致性 ：操作的前后满足同样的规则，保持平衡。
+ }: E$ f" n9 M4 q/ |
$ x: b) q6 l- Q4 ?; n8 G& m% R（3）隔离性 ：在事务运行的过程中。事务内的数据对外的可见性和可操作性（必需由数据库的支持）

6 W) K/ W0 b% X; P1 Z0 t（4）稳定性 ：保证数据在事务的操作的过程中不会遭到破坏，而且是永久性存储的
6 q: k% a; }$ @$ G8 q! f2 @' i" A

3 V  r* a6 L. y: m, t
事务模型
（1）经典事务模型又叫平面事务模型（JDBC） 事务不允许嵌套

（2）嵌套事务模型
5 p/ w  ^: J+ x3 n* d
4 q0 ]8 z# ]9 P) T2 v) V
& e+ c1 k: F0 h) V$ G
事务的两种方式
5 |' x* Q7 y. n（1）声明式
6 B1 q( \* c* \% y5 |9 V  G% q! R
5 E8 W+ w5 h" [& d6 t/ z2 I% Q在配置文件中设置以下6项

（１）.required

6 q& {) s2 D2 m9 u如果客户端没有事务　在bean中新起一个事务
2 n9 j* ^% `3 o
如果客户端有事务bean 中就加进去
- w9 t. o8 o, T# H
+ K) u4 o/ V' d: Y* k0 W; ^2 a' F(2)、 requiresNew
+ a* C7 e) y, u1 a
不管客户端有没有事务服务器段都新起一个事务
2 s8 S6 n7 q- q0 ?5 v# s
( j5 o3 \# ]) W7 F6 K+ p$ G+ V4 [- K如果客户端有事务就将事务挂起
8 ~! e/ a0 U& f5 t7 a1 a
8 e' m( E. V1 Y3 _9 C; o(3)、supports

如果客户端没有事务服务端也没有事务
; D" S" A+ R- ^6 s1 W
% n$ P  y/ @* o& ^如果客户端有事务服务端就加一个事务
1 \- w, N" g+ X9 @  y
& S" J. c6 j  U: y& t7 M: n(4)、mandatcry

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

如果客户端有事务服务端就加事务

: G2 @  u# w1 L1 W4 e3 U(5)、notSupported

不管客户端有没有事务服务端都没有事务

. N5 k% W- t6 }, S# p如果客户端有事务服务端就挂起
+ i! c$ v5 W0 v" r
. Z3 O; x& P5 Q/ k! u4 i/ n( D(6)、never
7 V- {) r: T2 ~
; \( w; v* p; {9 v$ g3 {0 Q0 ?不管客户端有没有事务服务端都没有事务
* w- n2 ~- q9 H' T) O
. O# `$ r) T. U# {如果客户端有事务就报错
$ w! U- \  w$ Z2 _' i
" w8 {: G* j$ v. T0 F5 F（2）编程式事务
1 K- r' N8 `* Q$ O/ o6 D, G# q' R
Javax.transaction.UserTranscation

- u7 i- Y- v! {, qJTA 事务可以精确到事务的开始和结束

2 c2 z( o7 p5 K1 n. Q" R- n

' @: z$ e+ q9 Z! u$ Q/ t) ?5 E事务的隔离性
4 s" B/ i7 ]1 Q, X. HRead-uncommited

读取未提交的数据（基本上没有锁）脏读，存在不当读取的问题。
! u3 e* B- s% J* K
, Y/ f4 C1 t; ?, L& i4 A) s$ Q7 [. A* kRead-commited

3 O2 v- |( a6 r读取已提交的数据（行级锁）

7 b0 D2 y5 e0 p* `4 B4 m无法读取已经写入，但没有被提交的数据。

( b! K5 o; q% R4 XRepeatable_read

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

不可重复读（行级锁+不允许修改/删除）

* Z4 D" E, `. ?9 |1 ESerializable

) P( c/ N' M* q5 f! O+ ?幻影读（表级锁）
$ _; S1 f4 D3 X- W- t  I8 @

6 o# W! P  p* Z; Y
0 t" h) H& v, ]4 I/ Tstruts
开发流程
% q! Q# @2 j7 `- F. x8 g; D# p
( o, \) o* s! o+ G$ N1、创建表单
/ r1 W! m; q, |6 }  V
2、从表单中获得输入
& z; J  L: p7 j( m( l4 x! `
; l/ M+ b7 p; `: ~3、处理输入（业务逻辑）

4、根据动态输入改变输入流
* n. I! A* A& R
要完成上述四步，我们需要创建

1、一个ActionForm
* z0 m' n6 L4 J, ?0 B% R
; w/ ]) J4 ^& I2、一个action

- x' u1 d, \$ p& R% F3、一个配置文件struts-config.xml

4、创建页面

0 V, a* z% L" Z- m; f" @创建ActionForm

1、写一个类继承ActionForm
- O+ Z; }$ d+ C% c
! A/ W2 v' v2 g; E8 q2、私有的属性

: J& j$ R: `* t4 c+ i" t  R' v3、相应的get、set方法

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

# H$ a; _8 ~3 u: |  G创建action
+ z5 A! s+ h3 }$ x
' `  `# Z! k+ f! w3 A1、写一个类继承Action
5 U( b, J0 E' n4 w, G7 k& h  x
2、实现一个公有的方法（回调方法）

public ActionForward execute(ActionMapping mapping,

ActionForm form,
) ~: F4 d9 p$ m  r1 G
HttpServletRequest request,
+ X1 R$ q, W; s% s! {7 t) h3 F
! N3 |3 Q0 ~; S5 N1 u- u2 |" zHttpServletResponse response)
( H8 M/ h* U) E# w3 w0 p6 M1 E' c
{
5 W! X6 ]; Z  v
3 Y( I" y# t- L1 q0 a# y4 X//1.收集参数
  ?8 s8 E7 i1 r8 B9 P7 @& B* K
MyActionForm myForm = (MyActionForm)form;
4 n! I1 ?% S7 c
//2.组织参数
# O: c9 k/ F$ }3 p* H6 }7 \- ]

) R' G+ X. K; c8 @
//3.调用逻辑层
1 }8 E4 o: u8 X/ S  j
boolean flag = true;

//4.根据返回值来跳转到相应的页面

ActionForward af = new ActionForward();
4 J% \4 ^+ B* G! N& l0 i( q
& ]6 P$ E" J+ r% I. }7 Wif(flag){

af = mapping.findForward(“1″);

}else{

af = mapping.findForward(“2″);

# d9 j& W9 b7 I6 ?}
0 p$ I& o3 }1 H2 K9 X) x
! z8 s+ U4 z+ D" X; |return af;
/ I4 a6 Y: v4 M# M2 [
) z4 {. a, J& n% r( w* b5 |}

! t( x9 ]8 C+ V9 t: O" B9 d配置struts-config.xml文件
& O+ s% Q  {2 I, l: |  `8 u! X2 l( U% J
+ m5 [" k  i* f5 X. A  U) P0 ^1.<form-beans>
  ?: Y8 m4 X8 q  U) V
; H( h; K& E0 T# t/ H' g% R4 A<form-bean name=”myActionForm” type=”全路径.MyActionForm”/>

<form-bean />
  _6 A( i( @! t* }* C  y, L
0 x! C) i( P8 d( \+ G! ^( v</form-beans>
4 V5 f7 E) c* A, i% l
2.<action-mappings>

<action path=”/sll”

" R8 X0 \  V/ `( ~9 gname=”myActionForm”
) y8 o& @( a% b  i
type=”全路径.MyAction”
' D) V$ B& O7 j" k
6 b, P/ X2 i2 Dscope=”session”

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

* e5 K; m3 l) q# ]/ P& T! z<forward name=”1″ path=”/1.jsp”>
1 m- X3 L4 t9 h- q7 J! u# w; [
<forward name=”2″ path=”/2.jsp”>
6 j5 B4 [. [3 F) M  Y
</action>
' _5 D, ]6 b, f. ^+ e: f
4 j- }9 N& E0 Z; j8 m( R( g& w</action-mappings>

步骤:

1.创建一个空的web应用

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

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

% l" S- H: o0 k2 s$ S4 A& B6 {4.配置struts-config.xml文件和web.xml文件

5.在页面引入tag文件uri

STRUTS运行机制
( V8 i# x- h. S* B+ K2 C' w( u3 u
' n$ _( Z/ ?7 I. G3 X* H! j4 j1、界面点击产生请求

2、容器接到请求

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

4、ActionServlet的处理
, C, h5 v; @* _% {
4.1 读struts-congfig.xml文件形成ActionMapping
' s+ o! ?+ e4 [' j
4 a2 G; w  k- y7 ]/ V, ]/ x5 M3 h4.2 通过path 来匹配Action类，通过Action的name属性来匹配ActionForm类
& g- {+ z; c" |% E, G
& V7 l+ k) y7 [2 Z4.3 通过反射机制来给Form添数据

4.4 由ActionServlet转调Action的execute方法
) n7 j$ y, u7 a8 b& Q: p6 A. @
+ P( ^7 |+ \8 I5 l4.5 得到execute方法的返回值，跳转页面
3 V0 @, q# v( V% i. `/ ^
2 Z$ {6 U3 \: d& ^4.5.1 RequestDispatcher
. U6 s/ T8 l; Y' K" j8 a' a9 t
9 l6 U2 T# w# b$ l2 B8 e# R4.5.2 response.sendRedirect(“list.jsp”);



2 p6 L3 ?. {" e$ Z5 C进入execute方法

, S; |: c. c7 A1 收集参数

& q* x4 ^# I3 k" w# `0 Z, G5 Q2 组织参数
( N; D/ h4 ^9 `2 U, q
3 调用，逻辑层

+ H+ k5 ^) C" u" K, c; F4 返回值
4 b. p3 ^/ O+ x
2 Q0 a+ Q$ A  Q( L# z' x4.1 选择下一个页面 （ActionForward）

4.2 把值传给下一个页面

4 L' s. z; @4 c' S0 m

5 k; a- M8 ^$ G# S# M1 \  Y比较struts和struts2的不同
7 }  m& \0 y4 o
Struts

Struts2
6 B# Q/ `' @; G* v% x
组成        五个部分：ActionServlet，ActionMapping，AtcionForward，ActionForm，Action        十个部分：AcionContext，FilterDispatcher，ActionMapper，ActionProxy，Configuration Manager，Action Invocation，Interceptot，Action，Result，Taglib
$ a! t0 I% J) `# q8 ~url        .do        .action
, C# p) q# N4 E' s+ J! `. p分发控制        AtcionServlet        FilterDispatcher
收集参数        利用JavaBean技术，将数据封装到ActionForm的子类中；
) r! v1 |( N2 \$ n, {一个Action对应一个ActionForm的子类

/ y* h9 p0 o, r# \. z" E使用拦截器将数据封装到值栈中。
使用域模型，一个Action对应多个值栈中的Model
" _! A! o0 ^! S3 b
读取配置文件        ActionMapping        Configuration Manager
拦截器        无拦截器        执行Action前后有拦截器
返回页面        将字符串封装到AtcionForward，进行跳转页面        Action中直接返回字符串，通过Result跳转页面
: R0 L0 A$ Z% L3 ]( |页面跳转方式        两种：dispatch，redirect        三种：dispatch，redirect，chain
* }3 O( ^) v0 _% {3 E& }2 ?值栈        无值栈，Action通过在request范围内设置属性，向jsp页面传递数据        有值栈，Action和jsp页面通过值栈传递数据，jsp页面通过OGNL取得值栈中的数据
配置文件        struts-config.xml        struts.xml
. D5 ]0 ~0 j* U+ ?- B4 x中文问题        不能解决（需要使用filter）        可以解决中文问题：
1 _3 T2 Y2 [$ {" h+ T- H+ I4 A* H1、在jsp页面添加Meta；

$ X! l% G( x7 [9 g; g$ G2、修改struts.properties中的设置。

admin

其他开发工具和技术
Ant
Ant是基于java的批处理工具

; X. X" b2 S/ {- V3 Y; ]7 i一、配置ant的运行环境
1 R% V% J7 Q0 S0 w8 \
1.将ant的bin目录添加到path中

2.配置JAVA_HOME

2 o& F' E" b% `7 q4 A' K3.配置ANT_HOME

$ W9 q8 @$ I) a; l, P二、配制build.xml文件，该文件放在应用程序的根目录下

编译java文件

执行java文件
$ e, `  v8 f. N* C$ y& l& e% O0 V
! }0 N; a% {% G( r1 i- G7 M# u+ mcopy
$ A  v4 D+ h% g& z. g
删除
, q* p6 y8 B% O
打jar包
4 X1 f, v7 |, m% d) B* S9 D  I
根据注解生成配置文件
% C4 p/ Y( Y) F) F" R. F
: R* C, K: X4 MXdoclet
( T& X7 R4 n$ g: f通过注释生成一系列文件的工具（txt、xml、java、html等）

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

1.在java文件中写符合要求的注释（将hbm.xml文件的内容搬到java文件中去写）
4 u* U1 w9 y1 M! R. I
1.1 在类的上面 写与表的对应

7 x1 A2 E7 I! \1.2 将每一个属性的注释都写到get方法的上面

' \$ d& B( }% j; h. q2.在ant中引入相应的task来驱动xdoclet
: J! O6 B: N% x


log4j日志管理
! }# a* e# C5 M) _- \+ R, b1、是什么？
- b" x- f" ?) U
. z; T& j! [3 S在开发期间用来测试、对整个日志信息进行管理的工具
: U9 t, k$ x9 a' ^3 e
  Q+ L$ }' X1 C; ]( B& Y2、功能
% ?: q' c6 u; r- u) V* {) L
: M5 \2 j/ ]  O) G) c$ b1.控制输出的目的地

2. 控制输出的格式
6 A- ?( D" K. b/ D
! B' H* r8 n' s) z9 x9 @, I3. 控制输出的级别

3、日志的级别

* f/ P. Q3 S1 x0 x' k5 I( h. x1. debug 调试

2. info 给用户的提示信息

( p& R: D; I7 J0 Q$ w  Q9 Q3. warn 给用户的警告信息
5 n) {3 ^8 b6 u2 x
4.error 给程序员用来调试

6 ?1 Z4 N  m) }% I( ~0 FDebug—-〉info—-〉warn——–〉error
" [1 K# c* ?9 X! q. w
4、配置

: R$ d3 z* D! y0 t6 r2 \, Z) j, o1.配置级别
! U. h( x8 x- S: S- x# J, S
2.输入源 （控制台和文件）

0 h0 p0 L  @5 X; U! x$ F3.可以进行分包控制

Log4f.logger.包结构 = 级别

5、使用

. [. K# Y) Q2 o- k- e0 n& z5 CLogger log=Logger.getLogger(Test.class);
( Y* c! R, R, w8 d
    public
void t3(){

        log.debug(“this is debug”);
% \- d7 J$ p" o# X4 R, D
4 x* z" ?/ F/ D6 t" i        log.info(“this is info”);
' X! R$ {$ y# j! B  s
        log.warn(“this is warn “);

        log.error(“this is error”);

    }
/ V1 A: s) p7 ^+ J& j
* l  }5 w0 @0 B+ e. m; \, JJunit
# j$ o2 A" @+ ]4 s/ T, f+ S4 @1.是什么？
3 s% t/ B4 l% p" E& f
  u3 ^, U0 d. A' X+ v单元测试的框架

2.怎么做？

写一个类继承TestCase
; k6 x+ {, |! w0 R4 V- ~
* h" n$ a1 R; ]* t! C" j: y测试的方法一般都以test开头并且没有参数
6 e" m$ w5 g( v( X" D
5 ~$ j0 t$ f0 w在测试方法前执行的方法public void setUp( )
6 q% u; k. h; K
在测试方法后执行的方法public void tearDown( )
+ ?; |+ l  ~/ ~! }' }0 N% g
error和故障的区别

error ：代码有问题

4 m4 D3 W* l$ |# W故障 ：逻辑有问题与祈望的值不相符合

1 W* j' T: T* I, R生命周期
% _' T+ e, i7 |
% s0 g. f, m# h, I5 s* q测试—〉SetUp（）—〉testXX（）—〉tearDown（）—〉结束；

TestCase套件
6 e/ B3 K4 z+ M" R
( x4 H# `( `" ?public class MyTest{
$ t9 n% Y9 \* s/ [) X: X
* K8 z7 j- r3 M        Public static Test suite(){

$ B, {, T! k) N) c4 b$ ?3 ~TestSuite suite = new TestSuite();

# s7 a1 S9 a, d5 J6 qsuite.addTestCase(Test1.class);

suite.addTestCase(Test2.class);
# N. P, ?+ v5 j, n* y
0 K1 T& m# a, k}
2 |6 {0 i8 S+ z- p$ z
8 N) n1 s& p4 q2 Y- ^- W0 ^}
' Y7 m7 j' H: G$ D

  x* \- S- ]0 E& l0 A7 M
$ ]6 [7 I- J& n2 jAjax
是什么？
3 H% r7 U' ]2 ]$ u! R9 jAJAX即“Asynchronous JavaScript and XML”（异步JavaScript和XML)。是一种创建交互式网页应用的网页开发技术。
  f$ D  a2 i. L+ W
2 h5 w/ o/ F% s+ a; m无刷新页面。

有什么？
AJAX是多种技术的综合，包括JavaScript、XHTML和CSS、DOM、XML 和 XSLT、XMLHttpRequest。
- N4 {3 S, t6 B! ^2 G) [2 G
能干什么？
使用XHTML+CSS标准化呈现；
使用DOM进行动态显示及交互；
$ Q$ g  ^8 \2 o2 W) R; B* Y( O( v使用 XML 和 XSLT 进行数据交换及相关操作；
0 }1 c8 a( s" L+ @* V使用 XMLHttpRequest 进行异步数据查询、检索；
使用JavaScript绑定和处理有所得数据；

传统的web应用允许用户填写表单(form)，当提交表单时就向web服务器发送一个请求。服务器接收并处理传来的表单，然後返回一个新的网页。这个做法浪费了许多带宽，因为在前後两个页面中的大部分HTML代码往往是相同的。由于每次应用的交互都需要向服务器发送请求，应用的响应时间就依赖于服务器的响应时间。这导致了用户界面的响应比本地应用慢得多。
" n, h& k; x. n0 r
; w: u4 q; K* B$ ?1 X# T8 L7 ?与此不同，AJAX应用可以仅向服务器发送并取回必需的数据，它使用SOAP或其它一些基于XML的web service接口，并在客户端采用JavaScript处理来自服务器的响应。因为在服务器和浏览器之间交换的数据大量减少，结果我们就能看到响应更快的应用。同时很多的处理工作可以在发出请求的客户端机器上完成，所以Web服务器的处理时间也减少了。
% P0 p  B) Y+ E
4 |% T! ^1 s" W; @' A# a5 T: f使用Ajax的最大优点，就是能在不更新整个页面的前提下维护数据。这使得Web应用程序更为迅捷地回应用户动作，并避免了在网络上发送那些没有改变过的信息。
! ^6 W; F, I9 L5 i
对应用Ajax最主要的批评就是：
  ~) |8 I! J/ H% _( E, a. ^6 G2 H1 它破坏了浏览器后退按钮的正常行为，就是用户点击后退按钮后不能看到之前的数据；
4 j; {0 @( }) m2 _& y1 R2 一些手持设备（如手机、PDA等）现在还不能很好的支持Ajax；
3 用JavaScript作的Ajax引擎，JavaScript的兼容性和DeBug都是让人头痛的事；
4 Ajax的无刷新重载，由于页面的变化没有刷新重载那么明显，所以容易给用户带来困扰――用户不太清楚现在的数据是新的还是已经更新过的；现有的解决有：在相关位置提示、数据更新的区域设计得比较明显、数据更新后给用户提示等;

怎么做？
<script language=”javascript”>
: I$ c4 }% z' P# k, c; v" o6 s
. O" S) f8 ~) E$ M* ]' uvar req;
/ I8 d$ a, b  l1 ~7 l0 a# l
function add(){

& X$ ]2 ?- }4 W2 w//1:创建用于传输的对象
& K4 u. p: P) O0 y: n
req=new ActiveXObject(“Microsoft.XMLHTTP”);

// 声明返回后，处理数据的方法
$ s9 Y2 e7 v  ], x/ p$ ^
. g9 E. t; c8 w0 rreq.onreadystatechange=manage;

4 `% @# g$ X; i& r% L//2:准备传输的内容

, l; p, q) u( `! p# fvar str=”test1111″;
, E8 h' Y& Q' _8 X) @$ t; l  \! a
//3:发出请求
4 e0 b1 W% K9 s& k1 v& z( e, o
, ~) c' Y& J1 {4 e; R% b, Preq.open(“GET” ,”/others/ajax/test/t2.jsp?str=”+str);

req.send(null);
0 Q* l; f# F: ^
& c0 {- y/ h% i4 |2 G6 e4 y! q}
! |% T: Y4 K- J
; e  n8 F% L: m) f1 U3 q  Y8 Y  j//4:接受返回并处理

6 |% X7 o4 [7 L6 |( I( l/ rfunction manage(){

% p5 V4 Q" q" G9 h1 z' j$ t( Eif(req.readyState==4){

alert(“r==”+req.responseText);
. v. L. [* X$ j( A; |
( I7 s+ H1 {3 d! W}
) x4 p2 \7 G* V3 a; p
- z5 Z& J; x; x9 _# |0 ], W}
* m7 {$ h1 _/ C( {
+ _7 `+ N8 T2 e! A</script>
, ^8 G  o" _$ f/ w7 q( f5 R' n& x( d( a
readyState的取值如下：

　　0 (未初始化)

4 e' i4 Y& U/ E" Z　　1 (正在装载)

0 q; T% B1 G& ?2 A% @% _. ?+ _　　2 (装载完毕)
( W. Q" J* V: s3 w6 c8 B
　　3 (交互中)
' Q4 X8 z, `4 f
　　4 (完成)

3 z+ e2 y$ Q- |8 ]3 B5 n: B. u+ B

原理
Ajax的原理简单来说通过XmlHttpRequest对象来向服务器发异步请求，从服务器获得数据，可以是xml格式，也可以是一个字符串，然后用javascript来操作DOM而更新页面。
+ w# Q4 O* W5 d3 d" X+ f
1 g: V& M: y7 r  ~& T0 r4 S. B3 BDwr
是什么？
) o) k! V& Z* \: g( m" D! hDWR（Direct Web Remoting）是一个开源的类库，可以帮助开发人员开发包含AJAX技术的页面。它可以允许在页面中使用运行在WEB服务器上的JAVA函数,被调用的JAVA函数就像是在页面中JavaScript方法一样。

有什么？
它包含两个主要的部分：允许JavaScript从WEB服务器上一个遵循了AJAX原则的Servlet中获取数据；另外一方面提供了一个JavaScript库可以帮助web开发人员轻松地利用获取的数据来动态改变网页的内容。
3 z# Z& b2 w" Y" C8 U

5 u+ @; E( p5 W6 h& q7 C* u
能干什么？
. m" b$ f, A: ~" [9 X8 h. `) Z' Y7 E动态地把java类生成为JavaScript，感觉调用就像发生在浏览器端，实际上代码调用发生在服务器端，Dwr负责数据的传递和转换。这种从Java到JavaScript的远程调用功能的方式使DWR用起来有种非常像RMI或者SOAP的常规RPC机制。

2 o9 P; E  I! }( U; t! I8 z

  X) I8 }* F5 m: B0 i怎么做？
① 编写配置文件

web.xml

<servlet>

<servlet-name>dwr-invoker</servlet-name>
% [3 b4 Z/ ?; \4 q/ |# {" w
<servlet-class>

) c2 D. U: U% P" C: m  gorg.directwebremoting.servlet.DwrServlet

</servlet-class>
% t! r! p& ^+ F
<init-param>

  B) s$ z. g% z<param-name>debug</param-name>

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

</init-param>
& B, ]  d7 V# A* B5 M7 o9 c0 ~
</servlet>
& j( r7 I  c/ e
5 D: s2 a* b4 Q( T/ `9 `  Q* S5 ^<servlet-mapping>

, H. R( H" l4 R3 [3 g5 T<servlet-name>dwr-invoker</servlet-name>

1 S, z+ v% F7 D* E6 {, F<url-pattern>/dwr/*</url-pattern>

# K, o( v0 z' f3 D+ Q. ^</servlet-mapping>

dwr.xml
+ k8 c/ \# |8 b* O. K. U( v( `
" H  u4 ]) I! c& x( \0 \4 T. T" p! K; m<allow>
6 |7 N# t* d6 a& {5 N
3 W& \% q: j1 i' _<create creator=”new” javascript=”kc2″>
1 W& K9 Y( w0 y. i1 M1 r
2 E. M  _7 o: o8 m<param name=”class” value=”dwr.Service” />

) p' S7 j! G- R7 N0 Q3 _5 Y</create>

5 ?5 A) F2 J% G7 a# m  p* r; q; G</allow>
- {4 C' c6 H; [, m$ [7 N9 F
②编写service

* w* K! E* I5 s: o/ bpublic class Service {

" w: C; D- {' B# ~public String sayHello(String yourName) {
) ]2 m# C( ^% H6 n! s4 A7 m
, E$ \" ?3 L1 }6 X2 b! @//可以是访问数据库的复杂代码

5 P6 l* h% T/ g$ `( areturn “Hello World ” + yourName;

}
% U; `4 M1 z' x! ^2 ^7 R6 {1 V2 m
}

③测试DWR

将代码放入应用服务器（比如Tomcat），启动。
# u/ c6 P1 P) a) D( ^
6 n2 K0 l  |6 b然后在地址栏输入http://localhost:8080/你的工程/dwr

④编写jsp页面

1） 要引用3个dwr的js，其中engine.js必须要，如果需要用到dwr提供的一些方便的工具要引用util.js

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

( h" X' i9 F0 u: m3） js里的service.sayHello和java类的那个有一点区别，多了一个参数，用来得到返回的数据