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

admin

JEE
) k: {; {+ l# C# C, a  a简述JEE
6 S- M+ G6 ~! t8 w7 s) @! O9 uJEE　： JAVA　 PLATFORM　 ENTERPRISE　 EDITION
. n8 `% `" k! c4 n
; ~) v, B+ \4 r9 AJEE是一个规范集；

JEE是一个框架集；
- n" b& j3 i5 @
JEE是一个技术集或API集；

适用于创建服务器端的大型的软件服务系统
: j1 N1 a2 r, c' f
) }7 U/ H8 }8 D+ q8 ]5 H

+ }9 T  G2 s' p. K. cC/S B/S 模式
C/S client/server即客户机/服务器模式，客户端也参与程序的运行与计算（富客户端、胖客户端）

B/S border/server即浏览器/服务器模式，又称为瘦客户端，客户端不参与程序的运行与计算
9 ?( l7 c5 l% v. O


企业级应用（大规模的应用）的特点
1.生命周期长、稳定、可靠

* J: q& s# n% Q2.组件往往分布在异构的环境中，能够跨平台

3.维护性、扩展性、重用性
: K7 t3 t* v# [! s  z% S
4.有事务、安全、线程


5 x, s$ R' H9 L1 B' e4 d
什么是业务逻辑？
依照业务逻辑划分模块，
# U0 a# K& c6 y
所谓判定业务　就是具有以下特征：

1.业务流程
, T0 F( z1 \$ }" H
% H+ L) o' Q1 }% A* Y+ V& V$ _' p2.业务判断

& s3 J- K8 _- [$ t  O0 t- z% a3.功能组合
) l/ e5 H2 p. d7 ]0 r
& k% ]6 o, e+ O# K1 x

平台（角色）的划分
- I8 }6 b, G7 a( R  q1.平台供应商。提供满足API集实现的厂商（BEA weblogic IBM webshphere）
: J5 ]7 j! u+ g1 [1 i
; a$ L8 @4 B! O3 u2.组件供应商
' D: x9 m6 c) Y. Y! W; C
3.组件装配人员

4.部署人员
" e7 R) u. H3 i1 v& M. H0 M
5.系统管理人员
9 e: c7 k/ `- o- n4 o, U% m
, V! S: V1 u9 Y0 u6.工具供应商 提供开发组件所使用的工具（Jbuilder、eclipse）



& o$ h! M  u! W, h# e8 [1 R) s) Ajava技术分布（设计架构 模块内部设计）
- |; X' _# |$ y2 Z+ K% G* q1.表现层 Servlet、 Jsp、 JavaBean、 Taglib
; i! K# a$ c' w8 E! m# u
; b) [' X1 D9 z2.逻辑层 EJB(SessionBean)
- U& s2 N# l$ n6 L* p1 H' d- ]
3.数据层 （　JDBC 　EJB（EntityBean））

4 ]( H" ~+ K+ i, |. i. G: S4.服务 JTA（JAVA事务架构） JTS（JAVA事务服务） JAAS（JAVA授权与验证服务）
+ ^" x8 h1 O  h
/ I5 f) F5 A1 V( ]5 o8 }9 @; s5 b5.分布式通讯 RMI（IIOP）+JNDI 、JAXP（JAVA 的 XML 架构）

0 R: c- \: B5 RJAVAMAIL（邮件服务）、JMS（消息服务）、IDLC、JCA（JAVA连接器框架 （成））


/ O8 h2 F1 e; a5 m
JEE的体系结构： 是一种组件的体系结构
1.组件 ： 能够完成一定功能的封状体（独立的功能的集合）
3 z9 G! a% D0 y
不能单独运行，必须运行在容器上
! G! F5 Y; w: j
分为两类：web组件、ejb组件
/ w5 S1 K) U& ?, z, A& ]
( F  h% J9 a3 U* y$ `) ~; P8 t) a2.容器 ： 提供组件的运行环境，并对组件进行管理（一段程序）
( w2 h* _: n% u) S( n
9 Q1 V. {" e4 _/ G3 ~. i/ `* s管理组件的生命周期
% D7 W- ~: D0 x, ^4 C# G
( J; E* L! T& P1 X# y' L+ Z不能单独运行，必须运行在服务器上
/ V$ W, B5 a! L9 \4 D
程序（组件）通过上下文来调用容器（context）
1 A+ e3 Y$ h0 R( @8 L0 l) U
组件通过web.xml向容器描述自己，使容器能够认识组件
" M4 E5 _  k. k6 \& s) o' [
$ g7 z+ w5 v+ M. h) T' \/ Q容器通过回调方法来调用组件

! S5 B/ }5 I- I9 z, e分为两类：web容器、ejb容器

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

web服务器（只提供web服务）
. H4 L6 f$ N) v$ Y  J+ K" s
jee服务器（提供web、jee服务）
# r2 P5 a- a/ m. [; z$ t4 o

/ |  y3 L7 n# g
% ]5 Z, T( A' \) Z  U什么是回调方法
5 W/ [% Q* R6 Y* [% P3 Z由容器自动调用的方法，就叫回调方法。
7 m5 t* |  w5 Z. L
& a( O  A& a: p) w+ f9 Z7 \  z

) J% m+ L( j5 d! ^# M3 ?ＲＭＩ远程方法的调用机制
例如：Ａ主机有Ｂ（）方法，Ｃ主机有Ｄ（）方法，Ａ　想调用Ｃ主机的Ｄ方法

2 @. Z1 c/ M% q; [1 t8 X( D( [9 G
: i) d. O6 B6 V5 h7 t+ v
6 [9 X5 W  e2 \2 d' z' K6 _

$ S( y7 _  {$ \# ^学习方法
1.规范（熟记） 2.熟悉API 3.多练 4.多想

admin

Servlet

•     描述war包、jar包、ear包的结构
  ; [- S, y. ]7 A  i; n5 H7 @! h
  
  

war-                            web文档压缩包

—WEB-INF

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

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

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

" J% P: d& y2 w

jar-                             java文件压缩包

—META-INF

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

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

–META-INF

—Application.xml 配置文件

–*.war

–*.jar

• 什么是servlet？servlet主要做什么？
  1 ^5 a, K! m; \* ?9 D
  
  

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

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

6 G# t$ M" Y- E- l8 y

• servlet 与cgi相比的优点？servlet的缺点
  
  
  

优点：

性能（线程比进程更快）

可伸缩

Java强健且面向对象

Java平台独立

缺点：

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

• 常用的servlet包的名称是？
  4 j- k8 }( ~# ^; f0 T8 K" Y
  
  5 _" s! }6 _$ ]; w7 M- ]9 B. ^

javax.servlet

javax.servlet.http

# b, a3 {( W3 E' T% q. }/ [; v- I# v

• 描述servlet接口的层次结构？
  
  
  

Servlet

–GenericServlet

–HttpServlet

–自己的servlet

ServletRequest

–HttpServletRequest

ServletResponse

–HttpServletResponse

9 Z" ]9 }6 V% V! A

• 对比get方法和post方法？
  
  
  

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

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

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

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

0 P5 ^6 B1 A$ f, {+ |

• 归类描述HttpServletRequest接口都完成那些功能
  5 Q( a3 ?& F+ f3 W
  % Y8 @6 x6 R/ j8 z8 T# {- W  Z/ z# p& V
  ) I! Z% \3 _% e. H) O' o8 Z
  • 读取HTTP头标
    - @. T1 x9 A) k, Z# _# M2 Q
  • 读取cookie
    
  • 读取路径信息
    
  • 标识HTTP会话。
    7 L  i% Y% |; Z+ |
    

% F$ F1 T1 a0 _2 W$ x

• 归类描述HttpServletResponse接口都完成那些功能
  
  
  
  • 设置HTTP头标
    
  • 设置cookie
    
  • 设定响应的content类型
    
  • 输出返回数据
    : M* b' {! h1 `) z9 _
    

. J  k, l& E  r# v- u: y

• 描述service方法所完成的基本功能？默认是在那里实现的？
  . a, ^, U) @  F- |
  
  : s3 z+ |4 j  n! N

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

实现：默认在HttpServlet类中实现

% a7 @* H% r: p6 p5 k/ \

• 如何开发自己的Servlet？描述应该做的步骤和每步需要完成的工作
  
  " p' c; W7 f! \! Z2 K
  

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

7 |, n7 C! n7 R: m7 x# P, q

• 为何servlet需要部署描述？
  
  + [) d- R( H: B+ y
  

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

* n$ y3 |  p/ v8 j* a9 Z

• Servlet基本的描述应该是？请写出来
  
  
  

: D( k2 m6 w7 o8 j- F! g7 c' V4 K

<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
  
  
  % }2 t/ e4 V& P! f2 A- k

FORM标记

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

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

语法：

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

{HTML form tags and other HTML content}

</FORM>

' D; D) n1 T2 o0 n$ a; N( e

• 如何接受request中的参数
  
  5 z8 ]2 E; q; U. n  R/ K% cString userName = request.getParameter(“userName”)方法
  
  : D; P' A6 u* _, Y. \

( l5 A9 Z& X/ H7 L" a0 b; t' y) m

• 如何接受request中header的值
  - c) ]1 P7 n9 h
  3 o8 V  k/ e) ~: w8 ]# N: f" K
  ! {# b2 a6 u: R# H1 ]( k7 h

request.getHeader(name);

request.getIntHeader(name);

request.getDateHeader(name);

request.getHeaderNames();

• 如何输出html
  7 i+ E( R! S" F! B
  
  / X4 U1 x$ E( d8 x

PrintWriter pw = response.getWriter();

pw.write(“<html>”);

pw.write(“Hello”);

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

5 I& j8 W  @# Q) b% d

• 如何设置输出的contentType
  
  ( ~2 ]% l* F3 p  o$ A8 ?6 z
  

response.setContentType(“text/html”)

) s9 O7 u% }4 d; U8 H

• 描述servlet的生命周期？
  6 Q+ {5 q0 H& u5 _1 P8 |) ]/ L
  8 P' c' R4 [3 M0 f# q3 ^
  7 j8 v/ q6 k& i0 T

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

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

• 描述init,service,destroy方法的功能和特点
  6 B/ c4 }# h9 `4 Y
  % I6 b# g3 Y( U0 H
  

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

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

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

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

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

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

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

9 M3 s+ y/ l1 }" |3 c

• 什么是回调方法？有什么特点？
  # ^* A- ^$ V; F& C" g) H8 V
  : \5 C0 n0 F- [
  ) _& c, H3 h3 S

由容器来调用程序的方法

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

• 如何设置初始化servlet的参数？
  . |/ ^  d- u  u8 l+ \+ f# q4 o
  在<servlet>中添加如下配置
  
  

<init-param>

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

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

</init-param>

9 G+ Q2 Y& x7 l! t! H4 c3 `

• 如何获取servlet初始化的参数
  
  
  

public void init() {

greetingText = getInitParameter(“greetingText”);

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

}

• ServletConfig接口默认实在那里实现的
  9 }# e0 ]8 {* A/ f; A
  ) y" [" j: m8 n# |  D( i& M
  

GenericServlet类实现ServletConfig接口

• 什么是ServletContext？有什么作用？
  : V! W8 T* @. b) f& q# Z( c8 q1 i3 G: i
  - r- s# Y: m9 K8 D- {
  ' j) T$ p7 L- b, x3 ?" U0 D9 q

Servlet上下文

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

9 p6 w% U5 ^' E( A. f

• 如何访问ServletContext接口？是在那里实现的？
  
  
  3 i5 A( F6 L/ B

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

GenericServlet类实现了ServletContext接口。

• ServletContext接口的功能包括？分别用代码示例
  
  
  

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

" D3 M. H# P# A+ B2 |

• 如何设置ServletContext的参数？
  
  + H+ ?; I& w- a0 V; Q- ~/ a  W
  

<context-param>

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

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

</context-param>

+ _5 {3 F3 j4 i

• 如何获取ServletContext设置的参数值？
  
  
  

ServletContext context = this.getServletContext();

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

• 描述Web应用的生命周期？
  9 S1 [2 G7 T+ z- W: ?5 b
  * F) D* v4 Y: _8 W# d1 o5 _
  ) z1 ~( A: C1 G8 x7 @: c( y( F' {! x

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

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

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

• 如何用代码实现监控Web应用的生命周期？
  ( n( P2 ~3 K% \9 o5 ]
  0 s7 [$ ?. a/ }# k
  9 w( M  b* r+ n3 i! i
  ( U4 I& f9 H& i& [* k0 K

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
  ( Z9 z# g. w  G" _7 q& B
  
  400 Bad Request//错误请求
  401 Unauthorized//未被认可
  404 Not Found//没有创建
  500 Internal Server Error//服务器内部错误
  
  

• 描述Web应用中用声明方式来进行错误处理的两种方法
  
  
  5 F7 G) p$ i% A6 A

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

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

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

8 ^+ g; w+ C. t& a

• 描述记录异常日志的方法，都位于那些接口？
  
  
  

GenericServlet：

log(message:String)

log(message:String, Throwable:excp)

ServletContext：

log(message:String)

        log(message:String, excp:Throwable)

• 什么是会话？
  , Z) U1 T! X/ I- @: p( ?
  
  ' y1 J; `* H7 P$ O! m) t: ]8 g4 u% A

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

• 如何获得会话？
  
  
  HttpSession session = request.getSesseion( );
  
  ; ], I# H9 O$ ]/ P2 G

