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

admin

JEE
简述JEE
JEE　： JAVA　 PLATFORM　 ENTERPRISE　 EDITION
5 G: e) P. R1 J) A& _  D* ^
JEE是一个规范集；

; q# m' T7 L. U: {JEE是一个框架集；

+ X. o7 \! Q, a. [8 HJEE是一个技术集或API集；

适用于创建服务器端的大型的软件服务系统

' e3 ]4 c" u& M8 h8 k* R& }1 a" }! j
) c5 b/ v( g2 |
C/S B/S 模式
0 I3 f& k, n. R* b9 G/ T+ ~C/S client/server即客户机/服务器模式，客户端也参与程序的运行与计算（富客户端、胖客户端）
1 b2 l; l% [4 z* w' T( t
' D' ?9 I* d! `% ?! WB/S border/server即浏览器/服务器模式，又称为瘦客户端，客户端不参与程序的运行与计算
- M2 O* I  B/ T! M; S' [1 H& A
1 c$ f- D1 H( B" U5 y

企业级应用（大规模的应用）的特点
. S2 ^$ `* N9 g% O; x9 F1.生命周期长、稳定、可靠

2.组件往往分布在异构的环境中，能够跨平台
2 E  i) T" p* ^4 K6 A- v
& I# A' o- E* U3.维护性、扩展性、重用性
8 M5 c% p6 x# {& n9 _, s0 G
4.有事务、安全、线程

( k2 t" h1 u; e6 W, R
! p% ]+ M0 y# D: L, h- K% W5 L
什么是业务逻辑？
依照业务逻辑划分模块，
' L: _, @' O* ?1 g! u* y; ?
! {7 P- q7 \  T4 N0 D所谓判定业务　就是具有以下特征：
& i/ P* `8 B, U  ]' P$ v) ]) L  R
1.业务流程
4 T- G0 f% X( N5 c' L9 Y( w2 c
! w6 r& T; T$ z1 j4 E% j' d# @2.业务判断

' X# }8 y* c  H, l- n4 Y% I3.功能组合


3 }1 i. a2 R6 ?5 L$ T/ p% \
平台（角色）的划分
1.平台供应商。提供满足API集实现的厂商（BEA weblogic IBM webshphere）
) ^* [& x2 j' C. A
2.组件供应商

3.组件装配人员
  D6 S9 T0 ~0 b# a. A
4.部署人员

; R" `0 y6 L; i* B9 D# f5.系统管理人员
% N' s  A3 w, `5 w* `/ `+ F
; v& Y3 k4 D# a7 P) y6.工具供应商 提供开发组件所使用的工具（Jbuilder、eclipse）


6 r3 k6 V. L$ m# y
java技术分布（设计架构 模块内部设计）
/ k; a5 s* p, |, S- {! N1.表现层 Servlet、 Jsp、 JavaBean、 Taglib
3 E; g0 R4 e: f3 J( s8 K
1 \. D' h. F9 ^! b9 A5 ~0 }  i2.逻辑层 EJB(SessionBean)

# D$ M  k" x( M6 H: U! G  U: F: x3.数据层 （　JDBC 　EJB（EntityBean））
/ S! m6 c( T2 }. F; r# N
4.服务 JTA（JAVA事务架构） JTS（JAVA事务服务） JAAS（JAVA授权与验证服务）

5.分布式通讯 RMI（IIOP）+JNDI 、JAXP（JAVA 的 XML 架构）

JAVAMAIL（邮件服务）、JMS（消息服务）、IDLC、JCA（JAVA连接器框架 （成））

. U# @, C! `1 O

5 ^0 i; U( c- T! r8 @% w$ kJEE的体系结构： 是一种组件的体系结构
: [  c, k. k( G; W1.组件 ： 能够完成一定功能的封状体（独立的功能的集合）
; f* p9 f& @, V& M8 `
8 l! x+ E8 b8 P  P& C: {" C# E+ {% V( N不能单独运行，必须运行在容器上

分为两类：web组件、ejb组件
0 c/ D' i* b3 J/ O& w2 g/ a
2.容器 ： 提供组件的运行环境，并对组件进行管理（一段程序）

管理组件的生命周期
3 Z5 G/ _: u9 W% M3 J
不能单独运行，必须运行在服务器上

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

  W6 C7 y2 n: s2 a组件通过web.xml向容器描述自己，使容器能够认识组件
* ^0 `0 X9 d+ o$ I3 x
7 I! w- X8 n8 ?容器通过回调方法来调用组件
0 e" a6 m* ?' H
分为两类：web容器、ejb容器
/ y) e% _& N% M! D# T; e
" j. v" Y/ v% ~8 K2 t3.服务器 ： 提供容器的运行环境，提供大量的JEE基础服务

/ F. [5 S! h1 k/ A; }7 {) ~- v4 z( Y! @1 Wweb服务器（只提供web服务）
+ V6 K* C" N  [* z& y9 I% f
jee服务器（提供web、jee服务）
7 h$ D: m: t, Q- M% v' h

' G- A) g" f# _% ^- D
什么是回调方法
由容器自动调用的方法，就叫回调方法。



2 H* x) i  q4 y. YＲＭＩ远程方法的调用机制
例如：Ａ主机有Ｂ（）方法，Ｃ主机有Ｄ（）方法，Ａ　想调用Ｃ主机的Ｄ方法



. y. C5 _4 G3 Y3 {: s
0 ?" n& b# Q  A; ^
学习方法
" u7 l7 v& q* C* M, }* C1.规范（熟记） 2.熟悉API 3.多练 4.多想

admin

Servlet

•     描述war包、jar包、ear包的结构
  
  
  # Z: T7 P2 U- b) M; g6 Y

war-                            web文档压缩包

—WEB-INF

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

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

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

jar-                             java文件压缩包

—META-INF

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

: @- w. }' T' f- h

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

–META-INF

—Application.xml 配置文件

–*.war

–*.jar

& B, M, ?6 J/ ^, _9 i+ c5 e) `

• 什么是servlet？servlet主要做什么？
  
  - n: c6 s3 `" d# S1 o+ P
  

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

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

; P1 g. M5 O& y

• servlet 与cgi相比的优点？servlet的缺点
  
  
  - ]) B6 `6 F$ z( @/ J# K$ e" ~

优点：

性能（线程比进程更快）

可伸缩

Java强健且面向对象

Java平台独立

缺点：

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

• 常用的servlet包的名称是？
  
  
  

javax.servlet

javax.servlet.http

7 m1 s9 q: h) `

• 描述servlet接口的层次结构？
  
  * D: A( i. j6 V5 Y+ r! \
  * W; D/ s1 Y+ z" A

Servlet

–GenericServlet

–HttpServlet

–自己的servlet

ServletRequest

–HttpServletRequest

ServletResponse

–HttpServletResponse

" r6 x7 k, s' p- S8 f1 i1 I

• 对比get方法和post方法？
  ( @6 a; ?' g  z5 f& e7 f
  5 C7 Y8 O! O; ~0 H
    i4 H+ n7 K  }7 B1 I* i' C

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

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

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

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

• 归类描述HttpServletRequest接口都完成那些功能
  . V; N: L2 i8 W6 j8 v  `0 l
  
  
  • 读取HTTP头标
    $ \! v- @* x# m2 g' P, U& V6 W
  • 读取cookie
    
  • 读取路径信息
    & `- Q+ [2 p) `, V7 Q5 s0 n
  • 标识HTTP会话。
    
    

1 ^* j5 v  u2 a$ Z: S

• 归类描述HttpServletResponse接口都完成那些功能
  1 {" O; l* Y  B7 {
  
  
  • 设置HTTP头标
    
  • 设置cookie
    7 ~# U% e. K/ y$ m- Z- n9 ], a
  • 设定响应的content类型
    
  • 输出返回数据
    
    

& Q2 x( u( B) a1 F4 z

• 描述service方法所完成的基本功能？默认是在那里实现的？
  
  1 W) a$ s! D6 P( V# _6 e
  

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

实现：默认在HttpServlet类中实现

" R2 y! O& F- l* _+ O9 X

• 如何开发自己的Servlet？描述应该做的步骤和每步需要完成的工作
  
  . f. _$ o! `3 R: x, ?% p' o
  % P4 W7 j* _+ T6 d. F$ B

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

8 G3 s  N. J% v6 ?

• 为何servlet需要部署描述？
  
  / i* w+ W6 l" f% z
  

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

• Servlet基本的描述应该是？请写出来
  - }/ y, B8 o4 T' C$ q
  - p1 H% s1 C; P+ n  E
  ! A5 v/ \- a' ^% a; F

( s6 X: Y  O1 Y$ B3 Y

<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
  
  
  & o% E- E* A1 I' o" y

FORM标记

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

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

语法：

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

{HTML form tags and other HTML content}

</FORM>

• 如何接受request中的参数
  ' {* m, {: p$ M* m  _$ Z
  String userName = request.getParameter(“userName”)方法
  
  

8 \' w7 X0 V" m0 l/ ?/ X8 Z- @2 s$ u

• 如何接受request中header的值
  8 l. B8 r  r4 j" D9 [
  
  # i' Q8 Y, N! |  U# a; Y) H- T

request.getHeader(name);

request.getIntHeader(name);

request.getDateHeader(name);

request.getHeaderNames();

• 如何输出html
  7 H9 h! u8 O; m( y
  
  

PrintWriter pw = response.getWriter();

pw.write(“<html>”);

pw.write(“Hello”);

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

) |2 ^0 `: L0 _

• 如何设置输出的contentType
  6 K8 ]# I) [* A- r5 |
  
  7 z8 C/ r9 \, ~6 n+ l

response.setContentType(“text/html”)

- v% V+ n0 |, [

• 描述servlet的生命周期？
  6 I# ^. n1 }8 C1 p
  
  

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

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

• 描述init,service,destroy方法的功能和特点
  
  
  

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

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

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

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

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

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

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

/ R7 }9 J! F$ y

• 什么是回调方法？有什么特点？
  : `( P4 |  a- C% c2 H' U5 ?6 ?, r
  
  # ^; h$ c. `9 W8 F. y

由容器来调用程序的方法

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

, i% o. ^  O' N: ^. d% _7 L  Q( t

• 如何设置初始化servlet的参数？
  
  在<servlet>中添加如下配置
  
  

<init-param>

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

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

</init-param>

• 如何获取servlet初始化的参数
  " L9 J" a3 d3 G: ^( f! [
  8 C8 T: q" s3 L; z
  

public void init() {

greetingText = getInitParameter(“greetingText”);

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

}

• ServletConfig接口默认实在那里实现的
  
  ! d. B6 a( M, Z
  

GenericServlet类实现ServletConfig接口

• 什么是ServletContext？有什么作用？
  5 n. n+ f6 ~* ]+ K6 m
  # W6 P5 t! I0 j" ?- G
  & o; B# K! p) X& d+ U* T

Servlet上下文

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

• 如何访问ServletContext接口？是在那里实现的？
  
  
  8 o3 g; y0 @7 O# @( ~' K$ [" |

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

GenericServlet类实现了ServletContext接口。

• ServletContext接口的功能包括？分别用代码示例
  - }: b/ o% @$ S7 q' Q5 f$ s
  
  & k* G) r: S0 F6 X8 q0 f

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

/ x& g4 n3 b( |7 n: l

• 如何设置ServletContext的参数？
    t9 N6 ~+ I) v
  
  . W  {5 L/ C! k: Y, l

<context-param>

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

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

</context-param>

• 如何获取ServletContext设置的参数值？
  
  / F' z- [/ h# W
  

ServletContext context = this.getServletContext();

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

8 T2 B" Y1 l2 K. B- E

• 描述Web应用的生命周期？
  ) i4 I& F; j+ s
  
  

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

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

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

• 如何用代码实现监控Web应用的生命周期？
  # R0 ?5 s' b/ Q$ E  y0 i' u  \- Y
  * U, g& _! n) z3 @" \+ S+ l
  ' s- j! X) r8 A* H  N# n* ~( V& Q
  

public class Test implements ServletContextListener{

public void contextDestroyed(ServletContextEvent arg0) {

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

}

public void contextInitialized(ServletContextEvent arg0) {

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

}

}

web.xml文件中的配置：

<listener>

<listener-class>

com.csy.Test

</listener-class>

</listener>

• web应用中如下错误码示什么意思：400，401，404，500
  
  
  400 Bad Request//错误请求
  401 Unauthorized//未被认可
  404 Not Found//没有创建
  500 Internal Server Error//服务器内部错误
  
  

7 l. Q$ o9 z6 H4 j

• 描述Web应用中用声明方式来进行错误处理的两种方法
  2 Q# C( h- j8 n: P5 E; j4 n
  # j; G' O" M2 m; T2 ~) [
  

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

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

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

• 描述记录异常日志的方法，都位于那些接口？
  
  " _7 P+ C' e" e
  

GenericServlet：

log(message:String)

log(message:String, Throwable:excp)

ServletContext：

log(message:String)

        log(message:String, excp:Throwable)

- `" q7 o9 c7 _7 i2 i4 i

• 什么是会话？
  
  ' M' Y7 \$ s2 `6 ]' H
  6 `6 N6 R% ^3 r7 P5 R

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

) _8 C: @2 e: q

• 如何获得会话？
  / @9 N5 D5 j- T$ L3 C1 Q
  
  HttpSession session = request.getSesseion( );
  
  ( n0 T3 C9 o2 W; l

* [" H0 ]% N% A! x' o) C

• 会话Api的基本功能？
  
  
  

getID() :String
1 N0 v+ u; V$ h- Q/ P) i  e

    isNew() :boolean
5 R! l3 x8 ]. L5 n/ ]+ j

    getAttribute(name):Object
! Q* y/ l6 \. u" V# S

    setAttribute(name,value)
6 v' X8 S$ J0 ^( P* D

    removeAttribute(name)

• 如何销毁会话？
  % `; O/ k0 g& n+ X
  2 o2 ?6 p5 A3 [4 l* m* x9 ]
  7 Q, Q( x5 _; f# k

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

<session-config>
. p: s( g  Y: L$ V% m. H8 [

         <session-timeout>10</session-timeout>
1 W8 y2 R% w6 Q; [1 R' Y& m2 U/ k

     </session-config>

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

invalidate()
7 O0 Y- x: h* _. O; {- D; y5 m

     getCreationTime() :long

    getLastAccessedTime() :long
9 \3 N, _# q8 x$ [

    getMaxInactiveInterval() :int

     setMaxInactiveInterval(int)

• 描述会话保持状态的基本原理
  
  8 N! r/ @2 [* G9 o) w( a8 z6 k* Z  |
  

1 S0 @: c4 ~  M  k4 e2 U5 X4 K

    client server
" d9 T- W& ]) w5 g

* |3 b/ |. z- x+ l8 s

request

response (sessionid)

request (cookies)
$ k$ b+ b( p& F9 V9 |) }# B# y

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

( C$ W! u" Z" K% P; }$ A. O

• 请描述session和cookie的异同之处
  
  
  

0 R/ }$ t6 p" k5 A

• 如何读写cookie，代码示例
  
  
  ; _" D2 I/ u2 U- ]& {& J- T% ^

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

response.addCookie(c);

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

        for ( int i=0; i < cookies.length; i++ ) {
8 B# A! Z2 X3 w1 D" V

            String key =cookies.getName();
. `- w' u# H; j; G, ~+ e) w- j

String value = cookies.getValue();
) Z2 G0 b% b1 W5 {5 w7 J) f2 I+ S8 G+ g

System.out.println(“cook”+i+“:key=”+key+“,value=”+value);
9 |6 E# q+ Z! |2 C% C# E8 [- g

     }

! h* @0 s, l0 G, I  P7 A( Y

• 什么是URL重写，如何实现，代码示例
  
  + f2 [: S1 i0 {( x
  

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

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

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

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

9 b& B# s" t& r+ R" ?; c
- C. P+ G0 }; P- p* k. _" J% w3 N

• 描述web应用的4种认证技术
  ( H+ W; G$ x+ b5 I6 Z, a4 [  e; \
  8 p; h' Y5 ^3 y# b1 S4 \
  

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

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

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

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

• 什么是授权，什么是验证？
  8 P( m' Z' d# D. S% ?
  
  

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

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

0 ^* K' f/ n9 i" f

• 什么是HTTPS
  ( P* L+ L) v! c6 J& `  o; j, ?
  & Z: H3 o  \  f0 E+ S! C
  

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

' r, C: e3 x, D7 i! x1 Z

• 什么是审计？
  
  6 g2 X: }/ ?. m7 I# m' O+ V
  

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

• 如何实现声明性授权
  
  
  ' @) K, |( f" i0 V

1、标识web资源集

2、标识角色

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

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

在 web.xml里配

" }1 _  S* }2 q: n9 v4 I$ ?

• 描述servlet并发问题？
  & Z8 a/ M" ~2 e+ S+ F& ~
  
  

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

• 描述Web应用中的六种属性范围
  / w! {  f0 a: \/ z; P
  : J  o& i4 H) A, N
  / K, g" A; ~! ~" o2 ^, X

局部变量（页面范围）

实例变量

类变量

请求属性（请求范围）

会话属性（会话范围）

上下文属性（应用范围）

• 指出上述六种哪些是线程安全的
  
  
  5 |0 R3 R! s/ i. n  t

局部变量和请求属性

• 什么是STM？如何实现？
  
  
  

SingleThreadModel接口

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

• 如何实现并发管理？
  & ]3 s! ?& p) w/ K
  , D' L2 [0 t0 T- U- M9 H
  $ B, j" E1 D4 K7 G. b7 t5 ?

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

使用synchronized语法控制并发

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

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

admin

Jsp
1 t% C4 ]' Z# j! `3 |1 V, |什么是Jsp?
0 w0 ^8 k0 Y: U0 XJava Server Page    结合java和html在服务端动态生成web页面的技术
, J2 @8 c: |* G8 ^# H

5 h/ d  |% v- X
+ ?% F4 x& [- H* _% k. y描述Jsp页面的运行过程？
+ m& M3 a4 ]+ f第一步：
6 }; R) ^; H) N% W) v# ?( s" J( G' `
请求进入Web容器，将JSP页面翻译成Servlet代码