# ~$ E$ p# ^, s! T1 c% l! x" R$ A

• 会话Api的基本功能？
  $ u# m/ @0 j8 g, e. j* e9 E% Q/ @6 v  c
  
  

getID() :String

    isNew() :boolean

    getAttribute(name):Object
; u; i) n/ ]2 P8 ]8 G, c, j; P

    setAttribute(name,value)
; G# a3 U. `; R# M& u4 U

    removeAttribute(name)

• 如何销毁会话？
  ( N/ Z/ `3 E( W! D! g7 `8 C& A
    K- C9 Q0 ~' w3 u( |- L
  4 h9 x. J3 S2 X

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

<session-config>

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

     </session-config>
4 C7 w8 V. M5 [  Z; T

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

invalidate()
) @% s+ ^- v3 ^" ~8 H

     getCreationTime() :long

    getLastAccessedTime() :long

    getMaxInactiveInterval() :int

     setMaxInactiveInterval(int)

/ g1 p, P7 p! E' s8 L

• 描述会话保持状态的基本原理
    \. @6 ~6 z! j7 P6 d% G
    `! M3 V: L+ k6 c  y5 a8 Z
  ) P- [2 A: o  d

5 X8 k2 v% P7 }9 d7 O/ V* y! R

    client server

' b2 O/ g4 W# Q* c

request
% _, N* i7 f* k/ e, D/ Z

response (sessionid)

request (cookies)
# @8 O' q  w( B/ }

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

• 请描述session和cookie的异同之处
  
  
  8 ^  F7 _( I( t, e( D8 L5 l# O

& K# M$ W( N" |7 I

• 如何读写cookie，代码示例
  
  
  

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

response.addCookie(c);

读：Cookie[] cookies = request.getCookies();
5 v1 Z' E! w5 R

        for ( int i=0; i < cookies.length; i++ ) {
( a( @0 F8 Y3 d" [4 @

            String key =cookies.getName();

String value = cookies.getValue();
6 R- T! T3 C0 b. m+ S  }

System.out.println(“cook”+i+“:key=”+key+“,value=”+value);
0 K4 Z' J7 q" X* a' T

     }

• 什么是URL重写，如何实现，代码示例
  
  * X9 b8 d, |0 W; A
  & Y7 m, `& m! r8 b, V

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

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

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

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

+ X# g! u& S0 c, E; _

• 描述web应用的4种认证技术
  
  ( [+ n% `5 A' V* V+ P
  

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

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

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

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

• 什么是授权，什么是验证？
  ( N2 L, s: n+ \3 p
  + q7 X/ g* T) k  K+ F& L
  : h- G9 S+ w4 ?& r: z, h3 s

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

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

* n( C5 p5 B  r

• 什么是HTTPS
  ! h& k% k0 Q5 n' I
  
  ! v; i9 p7 D" _! m8 [: g: @

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

• 什么是审计？
  
  
  

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

• 如何实现声明性授权
  
  
  

1、标识web资源集

2、标识角色

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

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

在 web.xml里配

• 描述servlet并发问题？
  
  4 o( g  Z  P9 ?( C; l
  

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

• 描述Web应用中的六种属性范围
  ' C+ C, Q7 M& d0 G3 p* _
  ) O& R4 i6 Q" r. F5 O( y$ O
  

局部变量（页面范围）

实例变量

类变量

请求属性（请求范围）

会话属性（会话范围）

上下文属性（应用范围）

% W5 f: }- l; c/ s6 n/ K- h

• 指出上述六种哪些是线程安全的
  
  * {% C% Q& Y2 Q' p. ]0 ?8 D
  ! j2 W1 _; _3 D) z

局部变量和请求属性

* z8 P" ]% l: n# H* t

• 什么是STM？如何实现？
  
  ' M  q! H# k2 \2 L' Q- l9 T& y
  ! i5 y* M( {* F: U

SingleThreadModel接口

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

$ g( C7 F/ f0 y; n

• 如何实现并发管理？
  
  
  

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

使用synchronized语法控制并发

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

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

admin

Jsp
什么是Jsp?
8 R5 c/ d8 d0 M( g9 c2 pJava Server Page    结合java和html在服务端动态生成web页面的技术

* I( i' I$ ~) _) r3 e

' F0 R( k3 {. [) x描述Jsp页面的运行过程？
, q, a6 @( |9 ^  [" b, a第一步：

请求进入Web容器，将JSP页面翻译成Servlet代码
6 l& u7 l5 S+ ?' O4 F2 n6 x' Z
第二步：

编译Servlet代码，并将编译过的类文件装入Web容器（JVM）环境
4 V) i2 y) ^0 n* H7 ~. }5 y% o
第三步：

Web容器为JSP页面创建一个Servlet类实例，并执行jspInit方法
# ], R: m$ k; n; t
第四步：

Web容器为该JSP页面调用Servlet实例的_jspService方法；将结果发送给用户
# L2 i, s' O3 r$ D' R& L; C
2 E+ W) e' D$ z+ s6 v1 D5 j- k
% P; w# I$ z% f7 R
1 M: J# k# G% O! Y- ?; |: f, Y- R描述Jsp页面的五类脚本元素的功能、写法、并示例
+ y( W( l) b9 V  u$ k3 r7 a& V注释 <%– –%>

<HTML>

<%– scripting element –%>
4 N. a* T; ?9 V$ R6 y+ F  ]
; q: t7 S: J. a; T/ P/ ]</HTML>

指令标记 <%@ %> 指令标记影响JSP页面的翻译阶段

1 }8 q% j/ @& z9 g<%@ page session=”false” %>

, l  {9 K1 _8 i/ j声明标记 <%! %> 声明标记允许JSP页面开发人员包含类级声明
8 f$ g- X) @1 X) G- s
0 i. z0 G# b4 Z8 w  d( \- ?0 b' E8 z<%! public static final String DEFAULT_NAME = “World”; %>
' w3 H# R4 R$ N# Z
" z+ Q* r$ g- U& u$ M4 j    脚本标记 <% %> 脚本标记允许JSP页面开发人员在_jspService方法中包含任意的Java代码

    <% int i = 0; %>
# P: |, m+ h5 w- |# t
表达式标记 <%= %> 表达式标记封装Java运行时的表达式，其值被送至HTTP响应流 <B>Ten is <%= (2 * 5) %></B>

9 |. k% Z2 I7 V7 A- b
: C/ f% I' G9 t
" ~8 B/ L4 `0 g0 X描述Jsp页面中的注释种类和写法
7 k- \1 k9 N# K" k9 h# J( b; }5 pHTML注释
2 T) V1 _1 L& _0 c
<!– HTML注释显示在响应中 –>
6 R) d* i& _- N! ?
JSP页面注释

  k& n; W  D9 |! }; f0 s# m1 w6 {<%– JSP注释只在JSP代码中可见，不显示在servlet代码或响应中。–%>