1 J8 j7 y6 H# m: {第二步：

编译Servlet代码，并将编译过的类文件装入Web容器（JVM）环境

  g- W+ [7 P) {) a1 y0 F( x  [9 A第三步：
3 E7 f- Z( e/ }2 `) X& r
Web容器为JSP页面创建一个Servlet类实例，并执行jspInit方法

. l, \; A% y$ L  W' {第四步：
6 `( A8 b5 W7 `9 t- s: |
Web容器为该JSP页面调用Servlet实例的_jspService方法；将结果发送给用户



描述Jsp页面的五类脚本元素的功能、写法、并示例
注释 <%– –%>
+ y! W2 B8 V. M
5 l6 P# d$ c8 b$ R% h7 w6 i6 J' U<HTML>

<%– scripting element –%>

</HTML>
7 K: m4 c% Y7 y2 U& h+ E5 q
' {% p* \7 O- r( ^) L3 C2 c+ X指令标记 <%@ %> 指令标记影响JSP页面的翻译阶段

- F; |# z3 Q# H2 Q  w, H<%@ page session=”false” %>

$ S6 M* Y. E) m3 \声明标记 <%! %> 声明标记允许JSP页面开发人员包含类级声明
9 o4 R0 c8 _% w- c9 U" d2 n
<%! public static final String DEFAULT_NAME = “World”; %>
% O0 i( i( m5 q( U! G- B9 C
) P& U- F! d" h' J3 }$ g& S% B5 H/ E    脚本标记 <% %> 脚本标记允许JSP页面开发人员在_jspService方法中包含任意的Java代码
! q' f4 c4 \/ t2 l, G# A1 z
    <% int i = 0; %>
. d+ W+ N/ Z# `7 C6 o* b4 f
表达式标记 <%= %> 表达式标记封装Java运行时的表达式，其值被送至HTTP响应流 <B>Ten is <%= (2 * 5) %></B>

8 M- [) W" E( m% w: L1 f! h) o
2 I" w* z6 r' L6 h4 ^/ g/ Q
. r! J: N+ q% ]; f/ N描述Jsp页面中的注释种类和写法
/ V/ S  o" o7 i9 HHTML注释

' u' _! r' v0 z8 n2 b( L0 ?<!– HTML注释显示在响应中 –>

JSP页面注释

) H5 y4 |7 S7 d9 @: b) _<%– JSP注释只在JSP代码中可见，不显示在servlet代码或响应中。–%>

Java注释

5 J2 a. K$ {3 t<%
- J5 d- d9 Q7 b+ l, l2 z
9 |! s  K; ]! B% k" S/* Java注释显示在servlet代码中，不显示在响应中
; e7 y# X0 ^4 Z2 P) }! Z! J+ z
8 o, u5 W4 T% ?' D& b" M- ~*/

%>



描述Jsp页面的指令标记的功能、写法、并示例
! e8 x) l6 f2 ~* T: ^( T4 `4 s% W; V指令标记影响JSP页面的翻译阶段

) a5 W" {  V9 A% F' m8 ]<%@ page session=”false” %>
" A$ j5 d1 V" z
<%@ include file=”incl/copyright.html” %>

* Q1 U9 |/ F3 t% H<%@ taglib %>



- x$ b5 A5 q; C, @描述Jsp页面的声明标记的功能、写法、并示例
声明标记允许JSP页面开发人员包含类级声明

6 C" w8 Q* E% [4 L写法：
  S8 ]  P5 [0 f% U4 ]  k
& x6 E+ J4 N, m: s<%! JavaClassDeclaration %>

8 N; u# f6 K9 F, H例：

: X" N% ]1 ~, p<%! public static final String DEFAULT_NAME = “World”; %>
: F& p. j$ X7 z4 _/ ]$ G
4 B  Y; z5 _7 n" I<%! public String getName(HttpServletRequest request) {

( L2 M  V+ H4 c- T+ @: p  ^* hreturn request.getParameter(“name”);
- i, ^$ S) |; s3 Z" |4 ^  u
}

$ |" E& W2 E; O1 v0 E- m%>
( P' R. l3 t" o/ Y* b: P
# H* E" l4 C6 D+ M<%! int counter = 0; %>
% w" l) s& g; p' l& k; g
9 q- o4 }. v" Q( F; |0 F0 m
* n1 e+ A8 A" W' Y
( m4 H7 n- Z/ M  |描述Jsp页面翻译成Servlet的规则
jsp中的注释标记被翻译成Servlet类中的注释
7 W! _, \( \3 k# X1 c% ~3 U
jsp中的指令标记被翻译成Servlet类中的import语句等
7 Q) Z5 f; C# g8 B+ ?, l% f0 L
$ N7 D; O8 H" J9 n8 x! U. H  xjsp中的声明标记被翻译成Servlet类中的属性
3 K$ D  s4 d- }. k* h7 C) g
' t+ h2 f- l: s' p2 T0 Sjsp中的脚本标记被转移到Servlet类中service方法中的代码

$ Z- O- C3 S7 z/ bjsp中的表达式标记被翻译成Serlvet类中的write()或者print()方法括号中的代码
; y' T3 Y. l3 ?: B$ ]3 j
# }7 l  b% \% L' U+ E+ Q

* c* i) s5 ~" [5 |# G/ Q6 Q7 M8 @描述Jsp页面的九个预定义变量的功能、用法、并示例
# i2 ]* |8 I+ f; k- q  Q# m/ Nrequest 与请求相关的HttpServletRequest对象
# B: l) n! m1 n. J6 B
response 与送回浏览器的响应相关的HttpServletResponse对象
/ L6 w9 T* M% c. ^: S
out 与响应的输出流相关的JspWriter对象
* U, R/ w+ a5 H/ `
    session 与给定用户请求会话相关的HttpSession对象，该变量只在JSP页面参

& H  F# N- t* ]+ l与一个HTTP会话时有意义
6 }5 T! ], k4 O; Z/ m
    application 用于Web应用的ServletContext对象
! j, ?2 K8 o7 E# k9 k
; m4 R3 B8 |# @9 P& yconfig 与该JSP页面的servlet相关的ServletConfig对象
, }$ U2 {$ ?  t
pageContext 该对象封装了一个JSP页面请求的环境
" A3 j6 ]8 u* J, s6 z
page 该变量与Java编程语言中的this变量等价
- K* d5 c3 u& R' R7 N9 \% a
/ ^. c  T9 B! X9 h- e8 ^0 ~- B    exception 由其它JSP页面抛出的Throwable对象，该变量只在”JSP错误页面”中可用
$ ^8 d4 r/ P" ?+ z& [$ |2 m$ E& E3 ~

& G# O5 T$ D& C& B- E- J
( m, B, S: B: ^/ fpage指令的功能，写法、并示例，并描述它的如下属性的功能和用法：import、session、buffer、errorPage、isErrorPage、ContentType、pageEncoding
+ l' b6 p- p+ q7 Oimport import 定义了一组servlet类定义必须导入的类和包，值是一个由
2 `* d2 a8 I" G/ a" ^9 D1 C5 _
逗号分隔的完全类名或包的列表。

session session 定义JSP页面是否参与HTTP会话，值可以为true（缺省）
6 Z8 q. [) t2 k' U
或false。

( k, r  E+ s. }# b% }5 o+ D. z5 {( Bbuffer buffer 定义用于输出流（JspWriter对象）的缓冲区大小，值可以为

- I' t5 u5 w% l; w  lnone或Nkb，缺省为8KB或更大。

- S  F1 |6 T: perrorPage 用来指定由另一个jsp页面来处理所有该页面抛出的异常
$ z4 L" W( n1 F3 m* R9 o
isErrorPage 定义JSP页面为其它JSP页面errorPage属性的目标，值为true或
  v" E! F# X, o" M
4 A" u7 j5 N! d3 Ufalse（缺省）。
  \3 M7 b# p  W  n5 @* i  H6 H/ u: v
ContentType 定义输出流的MIME类型，缺省为text/html。
4 W# Z4 A# ~1 d7 i
( [9 `, q2 Y" x7 WpageEncoding 定义输出流的字符编码，缺省为ISO-8859-1
; {+ ~8 f, p, E/ g4 k# h# ]
' N3 ~( c6 s5 U6 G' A7 _% ]
! I8 u. @, J) x9 K+ S  P4 O+ F
描述MVC各部分的功能？MVC的优点？MVC的缺点？
MVC各部分的功能：
* W" W5 P- [% g' {
2 \+ r) F5 @2 [Model（模型表示企业数据和业务逻辑）

封装应用状态

- l; U  g7 K. Y3 U1 p响应状态查询
: Q1 |+ I5 M/ v
2 o& }% [( O5 z* z6 B' w5 s, ]暴露应用的功能

$ S8 K+ R6 O# h4 C8 VController（控制器接受用户的输入并调用模型和视图去完成用户的需求）

验证HTTP请求的数据

% `* U* P7 J4 r1 N# |! @将用户数据与模型的更新相映射
8 T: {7 F7 o. s5 Z) }( {: `  k
选择用于响应的视图
4 f. Q5 u/ }0 }2 I+ E! F
4 F6 ^8 B) n& `" `0 o) IView（视图是用户看到并与之交互的界面）

3 a$ }2 p6 h% s1 t! G产生HTML响应
4 b$ R  b3 ]- e* |+ f- q3 Q
$ [: m- a2 G8 L4 m请求模型的更新

2 R  c, U+ d* V$ |- `3 N提供HTML form用于用户请求
3 s; L3 V6 H& Q% O% {3 G, g5 Y
  s( I3 m, E; T. s( JMVC的优点：
& H0 v- w7 K& z5 p( l
7 R9 f. q- v+ A# |  s$ ^        低耦合性：视图层和业务层分离
4 _; l8 @/ M2 U$ d( ]! K
/ p5 j" ]" L+ ]0 S# n高重用性和可适用性
& A5 s& w; |- g9 T# a
% D0 g( Z2 {+ d) \. b) `- x) ]较低的生命周期成本
6 ^& `2 r+ E: T! P
快速的部署

可维护性
1 E7 D/ [  a, P, @, M
有利于软件工程化管理
6 A+ g! G- H' c$ m: G
* v1 r# D3 e( @$ B提高软件的健壮性
8 }3 F5 \) a  ]( L. q) _) K
MVC的缺点：
: I9 B, k+ R' F4 w
        工作量大，增加工作的复杂性，MVC不适合小型甚至中等规模的应用程序

* h6 F. i" g6 N5 d- S
; g- T" R' A' w% ]1 u/ h; H
什么是Model 1结构，以及结构中各部分的功能
# Q& i: h+ ^+ b7 x+ \结构：jsp+javabean

2 {: `0 j5 o5 q; X+ y. IModel1中使用jsp来处理web应用中的视图控制部分

7 F8 r+ K" @' c" Y4 S& ?Javabean收集参数
- v4 J7 Z$ ~+ L0 G8 @

3 o4 C" B8 }, z
什么是JavaBean?
! i7 b1 L; s% H, J用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。

7 C% j/ o3 A5 M5 D% b, z" R- n% I
  f+ A6 v8 G6 S, X' a2 Z
JavaBean的规则？
4 w( [! {8 T7 Q7 @) |1 n使用get和set方法定义属性

8 f) Y  k" R" S5 _一个无参构造方法
1 |. o# C' F) V
9 K7 K& Y. c- f) i$ i' d: i6 g无public实例变量( 所有属性私有化)

/ I( e7 N5 R( v: G

什么是jsp标准动作？包含那些？分别都是什么功能？如何使用？
JSP页面中使用类似于XML的标记表示运行时的动作
) U* Y# Z' y  u  A. q
jsp:useBean

jsp:setProperty

jsp:getProperty

jsp:param
) _& ]# C( l* e
+ ]6 ?& n7 ^! B) l$ Fjsp:include

jsp:forward
1 B/ T$ q/ b" w( h

6 z" u- F2 W5 q8 d
- z/ n4 b4 _+ R0 Y0 n1 |用代码示例如下标准动作的使用：useBean、getProperty、setProperty
<jsp:useBean

id=”myForms”
# D- H$ Q6 v4 c/ p0 [
6 w( n$ a. ^! M1 b0 I# D; s' U9 sclass=”com.base.mystruts.forms.MyActionForm” scope=”session” />
! [; S( p% ^3 d
    <jsp:setProperty name=”myForms” property=”name” />

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


. ]% g& U* h, x' |, E
* u# y) a7 M; V1 g) ?& r描述说明Bean的四种scope
/ h7 w1 T, q$ e7 B  cpage

request
+ ^4 ]) w6 _. f
session
& p5 F0 ~6 s. I) j. _+ j: h
application

" _/ e$ v. c- t  p+ A1 F/ C/ ?; |
8 f" p$ A3 [$ u( w) S; U+ V
; c  D7 b/ v% m4 F9 x描述说明页面上的字段和Bean中属性的对应规则
* _& \7 i/ E/ sid 指javabean的变量名

class指javabean类的全路径

9 r7 _1 s6 c4 p" O* m  N4 A3 oscope指javabean的应用范围
. P6 K- Y7 v" R. H
name指所用到的javabean的变量名

& z% U3 W4 `$ D8 F2 E7 _    property指javabean中的属性
1 U7 S- T$ B) d* w; ?  V0 T


描述useBean动作的处理过程
0 ^9 i. o# F+ O使用id声明变量

试图在指定的范围内查找对象

如果没找到

创建一个类的实例
8 I& y) j, Q- c4 g. X
9 h% C! c+ w) J2 u; e3 J. a7 [执行useBean标记体初始化对象

0 O4 X- ]( Z& t8 X. m如果找到
/ r& G  U& h7 d% y, P
     将对象转换为类指定的类型
4 E# `! n* _8 m! G+ f6 D, c


描述forward动作的功能
使用脚本代码处理请求时，可用jsp:forward 动作产生一个不同的视图，

) E# H! p1 w/ {) Z* `6 ~使用同一个request：

2 v7 O& m  Z0 e. s) s% J
" P6 H9 K- c  R6 y8 {3 @/ ]5 i
: b* h1 `( P( ^3 v什么是Model 2结构，以及结构中各部分的功能
jsp+model+servlet
% x. Q- v7 N2 J! n# Z
Model 2架构使用MVC模式，JSP页面充当视图，Servlet充当控制器

Servlet控制器：

' v) L2 \5 i- I1 z) y$ g验证HTML form数据

+ t5 @7 H6 d, @. r0 I5 ?调用模型中的业务服务
0 S- w0 t$ @* d- o6 y; L0 e2 A
存储请求（或会话）范围内的域对象
/ n% T0 G" D2 ^! ~
8 ~1 A# H  z  N+ ^选择下一个用户的视图
7 N4 J: j; S3 Y" e* Y2 y/ B6 W! `
, r2 {) E. l! c- t; vJSP页面视图：

" n, T; V; A* c+ U1 b! G使用用户界面（在HTML中）
5 q# W/ k, Q) n
4 X* g+ y( O9 D: C4 P" E) m        访问域对象



7 i# p. _& j' W如何获得分发器？分发器的功能？
# I8 W, ]9 F! J, F上下文对象中的分发器：
) k" b6 x- w; V9 R9 {$ D9 {/ ^
  k" a. V0 }7 H  RServletContext context = this.getServletContext();