( N7 K: H; q& hJava注释
  t! [' m( c2 o8 @5 A- m( d# x
<%

/* Java注释显示在servlet代码中，不显示在响应中
, D4 T  b7 r3 O: v  |
7 }% N. r7 V9 N$ O6 _/ a$ C*/

%>
/ k5 K, K% u" K; F5 T. n
" h2 C8 M* U$ Y# N
$ D: g' v0 k4 B9 p$ X) I8 m
描述Jsp页面的指令标记的功能、写法、并示例
指令标记影响JSP页面的翻译阶段

<%@ page session=”false” %>
7 `4 v& N5 C, _4 r
<%@ include file=”incl/copyright.html” %>
/ i1 v5 A. V' g( z1 x, z& u! r$ k9 B
<%@ taglib %>


2 N' x% I7 _, I9 _' a7 f! z& n; D- Y
+ N  ?3 y* k' G描述Jsp页面的声明标记的功能、写法、并示例
声明标记允许JSP页面开发人员包含类级声明
" o2 t. I9 I' ?  m! ~8 z- e
写法：
! O+ T4 @+ G( r2 V. g
<%! JavaClassDeclaration %>
: g( e8 p0 V! @2 O- v9 @
% k9 I* U2 ^3 y7 e8 G9 g6 Q) J* H例：
' i" Y6 h  i; D8 K, d
5 N8 W' h6 }$ I' c7 }- f1 ]7 v! j<%! public static final String DEFAULT_NAME = “World”; %>

<%! public String getName(HttpServletRequest request) {
! d  t$ Z5 v% c: H
1 S7 c$ ]: h! e1 T5 q1 Ureturn request.getParameter(“name”);
  e9 i; e' I% l& J3 x! ~1 O& U% C7 P
+ @) J' U* [8 K& N}
& b7 `% c; Y. [
* G0 p/ D; S5 [' ]# l4 V* v) x%>
7 s$ @! X7 v4 f" Q
7 ~' M8 e* u7 U  F+ F3 R( y0 g<%! int counter = 0; %>

4 n4 R* e8 P4 V: T
& \! m: p3 F1 ^# A8 D2 s" F
5 _! d0 [* ^: _. g描述Jsp页面翻译成Servlet的规则
jsp中的注释标记被翻译成Servlet类中的注释
3 [5 O, v% _: N9 m
1 M: R* U4 P. C+ Rjsp中的指令标记被翻译成Servlet类中的import语句等

% |, a/ P. _# V% \( sjsp中的声明标记被翻译成Servlet类中的属性
7 Y% `/ h/ d! ]4 b# x, M
jsp中的脚本标记被转移到Servlet类中service方法中的代码

1 {3 n9 b; O& E6 P8 H$ U% Ojsp中的表达式标记被翻译成Serlvet类中的write()或者print()方法括号中的代码
. P( [1 z4 N) d/ V% \" N% Z


描述Jsp页面的九个预定义变量的功能、用法、并示例
+ S" \) |8 B7 J6 F: A! o+ Rrequest 与请求相关的HttpServletRequest对象
* H; g7 X6 _1 b5 {+ R
response 与送回浏览器的响应相关的HttpServletResponse对象
4 @; s2 l. _  i) r
out 与响应的输出流相关的JspWriter对象
; I. M' Q: C, A+ ^8 i" s& l
    session 与给定用户请求会话相关的HttpSession对象，该变量只在JSP页面参
2 A7 j5 r& l6 T
8 j6 B1 `* a2 V: e与一个HTTP会话时有意义
% B+ P8 L) Y9 D* F( _
1 p) j# R  l( N$ l. B: x    application 用于Web应用的ServletContext对象

' \, u8 T- K* y& _8 n. H9 k1 Aconfig 与该JSP页面的servlet相关的ServletConfig对象
+ M. B6 K3 y0 c, t' O7 |
/ a  i$ t6 O) W; z$ }pageContext 该对象封装了一个JSP页面请求的环境
2 ]; r$ g5 F! r5 g6 Y, o- E9 {/ D
; c  x# z6 f' M( y# D( Y* l( b9 P' Qpage 该变量与Java编程语言中的this变量等价
+ e$ B( W, W( [5 [
4 P. f* m; X; L3 J1 K4 t# [6 a    exception 由其它JSP页面抛出的Throwable对象，该变量只在”JSP错误页面”中可用

; x$ d, E* B; X  K4 p6 a2 j
6 ]) |1 W2 P! n
page指令的功能，写法、并示例，并描述它的如下属性的功能和用法：import、session、buffer、errorPage、isErrorPage、ContentType、pageEncoding
import import 定义了一组servlet类定义必须导入的类和包，值是一个由

+ P) M$ j% }9 s0 z: K) s; v逗号分隔的完全类名或包的列表。
1 I9 |2 M. b* I# X. _( B; ]
5 J( A8 P9 d2 q' T2 qsession session 定义JSP页面是否参与HTTP会话，值可以为true（缺省）
  E0 q, h0 P  w4 @: [, D
2 K3 y1 p: T9 y( c! ]: j或false。

+ e) }0 D! D3 Y2 M. e! \  v) ^% cbuffer buffer 定义用于输出流（JspWriter对象）的缓冲区大小，值可以为
$ \1 k- y8 `+ V) m  W% l/ Q1 L
8 F+ A$ L4 C, E. K3 hnone或Nkb，缺省为8KB或更大。

errorPage 用来指定由另一个jsp页面来处理所有该页面抛出的异常
: v% d7 m0 i3 F- P! S. [5 @
isErrorPage 定义JSP页面为其它JSP页面errorPage属性的目标，值为true或

false（缺省）。

1 L' r' e2 y, wContentType 定义输出流的MIME类型，缺省为text/html。

/ i; P# m' `, ypageEncoding 定义输出流的字符编码，缺省为ISO-8859-1

0 x" y+ I9 t5 C4 ]- j& k; m
+ ^# |0 x9 N+ w4 {. n& |: t; F3 g
描述MVC各部分的功能？MVC的优点？MVC的缺点？
5 d- D7 T( Y: EMVC各部分的功能：
  l* L% }* E2 H' \& M# a$ r" q
  D5 p( P: j) B" a! UModel（模型表示企业数据和业务逻辑）

9 ^/ P1 C: J9 E2 ^封装应用状态

  z+ X8 H. A% T0 q# C% A" {响应状态查询

9 f, Z( C2 y1 R! M* b* j: J暴露应用的功能

Controller（控制器接受用户的输入并调用模型和视图去完成用户的需求）
0 z% t' B' [/ F5 n, L9 L" |9 u
验证HTTP请求的数据

将用户数据与模型的更新相映射
& a* ]+ r, ~: V% i9 {; O
选择用于响应的视图

. H1 H& S$ ^3 ]) J, v" K$ FView（视图是用户看到并与之交互的界面）

3 ~0 W% o- p$ C产生HTML响应

0 `; E% t2 k) w- `: d" C请求模型的更新

提供HTML form用于用户请求

MVC的优点：
0 n3 q9 L* p/ D3 x. b
        低耦合性：视图层和业务层分离
7 D+ l% b- e9 M9 E; u' m
0 y! [% L0 p# x8 X: U高重用性和可适用性
7 c! v" E: M, K9 J& _7 E5 @" g
1 U. F9 L) d* l' i* x7 g较低的生命周期成本

快速的部署

( I  W! |# ]3 `) d$ `& d- b可维护性
6 ^8 K+ P, W( h
( }! e. V9 ^3 n有利于软件工程化管理
- Q  A3 S5 s/ @/ b
提高软件的健壮性
- S1 g' i, u2 e7 n. o# b2 U
MVC的缺点：
( r. x+ S  T( C- R- K
4 G- r, ]; o3 s        工作量大，增加工作的复杂性，MVC不适合小型甚至中等规模的应用程序
1 }/ a! H+ K' m$ Z6 Z
5 B8 M4 ~, y) N; o7 g8 O
8 x0 m. A+ ^1 c/ }/ F7 `+ D
什么是Model 1结构，以及结构中各部分的功能
9 a1 `* y4 d. {3 u, ~结构：jsp+javabean
( d: p2 r) }: e
* q; s/ P: E1 KModel1中使用jsp来处理web应用中的视图控制部分
8 Y5 y/ F# E5 h) }' E" P/ ?
Javabean收集参数

! `' a! ^3 {5 ]' |
& L: T7 _7 B$ F, |" ?: I
什么是JavaBean?
用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。
: {* R. f* b1 y  U4 ]
) H) M" M+ u% a- `* m; A
9 H; q( D$ G; m5 D
JavaBean的规则？
1 S- v) [4 `; Y  m( V8 d3 `' t6 y使用get和set方法定义属性
) I/ _# b2 f# l- w0 {' n( c
一个无参构造方法
4 C( X6 b% I: z) l& v) E1 [
无public实例变量( 所有属性私有化)
  w& m. L9 w2 {1 @- I% Y+ ^$ K& E! w


( C  S, [5 C( O4 H什么是jsp标准动作？包含那些？分别都是什么功能？如何使用？
JSP页面中使用类似于XML的标记表示运行时的动作
1 [+ ^' N- H6 T  P: X, L) ]6 ~( F
9 S& P/ g2 a$ l  J4 X* Njsp:useBean

4 N- R% q; i7 ]3 Y* f9 Njsp:setProperty
: C/ L2 b  B: F! o
jsp:getProperty

jsp:param

jsp:include

& o+ B+ T. p- l' D4 q0 S- b; o9 u& wjsp:forward

- N  A3 b" x  p1 i% y
5 V6 f/ F% g. k
用代码示例如下标准动作的使用：useBean、getProperty、setProperty
& {$ Y6 R$ Z$ Q# F- {6 L2 D<jsp:useBean

3 e9 k3 T! N1 j3 Z& K1 h# kid=”myForms”
3 ^1 G2 W# M- c& m, L' y; K
class=”com.base.mystruts.forms.MyActionForm” scope=”session” />

    <jsp:setProperty name=”myForms” property=”name” />

& j6 T  I4 V: G- P/ Y8 t<jsp:getProperty name=”myForms” property=”id” />
( e2 O/ x# A+ T

# f/ X# ^2 {" t5 n9 B
& t8 g' X7 v$ r& }/ b+ g描述说明Bean的四种scope
1 i: w& m: m- ]- X1 p" m9 |, v2 P- R4 Y' @page
3 d% f, s% V9 A  w+ A; f
/ f. X1 }5 _, J2 x$ d! G4 krequest

session
. T- g, c6 i/ C: |4 n% ^- N
application



  z) b  j) l& Y" C& m* o描述说明页面上的字段和Bean中属性的对应规则
id 指javabean的变量名
1 Q# Y1 S' |+ @+ r
class指javabean类的全路径
1 T: Z3 G/ t: r/ @# x
! j0 T1 }7 t. L+ U4 L& ^scope指javabean的应用范围

name指所用到的javabean的变量名

    property指javabean中的属性
# d# r3 L# g; D$ J, C5 x! ~


$ o& Q; u" F, b3 ^3 j  O/ M. E描述useBean动作的处理过程
5 T, K& Y5 x7 ]1 x+ Q- o3 e# J; t使用id声明变量
- k) R) {, I& q% j6 h  [- D( H' R: s
. {3 ^' P" M9 P- W9 V; ]) B5 P试图在指定的范围内查找对象

如果没找到

创建一个类的实例
& X+ f3 I; H( J. R+ O
执行useBean标记体初始化对象

如果找到
- s! d& j. V1 U2 |
     将对象转换为类指定的类型

# u9 J+ z4 h  q' Y, v7 {. M6 H5 ^7 i

0 y# a# e  _$ E1 Y描述forward动作的功能
& P9 P. Q) `/ X使用脚本代码处理请求时，可用jsp:forward 动作产生一个不同的视图，
1 L3 K3 f5 O, _' M& s- G
2 W- e% j2 j( l( W& h4 T6 Y7 v使用同一个request：



; E8 ?1 A; z8 o5 x什么是Model 2结构，以及结构中各部分的功能
3 k% U; [! o# |- l/ Jjsp+model+servlet
2 u% M+ Y. D+ N3 l+ E  U' n% |# u
7 Q/ f* e; w! q+ P" r' VModel 2架构使用MVC模式，JSP页面充当视图，Servlet充当控制器
& W/ i/ E* Q; j/ i  g# F
* K9 C2 k+ \1 t0 N2 c: fServlet控制器：

验证HTML form数据

调用模型中的业务服务
& ]% c1 Q- X" Z9 z9 G) t
4 x; i' h! u+ W& P( r6 N+ N存储请求（或会话）范围内的域对象
' D% a, M7 K0 I& i
选择下一个用户的视图

6 d1 a  j/ W) g3 f' Z2 ~JSP页面视图：

5 \' z" |- T. v  ?' A使用用户界面（在HTML中）

        访问域对象
2 s# t# ?0 R( b2 O; K


如何获得分发器？分发器的功能？
: c5 H3 q$ y/ k6 k8 k上下文对象中的分发器：
4 b8 {/ S$ H0 n
$ j2 h& q4 c7 I& iServletContext context = this.getServletContext();
+ ], z+ L$ N7 G, o$ [* m+ a
7 C/ B: D4 B: b! ~# N" gRequestDispatcher servlet = context.getNamedDispatcher(“MyServlet”);
1 ~$ b$ v: `4 |5 I
servlet.forward(request, response);
" ^( b# \& X3 S8 v% Y, f
; _' @& E" [  F- o" j请求对象中的分发器：

RequestDispatcher view = request.getRequestDispatcher(“tools/nails.jsp”);

+ }0 E2 e  E- I4 H& Y( rview.forward(request, response);

3 m9 w0 D3 m3 S) O: v2 p可以将请求转发到另一个jsp页面，并保持请求的传递性
9 g/ e! G6 q; @& P5 W6 t& f


% m3 b9 Z& p' K3 y, uJsp中页面跳转的两种方式？
使用分发器跳转页面
RequestDispatcher dispatcher = request.getRequestDispatcher(“url”);

2 A# d" B2 N: O( ]7 R+ ?. qdispatcher.forword(request);

6 _# U/ e5 v7 O1 l& t/ Q  K3 R/ k* b    特点：保持请求的传递（上一次请求中的数据，在下一个请求中仍然可以得到）；

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

* k% ^3 z2 k: Q- f' X- v使用重定向跳转页面
response.sendRedirect(“url”);

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

8 m7 W- `6 }8 a, S' U5 ]+ i7 f        重新定向的页面可以是任意的URL
6 o8 l: x1 c  {: h$ d
7 V3 n) q# X7 O) ~) ^+ s

描述Jsp中引入另外页面的两种方法，并比较两种方法的特点？
<%@ include file=””%> 在编译期间把另一个页面完全嵌入这个页面,可以说是一个页面

在这里可以共享变量

/ x  }3 G! K  ?" W: [5 S& \<jsp:include page=””> 动态的再运行期间把另一个页面加入这个页面,可以说是两个

页面，不可以共享变量
- P! g: y9 U6 V' N
$ y7 R# |: U# f

什么是自定义标记
5 k8 C) _' l+ s: a( V* b, S自定义标记库是一个Web组件，

包括：

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

' j/ |: ?! f" ~% U4 K  I, C所有相关的标记处理器类(*.jar)



: b$ d3 {1 f; E3 I  G描述使用自定义标记的步骤，以及每步详细的工作
! q+ z" I; G  @! J5 n$ F使用自定义标记前，要拿到.tld和.jar两类文件

把.jar文件放到WEB-INF的lib里面。
把.tld文件放到WEB-INF根目录下。
在web.xml中配置。
$ R1 U2 y2 Q; R9 K! t7 W8 Q. i<taglib>

4 h) _; R. I; d* _0 x0 I  k2 `<taglib-uri>http://java.sun.com/jsp/jstl/core</taglib-uri>
3 C# v% |6 r# e# s% d5 E% I1 X
0 k( B) A% R9 K4 l# M     <taglib-location>/WEB-INF/c.tld</taglib-location>

+ U- n6 G+ |$ ]/ I0 b8 x' ^* S</taglib>
. `8 B0 U; c1 F4 G  E8 |6 t
在页面中引用。
<%@ taglib uri=“http://java.sun.com/jsp/jstl/core” prefix=“s”%>
3 ?  R5 T8 P& |( f; B, l
uri必须与web.xml中的uri对应
3 _$ R5 l6 ?, J4 V
prefix是前缀，用来区分是哪一个taglib

0 f, U+ v+ X# i# F% B# _8 ?使用标记
格式：<prefix:tag名称 属性>
1 i9 l, U$ L/ N8 b
: y7 t' x: [) T) U- A+ l& y; Y<s:forEach >

admin

在tomcat下配置数据源
- e/ p* b: Z5 M( u  g: o; E1、服务器与数据库的连接
- Y6 L3 H# e" F( R  ^
配置server.xml文件
( j( X& Y5 @. x2 w
% Z2 s! d' c( g# U/ \9 H: b" g, `% h1.oracle

<Resource name=”jdbc/company” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”

4 H, r3 i' I% M: K; |3 d                        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”

3 F: d  v! z$ {$ o) Wurl=”jdbcracle:thin127.0.0.1:1521rcl”

  ^; V. G& T5 X5 {& KdriverClassName=”oracle.jdbc.driver.OracleDriver”

username=”aa”

password=”aa”
/ b2 p* h$ C" u9 G9 {2 F
maxActive=”50″

7 T7 Y$ ~- R& S) U- {5 rmaxIdle=”10″
. t. A" A- K5 [6 Q  w! z) f7 R: Z
maxWait=”-1″
& j7 I: U$ v' R- ~
( G7 {) e' n7 _; s& G/>

4 d& {& l& e+ A2 l6 s7 A- v2.sqlserver
; @1 [) m- E+ `. \$ B; g
<Resource name=”jdbc/webpage” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”

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

url=”jdbc:jtds:sqlserver://localhost:1433;SelectMethod=cursor;
! i' g1 y4 K' V3 G  I; t* Z" \. T
DatabaseName=webpagetest”

driverClassName=”net.sourceforge.jtds.jdbc.Driver”

- O. }2 C, M, U0 v9 qusername=”aa”
; g' g4 P4 ]. g, I9 q
# M& y8 \% f- ~7 S- Q1 k; Fpassword=”aa”
3 Y* ]3 n/ q# x* \; _5 b; J
maxActive=”50″
$ w- q9 y9 r; c* h7 l8 Q. L, ^1 s
maxIdle=”10″
( r9 J$ x3 K9 ]! j1 w
# C6 E4 g' j/ q$ A( p( T1 rmaxWait=”-1″

. x9 a7 F. C8 a2 t/>

( P5 M9 v, L0 f% O' i( `4 b; k2、配置自己的web应用的xml文件
# ~5 \; f3 L& i* V% o0 |


<Context path=”/eb03web” docBase=”F:/workweb/eb03web”

privileged=”true” antiResourceLocking=”false” antiJARLocking=”false”>
& ?3 {6 q. ~6 G4 U
<ResourceLink global=”jdbc/company” name=”jdbc/company” type=”javax.sql.DataSource”/>
  l6 Q# d8 Y. Q, k/ Y
  F$ u3 r" T4 T2 `$ I3 K: t</Context>
/ @7 f6 R: [" O1 g3 L* ]
/ E) L1 m& ]. u/ ]( w6 V

3、配置web.xml文件

与服务器建立连接
- u/ d6 H0 \$ ]+ H+ {4 U. ~* `
8 s  Q* {  N4 f4 d0 i5 N<resource-ref>

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

<res-type>javax.sql.DataSource</res-type>
- V: l2 Y" Z0 ?# P% n  \& W
0 `% M, U7 z7 ?5 W<res-auth>Container</res-auth>
/ h1 g9 [+ B7 F' R
</resource-ref>

4、在应用程序中不直接与数据库连接，通过DataSource连接池建立连接

, @2 @  J, T9 p2 H% H//1.在程序单独用时设置系统的属性，在tomcat下可以不用配置，

1 n. K1 }0 R5 oSystem.setProperty(Context.PROVIDER_URL,””);

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

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

1 d( n3 G  E7 X" Q3 V) i& HInitialContext context = new InitialContext();
# r, C. p" z  p* h. v) L2 N  e" D0 b
//3.通过上下文对象在连接池中查找DataSource
- \8 T4 p" H6 ^9 ?: i" Y  u
DataSource ds = (DataSource)context.lookUp(“java:comp/env/jdbc/company”);
! m, }7 W2 a5 f3 ^; a
& `0 `! [* m  r( R( n- P//4.通过数据源建立连接
& ?" m% w  d0 V
$ L' f% Q( F8 t, F) |4 h5 Mds.getConnection();

admin

ORM对象关系型数据库映射
4 J' \. _. z% v. D( h$ g8 G) F- f/ y(Object Relation Mapping)

一、映射的特点

- M1 {4 e& n" w# b' p  O$ t1.一个对象可以对应多个表
( L9 ^. d4 J5 t
' y) c- }8 u- O! @. @* ?+ d% {2.一个表可以对应多个对象
- s7 [  o$ p  J  `/ s% Z; M
3.对象和表的关系不用完全对应

! |3 g$ e7 o* U6 X& E( {$ }4.对象的属性的名称和表字段的名称可以不同
+ f+ l* ~) {; M& `# [
( K# @& _# i& k8 \# J/ d5.类型可以不同，但数据类型之间可以转换

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

% j7 g: i" y- ]- X7.数据库中有主外键关系时，对象中可以有，也可以没有
8 }+ W. J0 n. v  X! ^/ a/ w

4 k2 R& a% ^; i( @* w4 I
二 、有一个映射的描述文件————>xml

8 g5 [9 w4 z2 [三 、怎样实现描述文件————>一段程序

8 H1 C! r3 {0 H' y1 x对象 映射（mapping） 数据库
5 R2 K. s9 b, t6 v- J0 Q
user

* I* c& {+ M& W  Y* X8 Yid=11

7 A0 E7 I& ~4 T5 D$ Rname=”张三”———— > (1) —————> tbl_user(id,name,age,tel,address)

+ B( r( c3 @0 s" gage=25 <————(2) <————

, j" @  B7 D$ [' G& U
* S( M+ J. k; O( J3 x8 {- p* z
: o$ K$ B. S  D7 x* U7 ~. X# ?% t(1)从对象映射到数据库

* X6 z$ B) @& t+ E  ~( V1.JDBC
: Z% m! W$ }- G' p" u/ `6 c
8 _+ c) X* I) k2.根据描述文件来动态拼接sql

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



(2)从数据库中映射到对象
8 E7 z: s" ~, H; _, h' M
1.JDBC

( G; |. W# H* x+ l* i( @2.拼接查询sql
( Q% r  c' z1 E/ O
3.ResultSet

4.Model



hibernate
( x! R4 {5 g3 ^- n2 z  J开发流程：

* p- B7 h: y3 w$ o2 M" [% N是什么？
hibernate是一种基于orm 的轻量级的框架



, n; K+ {# L( \! l有什么？
# ~5 c. U3 H: A. W$ I  R1. session 保持连接状态（依赖事务和连接池）
. m# e  b, h6 I; y) l; b
4 D* o+ u- z5 w9 z( p2. Transaction事务
8 ^: k, S+ r; _& T) d* {6 x
3.
  r% [$ j& N" O; {' b( nConnection Provider 连接池


8 q: J7 |2 i5 C+ N
能干什么？
# ]3 \1 A, }, N1 L1.orm

3 i! d$ p* P0 T( t- i" z2.提供操作数据库的接口，简化数据持久化的编程任务

, l3 x6 B8 \; y* \4 F8 `* E  s
/ [( R- ?0 G, X0 K+ a* a9 a* ]
# n, e- S% `2 A1 m8 G怎么做？
1.搭建hibernate的运行环境，将hibernate的包和hibernate所需要的包拷贝到lib 文件夹下

2.O（vo）

3.R （关系型数据库中的表）

0 c% f# H" a+ ?+ n, J4 {4.配置文件
6 U) N) B# F# _& ]$ U0 U2 R; D
4.1 cfg.xml 放在classes根目录下，默认名字为hibernate.cfg.xml
) U! q4 p. n6 c
3 n. Q( P# [- A. y" a& }, Ka.与数据库的连接
4 }; k* j  R' w* w' p/ I2 B4 J
1 O8 {0 o0 K$ e# M+ B& V: G- h% Rb.可选配置
! }$ d& q( g8 T, J, F, L
c.映射资源的注册
+ A4 q: e$ T" z
* Y# x1 G# \: a2 q0 }4.2 hbm.xml文件 名字与类名相同 并且与类放在一起

a. 对象与数据库表之间的映射
* Y! v! ]$ O! \  x$ g: k3 l
( M. W1 F- v* i5 pb. 对象的属性与数据库表的字段之间的映射
% ~, F9 g* b% p( v$ P# _
c.组件之间的映射
7 e5 P9 q/ L# m; g+ U* N7 M
d.对象与对象之间的关系映射

) F" M% {9 l( ^  g5、客户端

1.得到SessionFactory

4 l, H- ?* q0 ^9 c# k) [( W2.通过SessionFactory 工厂来创建Session实例
- s! u9 {0 N) a- l, u
3.打开事务

4.操作数据库
6 w1 \+ h+ m# T; D& Q% s
4 a" A  v$ k% u  ?. d& {5.事务提交
  B* A& y: a3 a* y! k
' W( v, \' b5 r! Q5 h6.关闭连接

运行流程：

整体流程
1.通过configuration来读cfg.xml文件
( g+ ?4 m/ m) D/ i% f# b3 F! r0 Y
2.得到SessionFactory 工厂（根据数据库的连接来创建sessionfactory）

1 m  C% V8 l7 F+ _9 r9 \4 O3.通过SessionFactory 工厂来创建Session实例

' u2 u  ?! b8 ]: V) g4.打开事务
  g+ _7 b8 Q: ^# Y
5.通过session的api操作数据库
7 }, y( I. f, p, ^+ O3 ]7 Q
6.事务提交
. C+ a5 P5 ]* w- G
, C7 \+ o; y$ W. i8 B1 m% u) f* l7.关闭连接
! O, S' L/ e5 h; A4 n6 D
. H5 m( ~, R$ V. r
0 F+ j# q' t1 ?+ ^6 Z
save
1.to—>po

2.根据model和cfg.xml中映射文件的注册来找到hbm.xml文件
* j+ }3 v& V5 M
; M4 @, p' u, S7 a2 o3.根据hbm.xml文件和model来动态的拼sql
- X9 z$ [/ S8 r3 F  i
/ b- O( v4 F* a% q* {7 G* Y4.客户端提交或者刷新内存
/ L- y) v& i& j% c' H5 w
- Q4 e, v7 Y% A' J5.执行sql，值放到数据库



+ f' j' [7 C# Lupdate、delete
% `) b. Q  [3 Z' R# ]1.根据model 的id在内存hibernate的缓存中查找该对象

; N' e7 q4 O& x% {如果内存中没有就到数据库中查找来保证对象的存在
4 y2 T  i# n# D6 f9 R6 V
2.根据model和cfg.xml文件中映射文件的注册来找到hbm.xml文件
& r4 H. G% d0 b2 U" ]1 h
9 i3 _& p- s, V- u0 Y3.根据model和hbm.xml 文件来动态拼sql
3 N! T3 f" @- v- C1 C8 z3 C
4.客户端提交或者刷新内存
$ \+ @) D, H  l/ v2 B
! R3 @* _/ C; j  r5 ]# _$ d+ D$ m7 M5.执行sql
# W. N2 P+ X. m4 E( _

. ^: ~; N' b* f1 Z3 J% B1 J
9 j* P8 H' c, V" |+ `6 Y4 iQuery
load
& _% o. d; l. [9 w
1 l, r$ O3 K- C4 [4 e1.根据model的类型来找到hbm.xml文件
1 e/ M& P5 d# Y
: g% N# M1 C# y+ h! h# z/ V  P2.判断id对应的对象在缓存中是否存在，如果存在，就直接使用，如果不存在就进行下一步。
$ x7 {; ^) P4 O& A$ G
  K9 v4 W3 \+ }3 T3.用id做为查询条件来动态拼sql

4.执行sql 查询（先在内存中查找，如果没有找到（会抛出例外），就去数据库中查找）
1 Y7 z4 ^9 @( F7 F  {
5.返回一个model类型的对象

8 M% v* G% D& s' `" Q( |% aget
  X% [* h4 k. f2 M# z
    1.根据model的类型来找到hbm.xml文件

9 J1 Q$ }6 G0 R* U' \$ R. s2.用id做为查询条件来动态拼sql
  }& G! }" K  }# O& C  |9 N
8 L" X8 C/ a- i( x. w3.执行sql 直接在数据库中查找，如果没有查到就会返回null

/ g$ a6 W& g, p6 J6 g2 m  S& r: }query

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

# }. ^4 O) q+ R2.根据moedel和cfg.xml文件中映射文件的注册找到hbm.xml文件

3.根据model和hbm.xml文件来动态拼sql
. l% W  _* s/ y1 ?% n0 Q8 Y# ^
/ A- o: X; w- `  g: Y% k4.执行sql查询数据库
0 a) E4 @: I5 @6 e
7 h( I  T) Z4 k5.返回一个resultset

6.循环resultset的值，放到model中在放到集合（List）中

9 A) V: t- Z7 _. Y

& {* n# |# L  N) d谈谈hibernate缓存机制
( m' P* _7 c/ T
; ~4 [* R8 f" i3 h* Y3 W, h缓存其实很直观的理解为放到内存或者硬盘上的一块区域，缓存就是一个缓冲的作用，有很多时候，我们的数据需要经常访问，如果放到数据库中，不是不可，只是效率上低，如果有了中间产物来代替数据库，就省很多事情了。打个比方，去买酱油，不一定一定要去酱油的生产工厂去买。代码中需要数据的时候，可以先到缓存中查找，如果存在，就直接拿数据，不存在就去数据库中取，也省了很多事。
+ W6 @) g0 s# t6 l5 j5 a3 q6 j
  F- R/ Z! E( j1 i! P6 Q# M$ v
# f% k3 h. r) m# ^' L( d/ N( U
0 v; p9 ^8 U; W: t: V( \) \hibernate使用的是二级缓存，有两个级别，分别是Session，SessionFactroy级别，一级缓存是Session级别的缓存，Hiberante来管理的，这个我们一般不用管，二级缓存是SessionFactory级别的，可以进行配置和更改，加载卸载，就是我们平时用的hibernate配置文件中的配置SessionFactory的属性。

' \7 v: ]0 \4 D6 B" _
9 O/ ~0 b9 G" x1 ]# \3 ]: |
' D# C; l- b' o3 ~  h对一级缓存中的session事务进行数据的预存取，数据在各个session的上下文中存在（单例），当session关闭时，就是session.close( )，整个所有session范围内的数据全部清空；二级缓存默认的情况下是不开启的，如果开启，数据库汇总的所有数据都先copy到二级缓存中，这里要注意的是，一级缓存是每个线程下创建的session缓存区域，可以是多个，二级缓存只有一个区域 ，画个图比较容易理解。
. T9 d2 y; }6 Z% J9 x
# k  `9 n9 B3 L9 I
  i* y% ]6 d& a2 E2 M3 O: [' R3 ]5 i
| 一级session缓存| | 一级session缓存| |一级session缓存| |一级session缓存|
9 `! K! E3 ?) O& c  Y/ u
| | | |
0 i$ H9 u# Q3 p4 ^* _+ p% e
| | | |

4 c- |3 |$ d# o—————————————————————————————————
' v# j! S1 a; ~# j3 L" r, ^, A2 g
sessionFactroy级别的二级缓存
/ n3 }4 I9 _% s5 o# W
4 @1 |+ G( D) h8 ]" @) Z# O, ]——————————————————————————————————————-
0 U" w" m" G( y
2 _9 ]! u) x9 g|
5 X5 v/ C& ?1 D- O, ~
|
# v; C( V- s# m* x4 ~
* u+ i$ [7 Y# I1 _$ Q$ s|

' r: t: X! q1 ~: E9 q0 ~——————————————————————————————————————
. T, O4 ~" W+ B+ _  _8 \
DB
% Z# ^! b) Y( e7 ^, V
  p& M& Y' D* G—————————————————————————————————————–

admin

Spring

• 是什么？
  
  

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

• 有什么？
  0 L$ a4 j# U, W& E, |- `8 L4 E/ b
  : B2 X$ a0 R- G5 Q: l3 W4 n1 _7 m

每个包的功能：

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

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

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

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

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

AOP ：面向切面编成

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

• 能干什么？
  
  

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

8 X& e! f: @+ \' Q0 h0 K7 P

• 怎么用？
  7 d3 x+ R3 z4 V
  - L' M- c7 w2 p& a" y1 p
  • 搭建web工程，引入spring的jar包
    
  • 在web.xml中添加如下配置
    
    + w- Q1 {# O+ z. ^3 r
  
  % N0 C/ X6 W% ?) l
  

            contextConfigLocation
! ?3 M% F& K' d1 B1 @

            classpath*:applicationContext*.xml

   
- a4 `/ Z2 N" ?( E

        

            struts2
; r3 ~, W" S8 E

            

                org.apache.struts2.dispatcher.FilterDispatcher
  d/ P/ R; q* u+ ]/ d3 p

            

        

        

            struts2

            /*

            
1 h+ `! F0 _% e

                org.springframework.web.context.ContextLoaderListener
) c9 z; g% c. M$ _/ b+ r$ X  q% T

            

        

• 部署
  
  

& V& u5 J% u% `8 Y- n; y3 N5 \  A
6 E4 N% |) R( K* b/ e& S& N1 r

• 容器和bean
  " t0 E8 E# \0 D3 @

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

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

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

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

* f8 d3 D; R" y# M, ?0 G

• IOC控制反转
  
  
  
  & m+ Y/ ^4 n/ T% c
  $ U# ?# A) A9 G6 U, t. r7 G
  从前的应用程序想要得到A的实例他会直接主动的去拿，当用了sping后，应用程序由主动的去取变成被动的等待，由spring来控制应用程序所需要的对象
  
  
  • IOC的优点
    
  1.可以通过IOC来获得实例
  2.可以通过DI来获取注入的资源
  • 配置IOC的原则
    & k3 B9 e; g4 Y& f7 ~' j$ X
    • 一定是可变的资源才采用依赖注入
    • 一定是层间的接口或者是模块之间的相互调用才采用依赖注入
      

& l# G" i$ ?3 v6 t: b4 A) b

• DI依赖注入
  

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

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

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

例如：

在配置文件中

, z8 B! W& o2 U$ e/ L2 N

: W; a. ~6 Q6 Z# i' C) X

在应用程序中

Public DBDAO dao ;

Public void setDao(DBDAO dao){

This.dao = dao;

}

3．构造器注入

9 l7 U+ G) Q" n, v

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的思想： 主动—->被动（追加功能）
& l2 M9 V& d. x* K. h( x3 Q4 B

3.AOP 的概念
4 F9 J# B9 |% E5 K* L

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

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

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

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

5.引入 ：扩展的功能

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

7.aop代理 ：实现机制

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

4.AOP的事件机制

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

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

3.找到切入点

4.确定连接点

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

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

" d3 O" e) L3 W5 U8 q- f3 w
. l0 b5 H4 x! S- g. B

  y- T! G5 y) W0 b9 C


; Q# w- b& ?: _

5. AspectJ

5.1.在xml中配置比较烦琐
( K) f! N4 _0 z6 K  i/ B9 ^9 `

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

/ D1 z4 w) t: d

         


         
; v6 B% q5 u7 y6 V, p6 [6 b) S

        
0 j( O! I% Q/ h1 }

        

expression=“execution(* com.javakc.aop.MyTarget.t*())”/>
$ A9 [7 L8 S) q0 `

        

        

   

5.3.使用注解的方法相对简单
% ]' M; d! V4 Q8 r6 j+ k

@AspectJ的基本语法

1.@Aspect声明一个切面，将一系列的共同的功能定义成一个切面
/ I5 ]) x6 l' w2 d

直接在类上定义@Aspect

2.@Pointcut声明切入点

2.1、用一个专门的类来定义pointcut，类中的方法名就是该pointcut的名字
0 _9 h- C. [, E- p' d5 \4 z4 Q

2.2、可以使用匿名的pointcut

2.3、执行切点的几种方法
) f& T# `0 [, K& M4 M: }

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

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

within（”com.javakc.spring..*”）
9 N; ~  G, E% k9 b$ F

2.3.3 this 指定到实现接口的所有的实现类
% D, ?; b$ u. v* O  ?4 u

2.3.4 target 指定具体的实现类
/ N) u( e$ Y4 k9 ~5 e+ L

5.4.advice的五种类型的示例
0 f% E0 V+ X* }7 M$ [; ~

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

5.4.1.@AfterReturning(pointcut=”” returning=”retVal”)
4 D  [3 ?  [; z2 Q0 ~3 \

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

在注解@AfterReturning中必须加上pointcut和returning两个参数
  z3 ?- E8 ~0 [, k' R4 S

pointcut指所要监控的目标对象的方法
, x$ S+ S7 l- t  m

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

完成追加的功能
* }% D" s  }, }( p3 b

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
( a- k! t. p; i) r7 f. ^0 g4 h3 ~

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

(2).

     2.直接引用匿名的pointcut
6 }- `- U* R" G4 n0 \( G0 Z7 M

     (1).@AfterReturning(“execution(

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

     (2).@AfterReturning(pointcut=
1 ?% n' w6 k2 s

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

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

@AfterReturning (pointcut=”com.javakc.spring.schemaaop.TestPointcut.t4() && args(str)”,returning=”retVal”)
' W9 |9 Y' ?4 h" `* o3 i, s

public void testAfterReturning(String str,Object retVal){

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

    }
% ~5 \# H* C% D, h- \( g* N* J

5.4.2.@Aronud
3 J; k& V5 [, T1 c

     注解@Around环绕追加功能；

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

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

     通过ProceedingJoinPoint的实例的proceed来调用所监控的
4 d$ O3 R+ ?( C; A3 r3 a

目标对象的方法

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

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

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

&& args(str)”)
. k3 d- u1 ~' |' J# n; b

2.直接引用匿名的pointcut

     (1).@Around(“execution(
5 m& L. v+ \2 |9 b5 i; Z! m) f

* com.javakc.spring.schemaaop.Api.test1())”)
  G  y' u! Y/ l' V

     (2).@Around(“execution(

* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
) {  Z+ H" h. L

// @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{
6 w. O; J( F3 B7 G+ h) p3 e- K

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

        Object obj = prj.proceed();

        System.out.println(“around1==========after1pointcut==>”+str);
5 ]$ `5 l$ o2 Q6 G/ ?

    }
8 i& R# v4 L) X

5.4.3.@Before

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

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

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

(2).@Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
, G4 I3 B0 R1 l+ f& @

注意args后的名称与参数名相同
' Q; z4 K7 s+ A8 S. ^* l

2.直接引用匿名的pointcut

(1).@Before(“execution(* com.javakc.spring.schemaaop.Api.test1())”)
0 P% o, N# a; H8 n

(2).@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
8 D  B' W* G" v* }

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

// @Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
0 O  f* O  l1 M

@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
) d" {6 M4 p) |0 M3 a% ]. K

public void testBeforeParam(String str){

    System.out.println(“before1=param=>”+str);
. |9 L# C0 W9 C

}
: \! h# p/ K9 G9 U

5.4.4.@After
  a2 P- i( F+ B

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

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
% d( n2 L% d2 G: R; n0 l

     (1).@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
4 C2 Z  G- W9 Q( A! T" {; s

     2.直接引用匿名的pointcut
- o% r! l+ t/ P0 C8 G

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

@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
/ p- N; M* e6 h% x  F' A  N7 R

    public void testAfter(){

    System.out.println(“after1== >pointcut”);
2 @3 Q9 h8 F: V9 C4 v

    }

5.4.5.@AfterThorwing
+ b/ c! D7 \7 C0 P

• 描述一下spring中BeanFactory和ApplicationContext的差别
  
  

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

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

代码示例：

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

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

' D& b( L& W- f6 E5 D4 a

• 谈谈spring对DAO的支持
    Q! M2 Q+ ?& Y5 g# t
  

Spring提供的DAO(数据访问对象)支持主要的目的是便于以标准的方式使用不同的数据访问技术。
+ i# e; G5 N0 R; j0 `' J6 C7 F

简化 DAO 组件的开发。
. W+ M9 }, n- H3 Y0 wSpring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法，用来简化代码开发。

IoC 容器的使用，提供了 DAO 组件与业务逻辑组件之间的解耦。所有的 DAO 组件，都由容器负责注入到业务逻辑组件中，其业务组件无须关心 DAO 组件的实现。
2 t- x9 X9 A3 ?- b# p; H

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

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

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

• 谈谈spring对hibernate的支持
  
  ; j: F' M8 W5 E4 I6 B$ B$ x

在所有的 ORM 框架中， Sping 对 Hibernate 的支持最好。如 SessionFactory 的注入、HibernateTemplate 的简化操作及 DAO 支持等。另外， Spring 还提供了统一的异常体系及声明式事务管理等。
1 ^" _$ M) e  M4 F

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

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

1 J$ ?# L( ~( }9 u

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

        

            oracle.jdbc.driver.OracleDriver

        

        
5 t: ?+ L/ I# x

            jdbcracle:thinlocalhost:1521rcl
4 J1 o9 u: x# V# M9 Y# ~$ K

        

        
: D1 Q, G- ?+ m

            javakc2

        
4 x" g! F3 V2 z/ ^2 w& a* f$ J( @6 S, F

        

            javakc2

        
5 D, A4 T5 H* e  k, h! M0 x

   

2 A; m+ p3 [+ p& B6 C8 N. Z

   

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

        
5 ^9 ~3 o# S3 L4 [0 q% j6 |

        

            
1 A* U9 l0 G0 G7 ^# `

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

            

        
8 X8 Z! g0 M! g5 M

        

            

                hibernate.dialect=org.hibernate.dialect.OracleDialect
% n! o: N9 W2 o' c: n2 s

            

        
7 ]6 X- q8 F' n# Y4 Y" d- D& f# a

   

   
/ V6 `8 l1 {% M- \) S4 p

        

   

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

   

        class=“org.springframework.jndi.JndiObjectFactoryBean”>
. A% K6 e2 I& a6 B9 Q

        

            java:comp/env/jdbc/myds
4 ^% S" Y- E+ V- `( `8 _: P

        

   

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

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

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

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

   
$ I  B8 d6 {. |" h  U+ h/ [# R/ z

        
; ^/ L1 ~  `$ F6 F: {" o1 b* ^. o$ U6 b

   
: T; u. `' W" p- ~* |9 x" F% L

   

        
+ ?1 w. }& M0 [' ~% S

            
# h1 i+ E6 h. J8 z

        

   

; W6 J& {- C+ z1 C$ d7 g$ o

   
& H& W3 p' _/ b$ t! ?

        

        

   
& n1 N) p# p4 a" a+ o; G8 `

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

! t4 x1 a. N- t2 H: F6 X: N

Spring2.0之前事务的写法 6 V/ E4 |5 s( H% L, } ' H' I& ]  }7 I3 S7 s9 g        class=”org.springframework.transaction.interceptor.TransactionProxyFactoryBean”   @6 ]6 H( X. u. Q5 r# s. F  v! @        abstract=”true”> 5 Q( `6 s7 H  ^! R3 L" g$ x 8 K$ E. o  N3 @9 b+ U# s* G 9 n9 b9 V0 G( {" R - p( d% ]5 Q/ x                PROPAGATION_REQUIRED,readOnly                 PROPAGATION_REQUIRED : i6 a+ U  R8 A1 X/ x 3 J1 t6 S: C4 n0 {# D

• 谈谈Spring对事务的支持
  
  

1、声明式事务管理：

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

2.做法：

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

2.2

2.3 注入数据源

" ]! m. t  }" z5 s* v
& N. a4 ~& C/ F4 ~
% s/ C! F9 ~/ g: \/ L! m' @
9 `5 H0 E& D% ^% e* E) i

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

1 s  H/ a) o: v; }1 P

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

* d, I% F, X" S2 ^2 W2 g8 [+ R0 m



$ M0 D* I' g+ K; {" l0 U9 b; ^

2.6 定义切入点

8 b/ D0 y! \7 t- _# X. n
# A! E7 [( x, R  r. }$ U' u

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

1.注解@Transcational

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

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

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

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

- n/ L( ?5 u# d

7 l! G1 l% }8 ?4 V

如何在Spring中使用JTA的事务：
- Q$ h) G% V9 Y

admin

事务
+ T- H  B$ f9 C1 h. Z' xACID
5 a2 E3 u! U) n( w- w8 b（1）原子性（A）：一系列的操作具有不可分割性，要么成功，要么失败
  }4 n3 r2 i1 W9 g& l
" G1 l- E9 L* u8 d（2）一致性 ：操作的前后满足同样的规则，保持平衡。
, s! X" S8 H" L: w0 e$ p- m
% C. ?4 M" J+ ]' l) W（3）隔离性 ：在事务运行的过程中。事务内的数据对外的可见性和可操作性（必需由数据库的支持）
# G* F4 C+ Q) ~
（4）稳定性 ：保证数据在事务的操作的过程中不会遭到破坏，而且是永久性存储的
4 x3 |( X5 M' P" U5 B

+ Y7 `: S! Y8 T, i" F2 O% i+ e
  r! `/ B1 L# W  n/ \事务模型
! C8 p0 _+ ~; P" H% a# E; l4 w8 B（1）经典事务模型又叫平面事务模型（JDBC） 事务不允许嵌套

/ W8 H! V" [, \' m" D0 G, U9 P0 N（2）嵌套事务模型



0 J3 w' X- H0 F事务的两种方式
（1）声明式

  \, e/ k( P! ^( t# ~2 h在配置文件中设置以下6项

（１）.required

如果客户端没有事务　在bean中新起一个事务
$ B; v0 z/ g1 c( @9 c+ R+ g
6 n, y' p3 B' Q7 g6 J& l如果客户端有事务bean 中就加进去

(2)、 requiresNew
2 y) {( ^2 l- W9 q3 e: U
不管客户端有没有事务服务器段都新起一个事务

1 c9 {+ k1 C! P+ j如果客户端有事务就将事务挂起
7 {# \! E! U7 e/ `
2 |  ~" t' x4 _% E8 {(3)、supports

如果客户端没有事务服务端也没有事务

) q8 E* r: L* E/ `/ e( N4 `! I4 W0 M如果客户端有事务服务端就加一个事务
4 m' F8 D4 N6 J: J8 y3 N( d
(4)、mandatcry
# X0 }0 g0 E6 _# F! I) P5 N
如果客户端没有事务服务端就会报错
+ Y% w) Y  o4 o6 W2 D0 ]
0 D- T9 I9 ?' w7 S) n如果客户端有事务服务端就加事务
, |1 p( i5 O7 \
& _1 E4 i8 N1 J' N; B# e(5)、notSupported
4 \/ \3 K( D7 s, e, S3 r
不管客户端有没有事务服务端都没有事务
  J; x& M8 H% m
如果客户端有事务服务端就挂起
, N0 [  [; h" ?- M$ f/ T" w& y
' z. D( b* O# C/ A2 _* q& x$ L8 _: F(6)、never
1 Q" g( G3 _9 X  ~
不管客户端有没有事务服务端都没有事务
6 A- B* e$ U& I2 o& x( z, f
如果客户端有事务就报错

( q$ B2 k- L. |, N（2）编程式事务

: |$ B, a8 B) z3 qJavax.transaction.UserTranscation

9 i" D/ @0 P" ~JTA 事务可以精确到事务的开始和结束
# C0 Z. o+ J- P5 `4 @

6 \6 [6 q; z1 m
* \0 J/ i5 T5 Y/ k$ ~事务的隔离性
Read-uncommited
1 s$ _' p. }2 \7 U3 ?
' `2 O7 R% L' Z读取未提交的数据（基本上没有锁）脏读，存在不当读取的问题。

  ]9 j4 H6 Q& \' `, K! sRead-commited

$ Z; ^7 `) b3 A8 M读取已提交的数据（行级锁）
* Q: N( z4 L0 Q3 w
9 T/ ^- d; y( ]5 i% @无法读取已经写入，但没有被提交的数据。
! o. U2 H$ K; Q: A
4 e. [9 q$ h8 h& {  N4 pRepeatable_read

读取的数据不允许修改或删除
) \$ S  I- h# t; u
不可重复读（行级锁+不允许修改/删除）
. b3 x& [9 r+ u* @
Serializable
( l0 o7 S  d( t7 e
幻影读（表级锁）
( Q0 c$ S( @  q# x
& h6 B( }9 ]' y$ c9 B7 m6 g9 ~/ z
" G+ T4 I9 r; o& f: L% w3 ^8 w
# S9 ]% n/ |0 A) B% S. Dstruts
开发流程
. h; L' p. ]! p4 t/ i
1、创建表单
& Y( u  |9 f8 W: L9 Y* W
2、从表单中获得输入
7 {& \) L, O6 T! v
. h$ Y) g; Q9 {  _4 A8 p3、处理输入（业务逻辑）
! E) A7 T" d# ]$ B9 h& l9 z
; D6 P$ n. X9 ~! Q. A+ ~4、根据动态输入改变输入流
  q# F' i2 B: @% f
要完成上述四步，我们需要创建
9 Z9 [* U/ [2 E) H
1、一个ActionForm
6 z, T5 \' ^5 L* d* @
2、一个action

4 ^# X; F# H% k5 b# ~/ \3、一个配置文件struts-config.xml
1 [2 Q7 P; |7 M0 m- Y
2 T0 \( j5 v7 \. w! Z  l; K( P4、创建页面

创建ActionForm
4 W  o  T* c4 l; G
1、写一个类继承ActionForm

2、私有的属性
5 \( W  C8 a$ E6 [* c4 `- G
7 u; H* d$ {1 U3 ^! h3、相应的get、set方法

4、重写tostring、equals、hashcode三个方法
+ Q# \2 r! n% D. R9 P
4 I5 d4 }2 s0 j% q* D3 ~5 S创建action
# I% o5 U& v* \4 u, G% y& T) a  h, b
1、写一个类继承Action
$ r% s6 }2 ~6 x( `& C7 z
5 a6 }+ i+ V% d- ^8 I2、实现一个公有的方法（回调方法）

3 A6 J4 H- U9 |* y- v' f) ?( V* Apublic ActionForward execute(ActionMapping mapping,

ActionForm form,

HttpServletRequest request,

HttpServletResponse response)

0 A. q  k! Z! n6 H6 q8 ?% b( _7 h{
& O7 _7 G3 ^- F/ i& v
//1.收集参数

MyActionForm myForm = (MyActionForm)form;
% S% @6 d0 t: T
1 h$ G& T- r0 }" T' ^$ R5 F//2.组织参数
3 Z  r& [! [8 i6 D! n


2 s' [! j" `" y: k# ~: E- }//3.调用逻辑层

' b6 Y8 s5 r8 _9 Gboolean flag = true;
7 y" a" U& t- V2 T) f! M: @
//4.根据返回值来跳转到相应的页面

ActionForward af = new ActionForward();
3 }6 M; P# @7 ~; E
if(flag){
1 Y( H. L8 m+ Q) a, J
af = mapping.findForward(“1″);
& ~$ u& c% h1 ]! J7 k3 W& B8 @- j
7 c; l2 B3 c  u. W}else{

af = mapping.findForward(“2″);

}
) ]1 B& E3 B# O1 s) |
return af;
$ C4 S  ?& e3 \3 W$ p0 j3 r6 Y; q1 X
}

配置struts-config.xml文件
5 Q$ v  Z1 U0 ]" k% o" p. N, q7 T
, ~. t3 R7 J  H/ K5 r8 {3 I1 x1.<form-beans>

3 f: c0 a$ f% E; G+ I- X7 N<form-bean name=”myActionForm” type=”全路径.MyActionForm”/>

<form-bean />
3 d( I& \" S9 k+ [2 b
% [* U: o( `: n- ^  x8 V  a7 V' k. g1 y</form-beans>

9 {8 I; I& O* w5 }: r5 T2.<action-mappings>

<action path=”/sll”

9 c3 A6 w1 @# i+ A$ @/ Oname=”myActionForm”
: {% O& N+ y$ m. J& e7 _5 l! R) n
0 h; }, q* P) d" C- q2 y0 wtype=”全路径.MyAction”

( |( k" e# P! O) {scope=”session”
+ h" b0 k) I8 Y% R. }% j
1 u; G0 u* b; S- e  Minput=”错误返回的页面”>

<forward name=”1″ path=”/1.jsp”>
! ?0 J3 K  z2 q; `/ g# j% n$ J8 w
! `0 U* B5 u: M, [* D1 G: j6 P<forward name=”2″ path=”/2.jsp”>

4 E) Y7 x# K) M! K</action>

</action-mappings>

% ~, @* H7 u' y* U$ [: {9 o4 E步骤:
7 q1 R! U( v, V6 I2 K
1.创建一个空的web应用

" f1 Q% r3 R% N) ^$ Q2.将struts的包放到lib文件夹下
2 x7 T! H0 {$ R2 w0 z7 V6 M8 _
/ J+ D" T# z1 a6 K+ F) o7 @* ~3.将.tld文件文件和struts-config.xml、web.xml放到WEB-INF的跟目录下

4.配置struts-config.xml文件和web.xml文件

5.在页面引入tag文件uri
1 A2 F; s) X2 K4 Q0 o
STRUTS运行机制
8 E0 V, D3 G+ }
( m9 g$ e! K, g0 `/ q1、界面点击产生请求
. `  g% w) }; K# y
2、容器接到请求
/ O/ y  e8 w( _- Z4 }4 @# i7 ?
3、匹配web.xml文件中的*.do来调用ActionServlet
# H  Z  x; b# c& o  m
4、ActionServlet的处理

! f3 O  P, v& T9 S4.1 读struts-congfig.xml文件形成ActionMapping
* \. y) r- |' T+ _6 t2 \* C
4.2 通过path 来匹配Action类，通过Action的name属性来匹配ActionForm类
% T% f- r' D. D0 {( N" j2 ?
7 M0 I+ F  k  D: g0 W; F: K4.3 通过反射机制来给Form添数据

4.4 由ActionServlet转调Action的execute方法

3 z, p' L/ ?$ W+ e# l4.5 得到execute方法的返回值，跳转页面
5 x% |, c( {! I* k! u
4.5.1 RequestDispatcher
  v. u* V: `  A- O
6 {" K- A7 K" k6 a# ^( A, A: K4.5.2 response.sendRedirect(“list.jsp”);



进入execute方法
. H& @3 D" @+ o7 z9 H
1 收集参数
; ]1 T9 \$ J- ~, s5 H
/ L/ }3 E2 |* `% @# Q( n* Z, d2 组织参数

3 调用，逻辑层
" ]) w6 ~3 |" q
4 返回值

; Y* u. U4 x$ S0 l- R0 @# r4.1 选择下一个页面 （ActionForward）
3 P! @0 l% E1 \* t
4.2 把值传给下一个页面

+ J: N. D0 \5 [( f
& h3 t9 p% ~+ ]
比较struts和struts2的不同
. F8 z/ T  r. f5 ~' j1 c- X5 L# p
Struts
  r5 H- [7 g1 u
Struts2

组成        五个部分：ActionServlet，ActionMapping，AtcionForward，ActionForm，Action        十个部分：AcionContext，FilterDispatcher，ActionMapper，ActionProxy，Configuration Manager，Action Invocation，Interceptot，Action，Result，Taglib
url        .do        .action
0 M/ T  }  F% j% q7 @5 l分发控制        AtcionServlet        FilterDispatcher
收集参数        利用JavaBean技术，将数据封装到ActionForm的子类中；
0 F. j- C" m0 H1 h4 ?一个Action对应一个ActionForm的子类
2 E  W9 M: _' J; V
使用拦截器将数据封装到值栈中。
使用域模型，一个Action对应多个值栈中的Model
& F) I4 K4 {9 d, z
读取配置文件        ActionMapping        Configuration Manager
( Z6 d. ?) h  ^拦截器        无拦截器        执行Action前后有拦截器
: C% Y3 S: [) V! u* `6 \! e0 w! W, F$ S) z返回页面        将字符串封装到AtcionForward，进行跳转页面        Action中直接返回字符串，通过Result跳转页面
* I1 @9 |9 j% O3 f3 H  c. }页面跳转方式        两种：dispatch，redirect        三种：dispatch，redirect，chain
值栈        无值栈，Action通过在request范围内设置属性，向jsp页面传递数据        有值栈，Action和jsp页面通过值栈传递数据，jsp页面通过OGNL取得值栈中的数据
3 }" h& \; y% ?' \' t配置文件        struts-config.xml        struts.xml
1 ]+ Y3 G5 k- ]6 ]2 n; n中文问题        不能解决（需要使用filter）        可以解决中文问题：
" C# B6 y7 v7 B% \( F# M1、在jsp页面添加Meta；
, z2 d8 q/ f" c
2、修改struts.properties中的设置。

admin

其他开发工具和技术
( [: N9 l" S& l! O6 L. vAnt
Ant是基于java的批处理工具

一、配置ant的运行环境
' T( i7 L0 ]5 }1 }8 a/ u
1.将ant的bin目录添加到path中

2.配置JAVA_HOME
- v. H; {  A" s# h. ^* p" O
" a* \! R% d2 y  \# f/ f3.配置ANT_HOME
6 E% l' B$ L+ S! o5 Q( |
二、配制build.xml文件，该文件放在应用程序的根目录下
. U3 u2 x0 H1 u1 `$ k
/ `% w: U" m7 _. q) K编译java文件
- E+ ]4 I3 {6 e, r0 `  K; a1 r/ M  y5 B
执行java文件

copy
3 B6 ~- A2 Y; B/ A8 f' [8 f
删除

打jar包

# P* @) K2 g( t# O根据注解生成配置文件
' C# M) X8 @. [" J
; s- a8 C0 l% R; y/ }3 h7 ]; vXdoclet
% `$ D; ], [7 D. g通过注释生成一系列文件的工具（txt、xml、java、html等）

/ x. @& e8 v, f4 `xdoclet本质是摸板技术+字符串的替换

1.在java文件中写符合要求的注释（将hbm.xml文件的内容搬到java文件中去写）

" T% l$ G3 d6 ^# t5 {% Y) A- b2 ^1.1 在类的上面 写与表的对应

1.2 将每一个属性的注释都写到get方法的上面
+ k. r, C5 e2 b& U6 M$ w' q
$ Q0 [& g# Z) e' z0 \2.在ant中引入相应的task来驱动xdoclet
. R+ e* P( l9 U* {! ^1 Q3 e- g

7 Q9 z  h2 N) b* {, S
4 i& M3 l7 [5 G* Ilog4j日志管理
1、是什么？

3 T! M5 g- b! ?( E在开发期间用来测试、对整个日志信息进行管理的工具
: d) {5 d* V7 P: S% M7 B& E
8 E- L! d, X7 \2、功能
$ n" ]- O, g, D+ u: }" t) a& x
9 F) l5 @5 [) m" g- l' e1.控制输出的目的地
" }  v  e& q6 n3 G7 G# `
, d( X9 R  v7 h, Q, h/ r3 w2. 控制输出的格式
8 O; i7 j, o/ X* g
3. 控制输出的级别

' Y6 S2 a! x! o5 U( U3、日志的级别

1. debug 调试

2. info 给用户的提示信息
$ f( W3 `) d) k/ Q  ^
3. warn 给用户的警告信息
5 S2 n( z. t3 P! E1 Q, Z- p. ^
4.error 给程序员用来调试

2 e2 k+ R+ d/ y) w- iDebug—-〉info—-〉warn——–〉error

; h7 Y) N* e- r7 E6 o2 f' h4、配置
! B% I" t* X4 ^' E7 S. l$ k
1.配置级别

2.输入源 （控制台和文件）
% n0 Z, Y7 k) T+ u! j: L0 q
3.可以进行分包控制
+ S1 ~1 w% j3 M  c( _& b( M/ |
Log4f.logger.包结构 = 级别
2 j" d+ j$ I( W
5、使用

Logger log=Logger.getLogger(Test.class);

0 S; D- s9 p1 p# u+ ?" ~/ K! U    public
void t3(){
* D! d3 j1 |& e0 A$ Y) P; y
        log.debug(“this is debug”);
2 b/ E3 f) ~, M( i
3 }8 |/ G( r# n$ F6 C. e2 T+ w        log.info(“this is info”);
! }* E5 q& |8 ]2 c& X; L
3 Q1 S/ y* V% i/ w        log.warn(“this is warn “);
" W5 q/ ~5 ]& i0 A6 ], ?  ^
. p5 \4 ^% ]/ C$ X5 J7 W$ K) F        log.error(“this is error”);

    }

Junit
2 I" U& p/ B  b1 d) Y1.是什么？

- y- z( w0 F' f/ B+ ~5 L) W+ I3 V单元测试的框架
6 _8 u( v0 m' B' F3 l
2.怎么做？
9 Y3 {& D0 u( R* l4 E- g/ k
写一个类继承TestCase

测试的方法一般都以test开头并且没有参数
) q9 J* e0 V+ X; O$ h' A4 `
+ G/ z; k; d3 ]' X在测试方法前执行的方法public void setUp( )
# e" q' @4 C" c9 M1 f
在测试方法后执行的方法public void tearDown( )

error和故障的区别
% K" L& ~& m8 D; b! d8 v
error ：代码有问题
7 h0 n. J$ d* r1 C1 P
故障 ：逻辑有问题与祈望的值不相符合

! V  B; T  W* s4 F9 {生命周期

测试—〉SetUp（）—〉testXX（）—〉tearDown（）—〉结束；
* j$ a& ], E( |" H2 d1 d
- n7 l# R- H* U: p! l  tTestCase套件
" q2 X$ k6 P- q' f
public class MyTest{

        Public static Test suite(){
0 z# w1 r/ A2 b/ S+ m9 p, I/ T/ f
" r! x" `6 Z/ Q3 I) |3 Z' qTestSuite suite = new TestSuite();
* Y2 Z9 C: X% c
/ U- ^( s3 s5 C1 o% g$ E; W. Ysuite.addTestCase(Test1.class);

suite.addTestCase(Test2.class);

" U2 k5 _- c& q; O+ ~/ J; |' X}

" r$ q' ?) K+ r, N( ?5 u( T}

/ o" J+ E" ?. Y9 E/ X0 e
& d2 X+ ?  R) D7 u' |
Ajax
是什么？
+ e3 U& ?* H! QAJAX即“Asynchronous JavaScript and XML”（异步JavaScript和XML)。是一种创建交互式网页应用的网页开发技术。
5 t3 _- g' i3 F& a: Q1 s
: D( P  P+ g7 S# M* X无刷新页面。
% ^; ?& ~4 n. O! E) {* G. u
有什么？
$ |7 H8 A- c; W- T+ zAJAX是多种技术的综合，包括JavaScript、XHTML和CSS、DOM、XML 和 XSLT、XMLHttpRequest。

& g3 }: }, P, w) D/ Z4 ^能干什么？
使用XHTML+CSS标准化呈现；
3 ^# d/ n: f+ o4 V. C使用DOM进行动态显示及交互；
使用 XML 和 XSLT 进行数据交换及相关操作；
使用 XMLHttpRequest 进行异步数据查询、检索；
使用JavaScript绑定和处理有所得数据；

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

  D7 q0 X* z5 s4 C9 w与此不同，AJAX应用可以仅向服务器发送并取回必需的数据，它使用SOAP或其它一些基于XML的web service接口，并在客户端采用JavaScript处理来自服务器的响应。因为在服务器和浏览器之间交换的数据大量减少，结果我们就能看到响应更快的应用。同时很多的处理工作可以在发出请求的客户端机器上完成，所以Web服务器的处理时间也减少了。
3 _/ Z+ i' ^8 [6 V
# d: k- e) E; a' l# G3 {8 [使用Ajax的最大优点，就是能在不更新整个页面的前提下维护数据。这使得Web应用程序更为迅捷地回应用户动作，并避免了在网络上发送那些没有改变过的信息。
4 s; P9 W  V! r/ U7 S2 }# C* B1 T3 e
对应用Ajax最主要的批评就是：
" P4 F' k. Y: i1 它破坏了浏览器后退按钮的正常行为，就是用户点击后退按钮后不能看到之前的数据；
1 [( I) ?( T, i2 一些手持设备（如手机、PDA等）现在还不能很好的支持Ajax；
. l) s( G0 k5 r3 用JavaScript作的Ajax引擎，JavaScript的兼容性和DeBug都是让人头痛的事；
' b* L' i7 ?; k, x: Q$ w4 Ajax的无刷新重载，由于页面的变化没有刷新重载那么明显，所以容易给用户带来困扰――用户不太清楚现在的数据是新的还是已经更新过的；现有的解决有：在相关位置提示、数据更新的区域设计得比较明显、数据更新后给用户提示等;
' f/ c6 B1 n9 x/ o
怎么做？
: i: b6 A, G  ~' T  i4 n/ `: Z) M<script language=”javascript”>

var req;

4 c1 C1 ]+ o0 m. u" V& Xfunction add(){

& v4 ]. i# K& Q7 p! t7 r. ]//1:创建用于传输的对象

req=new ActiveXObject(“Microsoft.XMLHTTP”);

9 H8 |- n( v( e- \( I// 声明返回后，处理数据的方法
& ?+ Y  I: R+ O1 o6 E0 l
1 Z# i5 o: \( V- _! m% U3 c- b: o6 u7 sreq.onreadystatechange=manage;

  n2 `8 i9 `2 h* M! t//2:准备传输的内容

- n$ ]) c! p9 ^5 ?9 k+ D8 Evar str=”test1111″;

//3:发出请求

; E$ x* L* ~: [+ z3 freq.open(“GET” ,”/others/ajax/test/t2.jsp?str=”+str);

req.send(null);
* Y+ m4 K0 P1 |( a, T4 z1 w
: y3 o$ T  I$ w) \! ~3 \' d7 p}

//4:接受返回并处理

! }( E- {! V! g6 z8 Lfunction manage(){
  W& G' s  u5 d! W6 y3 U9 [8 L
! H! X% G3 v+ g0 ^if(req.readyState==4){
) r) g$ r! ?" @
+ h9 T  q6 u$ t- C2 c8 G3 Salert(“r==”+req.responseText);

! L+ i0 U0 c9 t. X% o}

8 S" r0 i8 n$ q. m: T8 x}
+ ?1 k! M3 d9 |4 G7 D
  i& S8 }) C' n4 c7 n</script>
4 k- w9 x9 h9 x- D, e
/ M/ }' b8 E! N8 i7 AreadyState的取值如下：
; S8 E( l: J& W; {, e4 `
　　0 (未初始化)
, ]% ?$ I6 g! S8 V' F
　　1 (正在装载)
; w' r0 {; w, c4 d4 M1 h( a7 q
4 G) M  x& J. n: ?　　2 (装载完毕)

6 [" w2 _( R9 h) b7 k% @: ~　　3 (交互中)

　　4 (完成)
9 {6 d3 z. H% F3 q5 n


. f9 c0 U0 ^( _7 o, I% [3 C原理
Ajax的原理简单来说通过XmlHttpRequest对象来向服务器发异步请求，从服务器获得数据，可以是xml格式，也可以是一个字符串，然后用javascript来操作DOM而更新页面。

Dwr
! \  k4 H7 A- t# N6 u  Y是什么？
DWR（Direct Web Remoting）是一个开源的类库，可以帮助开发人员开发包含AJAX技术的页面。它可以允许在页面中使用运行在WEB服务器上的JAVA函数,被调用的JAVA函数就像是在页面中JavaScript方法一样。
) _0 \5 `/ k) Y. B6 i
" S+ J& U% R, P/ Y有什么？
它包含两个主要的部分：允许JavaScript从WEB服务器上一个遵循了AJAX原则的Servlet中获取数据；另外一方面提供了一个JavaScript库可以帮助web开发人员轻松地利用获取的数据来动态改变网页的内容。


  w) R) n% S3 ?6 ?
能干什么？
动态地把java类生成为JavaScript，感觉调用就像发生在浏览器端，实际上代码调用发生在服务器端，Dwr负责数据的传递和转换。这种从Java到JavaScript的远程调用功能的方式使DWR用起来有种非常像RMI或者SOAP的常规RPC机制。
. L# l* j  @1 d7 A

9 |0 Z7 w2 q7 E* Q
0 K; ]. v( G$ P  h怎么做？
6 k. A# q& R! c) q, k% O0 I! p① 编写配置文件

! ?+ P  Z$ n. |4 I; oweb.xml

0 }! m# [$ F& v0 F! {7 J( x$ S: I  S<servlet>

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

<servlet-class>
2 @5 h4 ~- }9 o1 {( q
org.directwebremoting.servlet.DwrServlet
9 u: ]3 a' H& z* ~% M
2 e' r# E# f* ^4 n</servlet-class>

<init-param>

. b4 s# m, Y# R1 T" {% ]<param-name>debug</param-name>

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

</init-param>

6 F5 b8 l9 F7 Q' ]</servlet>
  v! |0 P5 `: }$ H5 I
. d! m" M& O3 Q% {! d8 ]; p<servlet-mapping>

<servlet-name>dwr-invoker</servlet-name>
8 ~+ k" l4 i6 f6 Z+ B
<url-pattern>/dwr/*</url-pattern>

9 C, V& E  s: s" r9 O</servlet-mapping>
. e; A% M  W! X$ y
& j. D/ K* P5 c- f& J' ndwr.xml

) S( T  D: a4 g<allow>
' h) C* b+ C/ R& g, i0 n$ O
<create creator=”new” javascript=”kc2″>

<param name=”class” value=”dwr.Service” />
/ A8 s( f3 B& X
</create>
6 m$ X- ~& I* P, b/ g1 G% m
</allow>
: t0 `' y; S4 m' V) U
7 `6 r6 k' E$ l) i% |- |②编写service

! P8 V/ E6 \2 b. s, Y. A0 x; y, ~public class Service {
& P+ m% y- W( C
public String sayHello(String yourName) {

3 C3 S8 \* Y0 ]6 V! t, B7 S//可以是访问数据库的复杂代码

return “Hello World ” + yourName;

8 u' M1 @' n8 u}

1 P9 R5 S2 P$ t# c) M5 _}
; W5 u, C6 a8 K( @8 q) C2 e
③测试DWR

将代码放入应用服务器（比如Tomcat），启动。

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

④编写jsp页面
7 |4 Q- L" N5 J
1） 要引用3个dwr的js，其中engine.js必须要，如果需要用到dwr提供的一些方便的工具要引用util.js
3 c# F. t# Q5 c# h" a6 ~
) ]2 p- J. [3 a- T  O. `7 [2） 然后还要引用dwr自动生成的js，dwr/interface/service.js，注意js名字要和dwr.xml配置的一样
2 K1 A9 [% v0 _$ l, y7 }4 N
3） js里的service.sayHello和java类的那个有一点区别，多了一个参数，用来得到返回的数据