( [8 J! ~6 {0 c- y( qRequestDispatcher servlet = context.getNamedDispatcher(“MyServlet”);
: N4 S# ^5 h5 H% ^7 ]1 B% u: V- K
0 G; Z7 Z( g( |4 ?+ X  Q+ Uservlet.forward(request, response);

请求对象中的分发器：
! o3 M- L6 ~* [  }
3 ~  d7 G  \! w8 y* i  cRequestDispatcher view = request.getRequestDispatcher(“tools/nails.jsp”);
+ e% R8 V% ?; W9 c3 X
9 {( `; z4 a; |6 d8 Z9 Y( rview.forward(request, response);
8 C- K2 L, c7 K9 H7 f
6 f$ q+ b% ?9 ?) R可以将请求转发到另一个jsp页面，并保持请求的传递性


; d2 z$ y" {- Q: d' g1 z6 a3 U. \, _
/ j9 F9 L! _4 g6 z% V; TJsp中页面跳转的两种方式？
+ ^- C) A' `. D) G+ r; u" F使用分发器跳转页面
RequestDispatcher dispatcher = request.getRequestDispatcher(“url”);

dispatcher.forword(request);
7 Z2 C& [5 n' o
    特点：保持请求的传递（上一次请求中的数据，在下一个请求中仍然可以得到）；

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

使用重定向跳转页面
, O3 Y+ n) H% T& v0 k3 {9 e3 Sresponse.sendRedirect(“url”);

: _9 K2 {8 }5 ]2 R2 |4 B9 Z7 r    特点：产生全新的请求，（上一次请求中的数据，在下一个请求中不能得到）；

. q9 Z; k7 q) f3 g  D- n% q( ~$ m        重新定向的页面可以是任意的URL

/ [& q& L5 j( U, [; B' T

6 X; [  d7 }) L! }4 d& s( X描述Jsp中引入另外页面的两种方法，并比较两种方法的特点？
<%@ include file=””%> 在编译期间把另一个页面完全嵌入这个页面,可以说是一个页面

在这里可以共享变量
' x) P, m5 i- ^3 i( I7 G
: @3 G; P) X) d* k( B( C<jsp:include page=””> 动态的再运行期间把另一个页面加入这个页面,可以说是两个

' S! @* |! a8 \9 h* P页面，不可以共享变量
$ u- `. M0 s+ R% Q+ L6 w
( a& L/ ]4 G/ ]

什么是自定义标记
# [5 S: T) z9 x自定义标记库是一个Web组件，
2 q2 q" K; i3 ], U: x. O: `) Q
! V2 H( c& M1 E+ L% {: A- n包括：

/ Z; K% i7 i# Y4 J一个标记库描述符文件（*.tld）

% o9 P; r' ?) T1 s+ ^  D3 d9 r7 |( G所有相关的标记处理器类(*.jar)


4 l" O+ [( v1 l" \  L
% z9 J+ x' o: r% j( f6 \9 s描述使用自定义标记的步骤，以及每步详细的工作
使用自定义标记前，要拿到.tld和.jar两类文件
1 G8 C% ?6 e3 V$ g; X
6 F' G- S; f0 Z把.jar文件放到WEB-INF的lib里面。
把.tld文件放到WEB-INF根目录下。
在web.xml中配置。
- E8 g- }8 ]; U: J, E, v1 s3 L1 q<taglib>
+ r' f6 w' U1 J! p. d7 |. A0 L, n2 w
<taglib-uri>http://java.sun.com/jsp/jstl/core</taglib-uri>
+ s; `  `2 H& z8 Z: ?
% Z& e# w1 R! Y' s     <taglib-location>/WEB-INF/c.tld</taglib-location>

</taglib>

% s) S* h4 A) E: M2 ?2 ]0 g在页面中引用。
4 Y3 W# u4 a: ?% P  n$ L" k<%@ taglib uri=“http://java.sun.com/jsp/jstl/core” prefix=“s”%>

% |2 u4 t  v4 r5 {. euri必须与web.xml中的uri对应

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

: l' o, @6 x( O3 q5 a使用标记
1 d: L% r& W4 L# ^3 E: {8 w格式：<prefix:tag名称 属性>
% P+ T  X( F- Y7 H9 }
<s:forEach >

admin

在tomcat下配置数据源
- v% T) C4 R" B3 ~8 b; L1、服务器与数据库的连接

配置server.xml文件
! e( r: n" t# `" c4 h
1.oracle

  F% D2 `; T2 d" {. m<Resource name=”jdbc/company” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”
; M6 z- p0 G* R
; Z4 J1 }  g/ j# q9 ]6 B7 E                        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”
2 V7 o6 W/ g; n7 S, e
url=”jdbcracle:thin127.0.0.1:1521rcl”

, @9 u0 T4 J7 r1 ]3 QdriverClassName=”oracle.jdbc.driver.OracleDriver”
3 j7 i! h# [9 K* q5 H1 M: Z- Z
/ v2 Y" U% [! D0 m/ Eusername=”aa”

password=”aa”

maxActive=”50″
. U6 V  C) ]: w
maxIdle=”10″
  i0 L# W, i) b  ~
maxWait=”-1″
; b5 f5 i# Y- A4 c
/>
: c8 G( a2 R' p; l" S, a
2.sqlserver
. s+ J/ l! p6 a& K
! L0 J; m+ w: `$ `1 R3 w' Y<Resource name=”jdbc/webpage” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”
" }1 M' Q- u2 w% M+ d
4 i$ C+ e( r0 Y% S; ]% W" {        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”

" k# J7 \8 O/ C- e0 {url=”jdbc:jtds:sqlserver://localhost:1433;SelectMethod=cursor;
" h4 q  [! A# m3 y" L
6 H6 x0 R( N; D% {DatabaseName=webpagetest”
' W/ u% @! X% S2 i/ x
driverClassName=”net.sourceforge.jtds.jdbc.Driver”

username=”aa”
- p$ [( I- I( ?( s) p: f" E: N1 H/ K  T% D
password=”aa”

4 }6 q( Z: `3 j6 u, O7 H( [; G9 ?maxActive=”50″

maxIdle=”10″

# E( v% Y! [! b' y9 J, y+ fmaxWait=”-1″

/>

% C4 `! J3 T' K( i2、配置自己的web应用的xml文件


; g1 u1 j/ Q. v) _* u
6 m" C& A0 ^, z/ ~) p6 ^<Context path=”/eb03web” docBase=”F:/workweb/eb03web”

, Z+ m% o0 c; Q! ~. Z" d, ^privileged=”true” antiResourceLocking=”false” antiJARLocking=”false”>
% u) T. _' ~" f( U# Y% ]
$ X0 Z* \4 I7 g, }<ResourceLink global=”jdbc/company” name=”jdbc/company” type=”javax.sql.DataSource”/>

</Context>
  [, G$ A! Y  G7 ]" D: x

. r8 _/ Y; i6 `% P/ Y0 c+ o
, }% b, s/ j2 v1 j3、配置web.xml文件

, u! }/ G0 }! L8 m与服务器建立连接
2 {$ e& T. M5 [" V4 B
<resource-ref>

<res-ref-name>jdbc/company</res-ref-name>
# j# |# F) b* C4 {6 g. X! v9 a
<res-type>javax.sql.DataSource</res-type>
" E. ]  a1 |) x! Y6 L- ]
<res-auth>Container</res-auth>
* n2 H' g0 M2 V0 G. m" J. F/ L  q
</resource-ref>

4、在应用程序中不直接与数据库连接，通过DataSource连接池建立连接
$ A/ V6 F7 O- b% P9 q- A( m
0 D6 S$ Z4 h( X, I, w, [//1.在程序单独用时设置系统的属性，在tomcat下可以不用配置，

- k" K/ @5 f" n& r. I) o9 qSystem.setProperty(Context.PROVIDER_URL,””);
7 @/ w. R3 ]* E* _+ j
3 v* T% L) e* BSystem.setProperty(Context.INITIAL_CONTEXT_FACTORY,””);
: }" D+ T, e9 P! t$ m
//2.创建一个上下文对象

' E1 ?- x' s3 h" O* KInitialContext context = new InitialContext();
; a3 r) U' Z! l' w
5 J# f# c1 p$ e6 f//3.通过上下文对象在连接池中查找DataSource
' x9 a- N% S- L; ]+ K
' e: J3 S& m9 ^& vDataSource ds = (DataSource)context.lookUp(“java:comp/env/jdbc/company”);

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

% R( J" T4 s% q' a3 S8 C4 U5 \+ @ds.getConnection();

admin

ORM对象关系型数据库映射
(Object Relation Mapping)
* @5 C; @$ x4 i
- b% l- z; ^1 P8 B/ I: H一、映射的特点

  f  G1 }  {$ ~1.一个对象可以对应多个表

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

" R/ ~: q; d' U/ V3 [5 S! F2 H0 R& R3.对象和表的关系不用完全对应
8 w9 s2 ~8 [2 ?0 I+ e$ H& O+ ~
4.对象的属性的名称和表字段的名称可以不同

0 n3 a8 z6 r+ Z2 E. O- q( U5.类型可以不同，但数据类型之间可以转换
% m+ y( B* y1 A" C, h% F
6.对象中必须有主键，数据库的表对主键无所谓
# T5 B3 h. R( k& B4 I0 f6 r# d
7.数据库中有主外键关系时，对象中可以有，也可以没有
* E. `' S6 |& r% ?. ]


二 、有一个映射的描述文件————>xml
7 c  _$ s% E9 W1 L! [. K
! r2 @: n  i# M0 d5 w" `5 R- a! u5 z三 、怎样实现描述文件————>一段程序

对象 映射（mapping） 数据库

. W3 P6 y/ }+ K! d; R: Vuser

( \3 B& n9 v/ c; k+ Mid=11
& H1 z" M& O( _$ s: M! q
name=”张三”———— > (1) —————> tbl_user(id,name,age,tel,address)

/ E+ p4 P4 B6 T! j6 ?age=25 <————(2) <————

4 }, g2 S' U4 w  ]
# \9 n  s8 M% C5 J5 V7 Z) ?9 C$ m
(1)从对象映射到数据库

1 k3 D$ T( T+ `+ Q: L8 q  V- m8 T1.JDBC

3 G/ n& v4 B  N; Y2.根据描述文件来动态拼接sql
, }( ~, j! E0 E3 g
3.执行，添加到数据库中
" u6 t( e/ r2 w# T

  Y6 W- }$ q8 @6 B, e* S
(2)从数据库中映射到对象
# N% f- Q" B& x+ p1 d2 r5 ?
1.JDBC
! {/ s0 F* }5 Q6 K6 c
9 t5 F$ B  J1 N8 v2.拼接查询sql
( w' d* w2 J6 O' v2 W: \; b2 o) A
3.ResultSet

) A& s" s& y; {8 a$ P0 Y2 t* |4.Model
" ?) r& A: n" J
5 W+ c& j0 i4 X: R
4 h' Z& V. f% k/ C+ u
& w2 q8 G, F; |% c5 d& Q' @/ ghibernate
开发流程：

是什么？
) j# U4 e) U/ H# Q# nhibernate是一种基于orm 的轻量级的框架
) b/ x  i! h' ^- j) x, e2 A! t

7 Z2 a8 D$ ]6 C0 b3 ]  B: Q! V
有什么？
/ \/ N" ~, a! }7 E1. session 保持连接状态（依赖事务和连接池）
- x, i' R4 Z$ G- k4 c
6 l$ L% S) h- p# s% ]% K2. Transaction事务

. f% c3 M9 X1 I0 S$ U3.
Connection Provider 连接池
2 W, u9 M' D9 G! L" I  V


能干什么？
6 H9 n4 Z& t8 _0 M3 a3 N1.orm
: u3 d. r) W0 i. R- x7 r
5 U6 K6 a6 {8 B2.提供操作数据库的接口，简化数据持久化的编程任务
* a1 H/ b: X3 O! Y) G! V
2 `1 F* X; f0 x! E9 S

) Y5 x% j  s' y; j' w6 ?怎么做？
1.搭建hibernate的运行环境，将hibernate的包和hibernate所需要的包拷贝到lib 文件夹下

2.O（vo）
2 v2 H0 ~( f  G
' n' `1 K4 @) {* H! ^3.R （关系型数据库中的表）

4.配置文件
' r& `$ q! a6 X. Z) w) u8 u. t
1 ?8 \3 \: G; v; N5 G2 P- h4.1 cfg.xml 放在classes根目录下，默认名字为hibernate.cfg.xml
  q/ i) l5 e1 _0 T) N
( W. X% Y7 m; f, e- ?a.与数据库的连接

( @8 I. e: a  e$ F" s* E! vb.可选配置
& T& q  r; g/ F( P
% r6 h, D% i9 a  a' j4 I3 [c.映射资源的注册
, U- i! x1 S( H7 q- }8 {
9 w* t% J0 ?8 B* @4.2 hbm.xml文件 名字与类名相同 并且与类放在一起

a. 对象与数据库表之间的映射
/ s1 q5 c( `( I& m5 U5 s
0 C2 L& H7 q3 Rb. 对象的属性与数据库表的字段之间的映射

) K. q3 M! f5 o+ sc.组件之间的映射
/ s7 O4 y* D4 X; t) f! n
6 g! O6 L: T3 N, L* ]! R. Gd.对象与对象之间的关系映射
9 P+ c8 m6 z9 l; a# p- y# E: H
5、客户端

1.得到SessionFactory
) Q$ M2 {! o8 @* _
. v& X. h+ H% _7 R, X8 Z8 ]: U2.通过SessionFactory 工厂来创建Session实例
1 }; z. {# y4 H5 q$ M
' A( N7 E5 s5 |+ _7 s' e, ~9 n# L3.打开事务
: y' W7 I5 p- P2 [& u
" t1 z6 ]0 @" n7 j4 n4.操作数据库

5.事务提交
3 O3 n; C, t! u5 U/ D1 g
+ d0 h# M$ U% l5 f: C4 g3 {6.关闭连接
1 R6 T# a9 U8 A* \% p
运行流程：
2 y# @% r2 C- b
! ?. J& M/ y7 }" k1 _; ?整体流程
& [1 Y, }7 G/ q) k8 N" B1.通过configuration来读cfg.xml文件

6 O) }3 T' I' t2 K, n' v5 C2.得到SessionFactory 工厂（根据数据库的连接来创建sessionfactory）

3.通过SessionFactory 工厂来创建Session实例
  v8 |0 R6 z1 c3 f
0 p. U/ P) N5 o- A/ ^$ k/ Y4.打开事务
& {( U; e% ?& c3 g. s+ V0 ^7 C
5 V* _- O! Y8 T5.通过session的api操作数据库
5 r% I; [5 z( L+ y
6 F  I% i1 T, u5 Z3 u; u4 D6.事务提交
5 h* d5 W; U. i$ J+ o7 l
9 B  q" K3 ]: l7.关闭连接
! B* T& t) [7 @. `


save
% {3 @  O) @) D) n; _1.to—>po

5 H; O( u* R: O0 \9 v6 S' z7 v2 j- b2.根据model和cfg.xml中映射文件的注册来找到hbm.xml文件

3.根据hbm.xml文件和model来动态的拼sql
! w5 c4 \. _/ t0 @" d/ n
4.客户端提交或者刷新内存
; s' |) j5 y* L3 ^
5.执行sql，值放到数据库



9 S7 t& ?0 Y! P7 I8 E" r  v4 pupdate、delete
9 e. Y) ~7 O# ?. _0 @7 t1.根据model 的id在内存hibernate的缓存中查找该对象

如果内存中没有就到数据库中查找来保证对象的存在

2.根据model和cfg.xml文件中映射文件的注册来找到hbm.xml文件
' h( ]  p. Y/ i; ]
3.根据model和hbm.xml 文件来动态拼sql

4.客户端提交或者刷新内存
: B; Q& `1 i3 ]& |& t
5.执行sql

/ H3 u! d& b. M5 @' e! @

' u0 M9 i7 y  w5 p& X  }" NQuery
* M* o) i& _* c* }( T8 M3 D3 tload
+ A+ ?8 K) L7 Q, E2 d9 W, |
* s0 E. l, H1 m0 V9 a6 E. {$ C1.根据model的类型来找到hbm.xml文件

5 e/ c9 S7 z& m$ y$ X2.判断id对应的对象在缓存中是否存在，如果存在，就直接使用，如果不存在就进行下一步。
+ E" z) c3 g  e6 ^" k- t! I. }
3.用id做为查询条件来动态拼sql
+ d" k  w: i2 K8 C
2 t- m( S1 S! D4.执行sql 查询（先在内存中查找，如果没有找到（会抛出例外），就去数据库中查找）
" X! G9 W5 D1 i  i' K+ D% L
0 Z- X/ }$ t& V/ h2 F4 {" z3 C5.返回一个model类型的对象
6 ^6 t, L  @) T
+ F8 k2 W4 Y& D8 xget
4 e9 @+ U5 o# B
' T2 ?! z0 P* B9 S- x6 @  y, s    1.根据model的类型来找到hbm.xml文件
( O# t& q% Q. |  y5 Q# b
2.用id做为查询条件来动态拼sql

7 D7 }" [/ S2 P* l5 \3.执行sql 直接在数据库中查找，如果没有查到就会返回null

query

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

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

1 `6 M" d$ z; l' J+ ]: J3.根据model和hbm.xml文件来动态拼sql
' }! ~" _  N3 T" x' |
! f# L: b6 l& k$ Z3 [$ P3 }- m. Z/ M4.执行sql查询数据库

5.返回一个resultset
! q+ o7 ~, q: j  p3 w
* A- z4 T% U* [5 a( m. Z6.循环resultset的值，放到model中在放到集合（List）中

7 p0 S3 n7 g. F" @& B# }
: y  `0 O' ~) O0 z
/ n1 j& k& d8 R谈谈hibernate缓存机制
1 t& w5 K3 q. ~" f# B; p+ Q) D
缓存其实很直观的理解为放到内存或者硬盘上的一块区域，缓存就是一个缓冲的作用，有很多时候，我们的数据需要经常访问，如果放到数据库中，不是不可，只是效率上低，如果有了中间产物来代替数据库，就省很多事情了。打个比方，去买酱油，不一定一定要去酱油的生产工厂去买。代码中需要数据的时候，可以先到缓存中查找，如果存在，就直接拿数据，不存在就去数据库中取，也省了很多事。


! K" m' F/ H6 v7 q" @- J( {
. m3 R4 H. \: r; Z$ n* \6 l& l6 Whibernate使用的是二级缓存，有两个级别，分别是Session，SessionFactroy级别，一级缓存是Session级别的缓存，Hiberante来管理的，这个我们一般不用管，二级缓存是SessionFactory级别的，可以进行配置和更改，加载卸载，就是我们平时用的hibernate配置文件中的配置SessionFactory的属性。

" T. M: T8 u8 F

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



& }' V2 J9 J4 G+ M# h5 S| 一级session缓存| | 一级session缓存| |一级session缓存| |一级session缓存|

| | | |

| | | |

4 s1 \# y$ Z9 |$ `& M—————————————————————————————————

4 q) |$ C0 q. t! nsessionFactroy级别的二级缓存

——————————————————————————————————————-

|
& z: y2 v; |# g! K! [
|
9 e' y" O. a, r+ u4 A
|

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

DB
7 t8 b9 n  P0 p6 A
1 J  o) j! J3 p. C/ h—————————————————————————————————————–

/ |; A! Y8 D6 Q! D

admin

Spring

• 是什么？
  
  5 ]" }6 ~# k% m

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

• 有什么？
  
  ; i/ ]/ P7 t) O- C) A5 Z7 q5 H; O

每个包的功能：

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

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

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

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

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

AOP ：面向切面编成

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

• 能干什么？
  ( k" |# \! [7 r. ?1 M  Z0 M6 d
  ; d5 j7 m! P; E- s# ^

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

• 怎么用？
  / o3 _1 P" S: |1 v" W
  
  • 搭建web工程，引入spring的jar包
    
  • 在web.xml中添加如下配置
    7 p2 H" Q  m/ D+ a0 Z& I1 V" v
    & l3 K& Z: g( f, |
  
  
  / A! T1 U4 y" @! Z9 K

            contextConfigLocation

            classpath*:applicationContext*.xml

   
4 G# h2 J' S- J( n1 P& x  B

        

            struts2

            
5 c2 i! X5 V+ t- f" U! @

                org.apache.struts2.dispatcher.FilterDispatcher
+ y, C7 H( J* x$ [1 l

            

        
$ G2 \% {4 p" t

        
9 j+ |& \: u% r6 c8 d( i0 k& {

            struts2

            /*
  W) Z* {) B  D- K. ]9 R

6 |! x) g3 M0 V) i& Q

            
( f; x2 B7 q5 }0 m: K: e& T" L

                org.springframework.web.context.ContextLoaderListener

            
( ]* G2 v2 `9 B. @8 k2 j( O$ H

        

• 部署
  / C) \. \4 {2 g. g- D  A! K. U
  2 U+ ?* @7 ]( ~9 o: r. I

  g' q4 s/ j- A

• 容器和bean
  

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

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

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

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

• IOC控制反转
  
  
  
  
  7 G/ w4 ~% e( z  h9 r5 b( v  ~
  从前的应用程序想要得到A的实例他会直接主动的去拿，当用了sping后，应用程序由主动的去取变成被动的等待，由spring来控制应用程序所需要的对象
  
  
  • IOC的优点
    * ~) e8 P, {6 t
  1.可以通过IOC来获得实例
  2.可以通过DI来获取注入的资源
  • 配置IOC的原则
    
    • 一定是可变的资源才采用依赖注入
    • 一定是层间的接口或者是模块之间的相互调用才采用依赖注入
      

; k+ s1 G. Y6 a. P' j9 t

• DI依赖注入
  7 U. R) K- P! Q, F

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

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

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

例如：

在配置文件中

  l6 ^# W* R) N. v. V9 X

在应用程序中

Public DBDAO dao ;

Public void setDao(DBDAO dao){

This.dao = dao;

}

3．构造器注入

4．ref 表示参照其它的bean

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

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

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

6.lookup注入

7.singleton

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

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

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

8.DI的优点：

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

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

• Aop面向切面编程
  
  

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

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

2.AOP的思想： 主动—->被动（追加功能）
" X, _& J5 |+ g  U  S! l

3.AOP 的概念

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

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

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

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

5.引入 ：扩展的功能

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

7.aop代理 ：实现机制

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

4.AOP的事件机制
- x' Z* c$ I+ J! J' e1 m0 J

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

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

3.找到切入点

4.确定连接点

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

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

  ~) u2 I2 D, l% T
% t  N! \. w. J7 S
4 w) S0 ~! V, l3 z; i, `8 ^
* g9 G' h4 |  c$ L


3 c& F' a% `8 C) D

5. AspectJ

5.1.在xml中配置比较烦琐

所有的入口必须从一个代理（ProxyFactoryBean）开始
; \; y- b+ k! o  w7 i2 M) I

1 X) f5 @$ Y& s0 C. Z1 h
8 e5 U, h2 z1 \+ v9 |

         
; g0 k# V; I% i- S3 ?  j" n
% q; F+ ]8 E2 g3 b/ p1 I% X5 n( F
         
* k, y# W! e# p

        

        

  _0 M/ u, T# Z* |expression=“execution(* com.javakc.aop.MyTarget.t*())”/>
. U! P- L! I# q/ S

        

        
$ v# Y: r& z4 {; t7 `- q' f, G

   
# v5 ]+ H6 _: x1 \3 ~% E

% @* s' I1 Z7 H9 c! I* |" n, f
% }; m# v8 x! E7 W

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

@AspectJ的基本语法

1.@Aspect声明一个切面，将一系列的共同的功能定义成一个切面
! u' L7 \9 |0 r6 F7 D1 g! g

直接在类上定义@Aspect
* ^# R6 }# X( M" P

2.@Pointcut声明切入点
  \  u5 g9 D0 K( F3 W8 i$ j6 B% s

2.1、用一个专门的类来定义pointcut，类中的方法名就是该pointcut的名字
" F2 q3 Y! O* J' V! b" O2 v

2.2、可以使用匿名的pointcut

2.3、执行切点的几种方法
4 P# M( a# u, r. c/ ~

2.3.1 execute（public * 包结构.*.*.（..）） 可以指定到具体的方法
9 f7 M! F9 H, \( @

2.3.2 within 指定到包，不能指定到类
8 L( p4 k# E, B

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

2.3.3 this 指定到实现接口的所有的实现类
( S% e( R! ^) J

2.3.4 target 指定具体的实现类
( D+ s! q6 V1 z9 g8 C  A

5.4.advice的五种类型的示例
$ L3 n& y" e4 H* L

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

5.4.1.@AfterReturning(pointcut=”” returning=”retVal”)
/ G+ Q3 \7 m: j  b% s

追加的方法的参数名字一定要与retrning的名字相同
/ |  e5 K% }7 x6 E* S& f1 @

在注解@AfterReturning中必须加上pointcut和returning两个参数
2 V( d4 w. M5 y1 A, g" l  W% g7 n

pointcut指所要监控的目标对象的方法
- L% X9 c% ~/ U# N) Z! w

得到目标对象的方法的返回值，来作为参数，进行下一步的处理,参数没有顺序，按参数的名字进行匹配
/ @% w0 M% H# d# y. P, N; |

完成追加的功能
! u1 u* Z( E* b/ W

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

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

(2).
7 c* M  M5 u5 Y3 R3 C4 g  Z

     2.直接引用匿名的pointcut

     (1).@AfterReturning(“execution(
6 L, j! c) U+ Z6 h% H" O2 |

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

     (2).@AfterReturning(pointcut=

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

args(str)”, returning=”retVal”)
( E+ X( V3 [$ M5 p7 [3 n* B

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

    }
$ i' K+ `( i0 }

5.4.2.@Aronud
$ `1 d: f2 r9 u( e, `

     注解@Around环绕追加功能；

     在执行目标对象的方法的前、后追加功能；
( F; j' o, m- t/ U0 {

     必须有参数；第一个参数的类型必须为ProceedingJoinPoint；
$ Z4 w) s8 _( A1 `0 N

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

目标对象的方法
: u) X+ m8 j* d3 o0 q8 y

     1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
' W2 s" y! y: @

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

     (2).@Around(“com.javakc.spring.schemaaop.TestPointcut.t2()
0 n5 O! T. Y; H3 Y9 Z

&& args(str)”)
! g4 z0 N, O  S4 ]% u8 b

2.直接引用匿名的pointcut
( s2 T% ^8 I- g- Y

     (1).@Around(“execution(

* com.javakc.spring.schemaaop.Api.test1())”)
) v6 d/ L9 m- c8 c) k1 e

     (2).@Around(“execution(
2 [9 h, F6 @6 q

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

// @Around(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
: z. J3 u( V( x9 m) f5 j% V

     @Around(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
5 y/ l. S  u- L9 r+ `

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

    System.out.println(“around1==========before1pointcut==>”+str)
5 `; v6 g2 o( P. K. h. C' p4 W

        Object obj = prj.proceed();

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

    }

5.4.3.@Before

注解@Before在执行目标对象的方法前追加相应的功能
/ v2 \+ _# X. g2 F$ w3 F( i* C" u0 d

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
% j/ @- y) p* B9 F0 e, D/ ]) n

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

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

注意args后的名称与参数名相同
% x+ \+ `$ ?$ P* w; L

2.直接引用匿名的pointcut
( W4 \& Y7 Z; i- G

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

(2).@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
* g7 N! c; R: f2 C

注意args后的名称与参数名相同
4 Z2 G. r' }, a

// @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);
# U, E' U. k- {! ?" k

}
$ J# K( j. |8 P& m7 R

5.4.4.@After

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

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

     (1).@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
+ |% H5 i6 {6 Y" @0 Q

     2.直接引用匿名的pointcut

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

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

    public void testAfter(){

    System.out.println(“after1== >pointcut”);
- C7 c4 H" F, y: `6 d; Z" f

    }
& N" l% L, v; E- X( v

5.4.5.@AfterThorwing
7 ^4 X9 `2 T6 G( t

. k$ c* Q1 J; H0 t2 b! W- M1 k, K

• 描述一下spring中BeanFactory和ApplicationContext的差别
  7 H/ n' J& W+ }$ O8 k: v
  

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

/ E4 q9 h: j/ `1 x' R1 c2 z' }

• 谈谈spring对DAO的支持
  $ Z/ P# J' [: V) l, A% |0 @
  

Spring提供的DAO(数据访问对象)支持主要的目的是便于以标准的方式使用不同的数据访问技术。
* A  H5 n7 s) u$ ?3 H9 b8 k

简化 DAO 组件的开发。
Spring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法，用来简化代码开发。
% x# w' i% J, Y

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

面向接口编程及 DAO 模式的使用，提高了系统组件之间的解耦，降低了系统重构的成本。
. b5 w- z8 N% i  A& ~) {

方便的事务管理: Spring的声明式事务管理力度是方法级。
* q/ }' |& o2 ~7 Z$ e4 Y

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

3 H8 d: o) K- _
: z' H2 Q( g# D+ R* D

• 谈谈spring对hibernate的支持
  8 q" t& M- M( h; @" T
  

在所有的 ORM 框架中， Sping 对 Hibernate 的支持最好。如 SessionFactory 的注入、HibernateTemplate 的简化操作及 DAO 支持等。另外， Spring 还提供了统一的异常体系及声明式事务管理等。
3 S$ _, m3 D- e1 g0 P# U

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

1、通用的资源管理: Spring 的 ApplicationContext 能管理 SessionFactory，使得配置值很容易被管理和修改，无须使用Hibernate 的配置文件。详细配置如下：
' ~* x) I6 x" t: E8 ^5 v7 p

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

        

            oracle.jdbc.driver.OracleDriver
* U5 y! n- G; f" u: X2 i' u2 v

        
9 V  g' T" `. c

        
' z# H( f  z' H0 q; i1 n8 P+ c& y

            jdbcracle:thinlocalhost:1521rcl

        

        
6 S4 O. T( M* P% K6 ?- d

            javakc2
$ n# h+ s) j% b' X2 c4 A

        

        

            javakc2

        
2 R; G7 ?0 x) w" O) J

   

4 ~) }' J; g, f0 a! u3 Q7 A

   

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

        
. |, p" n1 ~' i/ z2 z

        

            

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

            

        
4 K, d; D2 Y$ g$ ?: _

        

            

                hibernate.dialect=org.hibernate.dialect.OracleDialect

            
4 r; F2 p: C9 M* w) o  J

        
! S/ C3 `- d% q& ?6 y4 z$ P

   
# p1 {( i! k4 H

   
0 Z5 h) t8 Z% s% F7 h, u

        

   

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

   

        class=“org.springframework.jndi.JndiObjectFactoryBean”>
7 V6 K) f/ r7 \8 @

        
' \5 I! `6 q, y- ?. }

            java:comp/env/jdbc/myds
: D1 q0 B3 o5 N

        

   

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

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

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

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

   

        

   

0 a, U5 T" g: d" a; p1 b8 M, u

   
0 t9 ~7 _1 a, U8 |

        
1 F' k! ^  X( W3 H

            
3 ]  l! k9 h7 g! v

        
$ g% W( T: U" ^; r8 v

   

6 `% @& t2 X% U+ u/ `7 C* [2 E

   

        
: v- j' |0 @. C3 e

        

   
: ?# a6 F0 D" F* B3 r% @2 G

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

Spring2.0之前事务的写法 + F$ L6 q, g% a% b; W8 v        class=”org.springframework.transaction.interceptor.TransactionProxyFactoryBean” 8 h1 P5 ?6 e2 Y1 A6 l+ r        abstract=”true”>                 PROPAGATION_REQUIRED,readOnly                 PROPAGATION_REQUIRED , m6 |+ i4 d: f2 X8 r

& C! [7 e$ q% i  W/ k

• 谈谈Spring对事务的支持
  
  4 P* C! `; p9 Z

1、声明式事务管理：

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

2.做法：

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

2.2

2.3 注入数据源

7 i% P4 x  E1 D  c3 |! b$ c6 y0 I) ^

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

( W! o+ w7 Q+ Z# K2 d' E8 s6 b
; ^+ i, h! c; o& {( ]

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

# D+ `- g/ a# K# b; \) C



1 e! |  O2 H4 F2 E9 G+ ]

2.6 定义切入点

7 b7 o- K; u/ V: }* L9 }

0 ]. H0 \8 F$ f4 A, B

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

1.注解@Transcational

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

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

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

- h# z6 z7 q# L5 x$ _% u

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

4 }+ t) c2 S, n7 z; z3 ]; n9 e) Z

/ ^0 u: V4 Y& }0 I0 D5 u' y4 \! [

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

admin

事务
1 B" S; c* [/ E( x- o( p) EACID
（1）原子性（A）：一系列的操作具有不可分割性，要么成功，要么失败

/ l5 q4 K7 i5 s9 f/ ~（2）一致性 ：操作的前后满足同样的规则，保持平衡。
6 r: V7 n4 q* b9 ]1 J
（3）隔离性 ：在事务运行的过程中。事务内的数据对外的可见性和可操作性（必需由数据库的支持）

; t& f' W! `- e4 r: x0 k# R3 s（4）稳定性 ：保证数据在事务的操作的过程中不会遭到破坏，而且是永久性存储的

! g- ~# }6 s8 {7 e* Q: r  z4 Y

$ Y* S  F- ]5 f7 x事务模型
+ K6 F& ~+ \4 V# Q! e（1）经典事务模型又叫平面事务模型（JDBC） 事务不允许嵌套
& M4 F4 r) U  {& p1 j# V8 s
（2）嵌套事务模型
5 M8 O7 Z( ^2 e% ?
! [( r" T) I6 L7 F4 g
* a% o. M" r* t" Q4 e( _
) s8 T0 p5 `( ~2 u) R4 j事务的两种方式
0 W% P$ _7 U5 x0 ^- M2 b' H$ @（1）声明式

在配置文件中设置以下6项
* @- r! b9 A9 i8 q) I) C
（１）.required

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

如果客户端有事务bean 中就加进去
& x+ o1 C) ?& U0 D% L" @8 Y, i
8 Z+ Z7 ?# p8 W- Y' k3 A7 S- [' N(2)、 requiresNew
! M$ t3 v8 A; \4 E( G! I, t
) U- o5 J% Z5 ?4 o; I' @1 u! M不管客户端有没有事务服务器段都新起一个事务

! d3 j3 U0 e  M- _如果客户端有事务就将事务挂起
1 Q# e- H. F5 i! C6 H. k. d
/ n5 b( N( X& J(3)、supports
+ z; E' P- v" E% B4 M2 z% h
如果客户端没有事务服务端也没有事务

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

(4)、mandatcry
4 ^' [- Q, Y" r8 R/ J" y" h4 C
; g  x0 o# p: Q- ?; E如果客户端没有事务服务端就会报错
2 H8 `/ X- ^) E; W6 z% Y
如果客户端有事务服务端就加事务
: S" w5 E( D' X6 F5 S
(5)、notSupported

不管客户端有没有事务服务端都没有事务
; ]- Y& P* ]& c
如果客户端有事务服务端就挂起
: t* N1 \/ I7 ~9 C$ u
  S$ K4 L0 U4 x/ T. p- A(6)、never

不管客户端有没有事务服务端都没有事务
( T" `4 ]7 a( q
如果客户端有事务就报错

（2）编程式事务

Javax.transaction.UserTranscation
4 u: e5 x  }" W& O0 b
JTA 事务可以精确到事务的开始和结束
: w* @* b4 C. W! I6 m- f! R

  u- R7 M* Q6 d3 j6 l
事务的隔离性
3 n  z' u3 V" `# ?- A4 _6 fRead-uncommited

3 y2 ?  l4 d; ]3 ]" Z& ?6 q1 g读取未提交的数据（基本上没有锁）脏读，存在不当读取的问题。

6 ^/ w) F( s9 h2 @& E% VRead-commited

3 w0 g8 y- m6 P9 a读取已提交的数据（行级锁）

无法读取已经写入，但没有被提交的数据。
9 k/ b: ]/ |/ d. X' e
/ B% ~, M( [( }# k- e6 TRepeatable_read

读取的数据不允许修改或删除
3 Y: ]; C' d, N: J. ^
" h3 T! \  L" N( v, A# O不可重复读（行级锁+不允许修改/删除）

Serializable
0 \7 A9 c7 @7 Y( t
幻影读（表级锁）

2 q- h3 ?8 H# ~  x- q* h

struts
1 A3 k+ e7 W- t) U8 n- k' A' k开发流程
& r2 o% }: I0 y! {+ ~
$ D2 }( n) j& t# j2 F, b1、创建表单

2、从表单中获得输入
- _  h8 R4 \: Y& }( s( r( m: d- U
3、处理输入（业务逻辑）

4、根据动态输入改变输入流
) i& l6 A2 j$ J# X, k
8 t) ?+ @/ H* T' X5 h5 J! ]要完成上述四步，我们需要创建
; G/ j& o8 M3 o; o8 w
1、一个ActionForm

2、一个action
' W  m7 B3 P9 e# X8 v" S
3、一个配置文件struts-config.xml
' V: y% W) R+ W
4、创建页面
( U8 y, B& w9 n" h( D6 C- ~# Z
创建ActionForm
+ _' t, L1 E: w9 S
1、写一个类继承ActionForm
, ?& A  T5 V% |* @$ q% z+ J
2、私有的属性
, Z. `6 e5 A0 ~- d
3、相应的get、set方法
3 k, y$ O' i! @  A
) C9 A' c* V9 i4、重写tostring、equals、hashcode三个方法

2 P& m) C# h" u' n" K) c5 q创建action

1、写一个类继承Action
; W  G" S+ r: G" P6 {+ x
: H" ^9 e/ D  J: D7 H9 c! |2、实现一个公有的方法（回调方法）

  T2 A. D, J, z' E$ H0 f6 Dpublic ActionForward execute(ActionMapping mapping,
" B$ H+ q+ D# D/ Z, q
$ `' Z- P  ~7 ^/ T  EActionForm form,
9 S2 {! ^. R* W) A1 W  Y
HttpServletRequest request,

HttpServletResponse response)
; C. z0 S% e0 J- _- c9 e
{

: a* }: Q8 K8 h; v/ o6 I//1.收集参数
) ^/ T- U; H, J, \. f' l( g
2 Z* S) s' R$ _9 q) N. j' fMyActionForm myForm = (MyActionForm)form;
6 D6 d( x5 B0 `: t% n$ O
: F+ T7 x$ n" u' ?  |//2.组织参数
% `) R4 b6 e" {' C' |

0 Z  K1 {( V( S$ j6 [4 g' g5 k
//3.调用逻辑层
! X( [7 |4 a4 _# E% d% \
boolean flag = true;
0 l8 F( R9 |6 o4 `4 e. c/ ?
//4.根据返回值来跳转到相应的页面
1 d% |* _" \" w, m0 |5 R2 a! Y
% h; e0 ^" `$ E/ q$ P- M  m' CActionForward af = new ActionForward();

if(flag){

& }* n- G# M! `9 eaf = mapping.findForward(“1″);
( v/ N, P! ?4 D8 Y- k
}else{
% ~0 G. J: h0 F4 I. [0 p
( m/ }+ o! b# J1 m3 jaf = mapping.findForward(“2″);
) V! Q2 e# R! Q
}

' n7 i! [  |" \+ N" H7 D6 breturn af;

}

, N. X% ]. X6 P7 P- I4 F  a配置struts-config.xml文件

2 K( E! ?  |! ~6 L6 |! R1.<form-beans>

<form-bean name=”myActionForm” type=”全路径.MyActionForm”/>
5 ]1 ^1 F/ K4 l8 r- t
<form-bean />

</form-beans>

2.<action-mappings>
, S( @, t# U1 n) T& \% D
<action path=”/sll”
$ [  e/ G1 C1 i0 @* \! e# K
name=”myActionForm”

type=”全路径.MyAction”
* z7 {9 N) R  A/ T. B9 Y
3 H9 i5 q* A' d0 r; T3 vscope=”session”
3 o2 E$ i; w; e
" M( d0 ~( c- z" uinput=”错误返回的页面”>

8 V" J6 ^5 k* J; A( O! Y% |; E<forward name=”1″ path=”/1.jsp”>
6 R' i9 r0 U7 g  J* D+ e
<forward name=”2″ path=”/2.jsp”>
  b! m6 j7 j5 h+ g6 h7 p2 I4 P
</action>

</action-mappings>

; h# T4 z2 J6 s2 K9 l# y' ?. l2 o步骤:
2 H1 R( q+ v6 S) k
" S+ I3 r+ Z& F1.创建一个空的web应用
$ V( s, u: {7 T
0 z9 Y" t  `; l! S2.将struts的包放到lib文件夹下

3.将.tld文件文件和struts-config.xml、web.xml放到WEB-INF的跟目录下
2 p1 y8 f( I' _  v1 q
1 s& n, ^" }2 U& b3 _4.配置struts-config.xml文件和web.xml文件
- X0 M% r7 x5 l- ^0 G8 q. ^0 P
5.在页面引入tag文件uri

% E, {5 o- c! B- c( CSTRUTS运行机制

% G- j8 L5 m- i4 x  @1、界面点击产生请求

1 ~# A# g: _% e1 ]1 K# U" S2、容器接到请求

, `" u$ Y2 v6 ~3 J& f% n/ e$ j3、匹配web.xml文件中的*.do来调用ActionServlet

" O( ?1 [. [+ W7 x4、ActionServlet的处理

4.1 读struts-congfig.xml文件形成ActionMapping
+ O+ d: b" n! X6 a- r( f- l
4.2 通过path 来匹配Action类，通过Action的name属性来匹配ActionForm类
' j: Z6 w' x3 S+ g  K* T# z  V4 E
4.3 通过反射机制来给Form添数据

' A( d6 l; s" G% f( t4.4 由ActionServlet转调Action的execute方法

* x2 [0 O- ]$ h0 U2 M+ w4.5 得到execute方法的返回值，跳转页面

# O9 b0 c0 y& w7 O3 U' h4.5.1 RequestDispatcher
5 S0 G0 R. S6 F  |
4.5.2 response.sendRedirect(“list.jsp”);
. c$ F$ P* \% M# t% c% O8 T

) `# u$ `8 s6 r( C$ C; Y4 r& |
3 x2 p' l# c1 l5 D进入execute方法

; c: q: E& T* W8 J+ u" u1 收集参数

; E6 s# V4 c& t0 Q$ `2 组织参数

3 调用，逻辑层
: ^: B( d  V! X6 L) D
* V5 p. ]- d. T5 `3 p4 返回值

) b: \/ _) p1 z4.1 选择下一个页面 （ActionForward）
. P# |3 q/ S3 U' [% _  `- g1 l+ k
% X, Y0 V: P9 g) d9 }' I4.2 把值传给下一个页面

7 v) j' Z8 f2 i' \

7 t8 i( l1 Q% c  J比较struts和struts2的不同

! e2 v0 h! j# f7 g7 G# vStruts
! w. ?2 E" v; D  _& g, w2 q& b) a
. E1 W4 z/ z+ a* E; T9 {Struts2
+ ]! J! a. S1 @0 _0 x
组成        五个部分：ActionServlet，ActionMapping，AtcionForward，ActionForm，Action        十个部分：AcionContext，FilterDispatcher，ActionMapper，ActionProxy，Configuration Manager，Action Invocation，Interceptot，Action，Result，Taglib
url        .do        .action
: U9 ], n# Q1 t" j( ?: d. G' X7 V分发控制        AtcionServlet        FilterDispatcher
收集参数        利用JavaBean技术，将数据封装到ActionForm的子类中；
! \( }. }' f  B- p  b一个Action对应一个ActionForm的子类

* a" q* |" e* K' h2 ~使用拦截器将数据封装到值栈中。
2 e& a0 L" H9 L使用域模型，一个Action对应多个值栈中的Model

! m' K( j& U; V- z# y& n7 q读取配置文件        ActionMapping        Configuration Manager
拦截器        无拦截器        执行Action前后有拦截器
返回页面        将字符串封装到AtcionForward，进行跳转页面        Action中直接返回字符串，通过Result跳转页面
页面跳转方式        两种：dispatch，redirect        三种：dispatch，redirect，chain
# i+ L8 ]# e0 x' u3 J: H8 c! o值栈        无值栈，Action通过在request范围内设置属性，向jsp页面传递数据        有值栈，Action和jsp页面通过值栈传递数据，jsp页面通过OGNL取得值栈中的数据
3 L4 v- }: Q( J0 b  I配置文件        struts-config.xml        struts.xml
中文问题        不能解决（需要使用filter）        可以解决中文问题：
, y, G) v; p8 C8 l1、在jsp页面添加Meta；

6 I* _' V/ ]+ ?; v! S7 b2、修改struts.properties中的设置。

admin

其他开发工具和技术
! }3 }& {7 ^1 SAnt
  e" M+ z  F( r% _9 DAnt是基于java的批处理工具

3 O" P, E8 }. ~2 {: M4 {3 K. n# X一、配置ant的运行环境

% D7 }8 J* G! l1.将ant的bin目录添加到path中

% Y# _: i# g2 H' A4 o9 w& _2 j' T2.配置JAVA_HOME

5 E: G  {! F. P3.配置ANT_HOME

二、配制build.xml文件，该文件放在应用程序的根目录下
( }& C# l9 K9 V0 g) e- y( i7 M
编译java文件

执行java文件

copy

7 `0 o# {) _! ?7 M& s; S, F删除

/ Z3 K# Q9 d4 n- J: I5 u打jar包
# L! j( F% n( ?; J0 V
% [" V8 s& d+ J" i7 S  n0 P根据注解生成配置文件
& h4 L1 ?8 J9 K8 j7 ?
Xdoclet
& }2 T, G. r% y9 G, C: X1 i; I通过注释生成一系列文件的工具（txt、xml、java、html等）
8 h! j# A/ j" R8 r. W. P
. B1 f1 d/ V0 r; |, Bxdoclet本质是摸板技术+字符串的替换
* w& P; L. N( }) d7 d* ~
/ n: t, u, A( C9 C5 A" y1.在java文件中写符合要求的注释（将hbm.xml文件的内容搬到java文件中去写）
8 ~1 W' ~  q& P0 U; w* r/ ^
, _" `7 U- D! i1.1 在类的上面 写与表的对应
+ o: {* N* S) F& Z* U6 @  y
1.2 将每一个属性的注释都写到get方法的上面
3 P- j5 s- @; n1 |  A1 A
2 @/ s% y0 e4 q, a4 y1 U" G/ N* Q2.在ant中引入相应的task来驱动xdoclet



2 g+ x- p$ A" ^% ]; f& Wlog4j日志管理
) r$ H1 v3 q0 O# Z& x! ?1、是什么？

0 [5 y) K% _$ r在开发期间用来测试、对整个日志信息进行管理的工具

$ m+ Y" L# \7 I* G9 b2、功能
2 [. q/ W+ A5 H. z5 m: H  g& ], \
; J6 K1 F& H: x* p1.控制输出的目的地
2 R) P  [+ S- b! m/ @8 A/ W( ?' e6 ^
2. 控制输出的格式

3. 控制输出的级别

( C& C7 v7 R# }1 D$ M0 w3、日志的级别

: W. ~9 t+ f! }3 ~# x" C1. debug 调试
5 U# j, N6 g( V0 v9 k
2. info 给用户的提示信息
0 I) T, V) k- x$ _+ z) o( m- w
6 ~/ W3 w, y+ Q/ w9 u3. warn 给用户的警告信息
6 k: i4 Q5 `! W& l  m
0 Z- s0 [& P9 v" ]4 G/ z& E1 h4.error 给程序员用来调试

$ F$ `: s' ?+ u6 I) F0 T5 BDebug—-〉info—-〉warn——–〉error

4、配置

1.配置级别
" q7 X. y0 @2 p- w2 L4 a1 p
: U) W. c* w1 B+ o* q2.输入源 （控制台和文件）
4 l$ `# {' _  c$ `- e; f  Y0 t
/ \. t! Z/ e1 L0 y( J, V1 V3.可以进行分包控制
9 H* I) ^: E& g
; @- i+ d% B) d2 K9 j% ~; {: w' g- vLog4f.logger.包结构 = 级别

8 K& t7 p5 d' `) K5、使用
( k5 Y9 a; A, k" z3 o1 z3 E
+ d3 L$ X3 M, P% mLogger log=Logger.getLogger(Test.class);

: M/ F% S6 }, Z: `7 o1 j    public
void t3(){

6 [& M) U, g. E; f. C0 j! e. L. G) t: t        log.debug(“this is debug”);
: c4 l; ]& ^  C% ~; l1 k
        log.info(“this is info”);
5 i' P  J1 x3 W( T7 j
1 t) w) w3 W; A0 E7 k* C" W) Q        log.warn(“this is warn “);
0 K- j7 g9 R4 A  r- }7 v
        log.error(“this is error”);

+ D% a$ m7 g7 h8 U% `, [# ]    }
+ `. ?& [, h( ?) m& E) P3 R. a
Junit
1.是什么？

单元测试的框架

  X9 }, ]' q- O2.怎么做？

) D/ ^, F+ q9 v& f1 v# ]写一个类继承TestCase

测试的方法一般都以test开头并且没有参数
( {- D% a5 r& E& _9 d
2 w/ V9 _# N, N9 v在测试方法前执行的方法public void setUp( )
# j2 {6 R9 |2 P$ ^6 P: n8 w" U
9 y$ j% A# G8 q5 W( a) ?2 A! C在测试方法后执行的方法public void tearDown( )
+ n0 E  |4 R8 ?+ a8 p
9 @3 w; ]% J: `) [error和故障的区别

5 U  \4 I( ~' i& ^; F2 s$ i1 X' N% Nerror ：代码有问题
5 W3 z8 ~$ X% ~! {) J3 Y, G8 B
故障 ：逻辑有问题与祈望的值不相符合
  G; B+ S) e5 ]
8 P/ W3 M; g) T  e6 |6 r- f& N7 w' X生命周期
; j3 \7 G5 L. G7 ^2 n" U
测试—〉SetUp（）—〉testXX（）—〉tearDown（）—〉结束；
6 H9 q* y6 R2 h) d: b; S- z
7 Y2 y( [, A9 i6 kTestCase套件

0 f% t7 y% u+ m6 f6 H; e+ {public class MyTest{
, v- E" ^2 S7 o. Z# z/ d
( w  s$ a% w' i7 c' o: [        Public static Test suite(){

- X5 m4 j" p8 {" h3 L. @8 eTestSuite suite = new TestSuite();
" F" P6 s) Y2 b3 u
: T& Y  w; z& f! d4 y# Jsuite.addTestCase(Test1.class);
2 P' w5 S6 w9 Q- e# x
suite.addTestCase(Test2.class);

}
4 G: @! i  s# M- M, ~! g6 x+ _
}
# n8 u/ n7 L2 s2 ]


Ajax
6 A0 w: z, N* a- P$ I# @. i7 ]; l0 `3 n6 G是什么？
: ?7 ^' W, U+ @  ~, J' Q# a- {AJAX即“Asynchronous JavaScript and XML”（异步JavaScript和XML)。是一种创建交互式网页应用的网页开发技术。
6 k$ K( l6 C- I/ G0 U3 \" S% {
无刷新页面。
. [2 y3 ?/ f1 `( F" q* G! a6 e
0 ^2 r3 j% O  f; \有什么？
AJAX是多种技术的综合，包括JavaScript、XHTML和CSS、DOM、XML 和 XSLT、XMLHttpRequest。

$ `- s8 `8 u+ f& G! \' G能干什么？
使用XHTML+CSS标准化呈现；
+ G3 k  r+ T1 I* n/ }- F8 M$ u使用DOM进行动态显示及交互；
使用 XML 和 XSLT 进行数据交换及相关操作；
使用 XMLHttpRequest 进行异步数据查询、检索；
* t. ]( }9 c& U, m0 Z( {使用JavaScript绑定和处理有所得数据；
- ~/ S1 c8 d6 w- }0 f
9 p; S8 e& M- n: ~2 ^0 A# L' `: \传统的web应用允许用户填写表单(form)，当提交表单时就向web服务器发送一个请求。服务器接收并处理传来的表单，然後返回一个新的网页。这个做法浪费了许多带宽，因为在前後两个页面中的大部分HTML代码往往是相同的。由于每次应用的交互都需要向服务器发送请求，应用的响应时间就依赖于服务器的响应时间。这导致了用户界面的响应比本地应用慢得多。

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

使用Ajax的最大优点，就是能在不更新整个页面的前提下维护数据。这使得Web应用程序更为迅捷地回应用户动作，并避免了在网络上发送那些没有改变过的信息。
* W6 D* g& C$ g7 ?: j2 f
+ \5 Z. ~( u2 i4 M对应用Ajax最主要的批评就是：
1 它破坏了浏览器后退按钮的正常行为，就是用户点击后退按钮后不能看到之前的数据；
2 一些手持设备（如手机、PDA等）现在还不能很好的支持Ajax；
% r3 L  t* T3 [( _# y3 用JavaScript作的Ajax引擎，JavaScript的兼容性和DeBug都是让人头痛的事；
1 w) i' ^, ?; `5 ^+ x" Y" U4 Ajax的无刷新重载，由于页面的变化没有刷新重载那么明显，所以容易给用户带来困扰――用户不太清楚现在的数据是新的还是已经更新过的；现有的解决有：在相关位置提示、数据更新的区域设计得比较明显、数据更新后给用户提示等;
, S1 d+ y6 x# c+ y# k. p, N
怎么做？
% d% z2 W' X1 A) H, T" `4 n<script language=”javascript”>
9 ]1 S# C& X& X) X6 [9 Q
/ J8 Y# p) N$ Q7 o- Y+ o- |var req;
; L. _( [" k+ |4 M% E2 E
function add(){

0 K- h8 ?) k0 c2 s" @1 i//1:创建用于传输的对象

- b! ~: h1 C7 ^2 L- |9 ]' a( Preq=new ActiveXObject(“Microsoft.XMLHTTP”);

- o3 H7 ?, p% w  o  w: d5 F' o// 声明返回后，处理数据的方法

( a  G9 Q7 j8 R5 `2 g4 A4 Sreq.onreadystatechange=manage;

//2:准备传输的内容
/ P3 n( s# F5 t$ n
4 A; o1 w. `3 y' _) Qvar str=”test1111″;

, Y# _% \/ ?  ]# `/ q//3:发出请求

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

1 G" Y  H. ~( T6 W& oreq.send(null);

}
% o3 t; J5 N' u7 I- z& t
//4:接受返回并处理
; X( ]' Q; e! K. l3 e5 z
function manage(){
0 u  N4 m- n. j+ ~# z' G- T
if(req.readyState==4){
9 q! B% K2 s+ m! @$ d  M
alert(“r==”+req.responseText);

3 P) g% n& b4 }) _}
' r7 `$ ^+ F( S' x
}

</script>
" |: H4 X5 z+ s
readyState的取值如下：

- a- W3 ^, Y# h* r　　0 (未初始化)

　　1 (正在装载)

. k9 u5 E& {, U- u6 j　　2 (装载完毕)

　　3 (交互中)
  d6 Z( Z+ v- i2 A
　　4 (完成)


0 ?4 v6 `4 m: \0 u1 Q
) u- e( i  g1 s# E# G! _3 K+ J原理
0 h4 ]  U+ y1 l6 f+ I5 c3 YAjax的原理简单来说通过XmlHttpRequest对象来向服务器发异步请求，从服务器获得数据，可以是xml格式，也可以是一个字符串，然后用javascript来操作DOM而更新页面。

( Y/ x4 V- d. A/ X6 E2 [6 y) F* ADwr
2 }( N- j- T$ ~, L是什么？
DWR（Direct Web Remoting）是一个开源的类库，可以帮助开发人员开发包含AJAX技术的页面。它可以允许在页面中使用运行在WEB服务器上的JAVA函数,被调用的JAVA函数就像是在页面中JavaScript方法一样。

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


9 V, ^7 [2 X) d, w& o# }
能干什么？
动态地把java类生成为JavaScript，感觉调用就像发生在浏览器端，实际上代码调用发生在服务器端，Dwr负责数据的传递和转换。这种从Java到JavaScript的远程调用功能的方式使DWR用起来有种非常像RMI或者SOAP的常规RPC机制。
, g( e$ {1 X+ g, I


怎么做？
① 编写配置文件

( O8 K) `& ~& O0 h3 A6 c2 Yweb.xml
1 ^! h  c+ c8 I8 |- [+ f
. n# s, y1 I( F; t7 V* _<servlet>

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

<servlet-class>
6 r) Q! |2 Z+ m% q+ d
  a  X0 W3 F! |) \4 c) gorg.directwebremoting.servlet.DwrServlet

</servlet-class>

<init-param>
7 q/ U1 K/ m& G, s1 y+ a
. b, @3 r: f2 J<param-name>debug</param-name>

0 D# q1 h1 _; ?. C$ o2 t7 F<param-value>true</param-value>

</init-param>
+ `$ ?1 C8 w: W1 I5 H) w
</servlet>
1 v4 K) y5 [# G) I2 a
5 ^; z; s% b3 ^5 W4 Z! Z7 Q<servlet-mapping>
1 i+ Y5 q& c) f% t; r
) P9 P- X3 ]  Q! Z$ m<servlet-name>dwr-invoker</servlet-name>
; u. r; H2 b3 }& H6 [' H8 ~  @# ?
2 b6 J1 o* ?6 H) @; l0 W+ d" W<url-pattern>/dwr/*</url-pattern>

</servlet-mapping>
: J! u9 L' _) x$ P$ t7 D9 s
dwr.xml

<allow>
; E/ m% Q& p3 ?& `$ s2 D3 U1 S/ e% S
$ `) Q  U5 Z1 u0 p- i3 z<create creator=”new” javascript=”kc2″>
) Y* ^+ r: \! b% {* j  }- n
0 M3 e6 y( a7 Q, m& B. B& t  C<param name=”class” value=”dwr.Service” />
9 {) p3 b+ x1 a; E
$ v* j5 f, C3 ?+ Y" ^9 W7 \6 w</create>

+ ~' X* `$ j7 h; [; n7 o( y- O</allow>
" c0 x& |! [0 d. Q: {3 ~
3 T" U, ]8 J. \6 r$ M! E②编写service
1 j1 O% n' b& d
; {7 L% R. e: f' {public class Service {
1 R+ t9 w2 h0 I
public String sayHello(String yourName) {

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

return “Hello World ” + yourName;
- P) a) Z9 z; l7 `$ b' T
. L8 I, u1 U: n. M}

}
: \. W" W$ M" y/ v+ f( Q
; ~3 Y) x6 y8 g* T& ]! O5 V* i/ Q4 N③测试DWR
6 D5 z4 `+ t1 i0 `+ k
/ J: ?. t# x2 y& v6 x0 O将代码放入应用服务器（比如Tomcat），启动。
4 x  F, r. c, N! F# z8 K
" I9 k# h) P4 o' S& O然后在地址栏输入http://localhost:8080/你的工程/dwr

. m5 M# b$ y/ A* X④编写jsp页面
* B& m2 a% w) d# S8 b$ @
1） 要引用3个dwr的js，其中engine.js必须要，如果需要用到dwr提供的一些方便的工具要引用util.js
  s* _' b; V* B( [3 M3 J% ^
2） 然后还要引用dwr自动生成的js，dwr/interface/service.js，注意js名字要和dwr.xml配置的一样

, i- n% a- M# E4 U1 N8 |% {* m3） js里的service.sayHello和java类的那个有一点区别，多了一个参数，用来得到返回的数据