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

admin

JEE
4 I- q% m! c& }4 g+ s9 C简述JEE
JEE　： JAVA　 PLATFORM　 ENTERPRISE　 EDITION
; z; A- p' I' x7 ~9 }6 r  l
* {8 C) d, `$ C% e3 b$ XJEE是一个规范集；

JEE是一个框架集；

JEE是一个技术集或API集；
. L6 W+ n6 e& |& [% ~8 s
适用于创建服务器端的大型的软件服务系统
' F9 f+ v3 E3 v  O; p

+ u0 s: K5 v6 x2 L0 T% Q
" i: Z4 X2 ?  ]2 Y/ T# tC/S B/S 模式
  V4 `6 H" T# F. K* v" _6 q0 _C/S client/server即客户机/服务器模式，客户端也参与程序的运行与计算（富客户端、胖客户端）
9 q* }- o/ e: G" a) s6 Y" \
9 G$ F! q1 d. n+ @  kB/S border/server即浏览器/服务器模式，又称为瘦客户端，客户端不参与程序的运行与计算
$ F- L" H  z8 c' p8 H! n. X
8 r: w: t( e8 o& P" w
9 C' V% t, B8 v
( Y7 [1 j4 R/ k$ h企业级应用（大规模的应用）的特点
' z) A. A& s% i6 `* @* p! K% q1.生命周期长、稳定、可靠

2.组件往往分布在异构的环境中，能够跨平台
( O( E4 s$ b3 a6 z! r
$ a, \: _4 `6 o1 F1 E( u3.维护性、扩展性、重用性
( o4 s7 k2 d& U+ b9 Y
4.有事务、安全、线程
" T/ Y; W" _* r  _


3 q: b+ J7 o8 o) j! ^6 A6 U什么是业务逻辑？
依照业务逻辑划分模块，
8 F9 Z8 W( a! W% v/ l5 A
所谓判定业务　就是具有以下特征：

1.业务流程
" T6 w- p, g" _' |! q! A/ S
; Y8 |( W" s4 C; F2 f: b+ V  N9 |/ s1 O; s2.业务判断
' o: _. ?: N9 \9 S: v
3.功能组合



平台（角色）的划分
1.平台供应商。提供满足API集实现的厂商（BEA weblogic IBM webshphere）
8 c$ ]  Q8 @3 p
1 C+ H3 Y; D# u, r: c( _2.组件供应商

3.组件装配人员
/ `5 D$ S) I+ G9 F, S
7 q0 K& d* u3 g2 L9 [4 U" R4.部署人员
/ x; d! n3 F4 u) k: {) C( \/ b" A
# y' }! j. w1 Z) n- Z5.系统管理人员

6.工具供应商 提供开发组件所使用的工具（Jbuilder、eclipse）
; s; ~: \& A6 Q' G3 f7 |

4 `' X  k# T- ?4 O3 w/ @* ?$ n
: A( @- o# t9 }2 y- D+ J3 k) _4 Z+ hjava技术分布（设计架构 模块内部设计）
( O+ u) y+ R: K7 [1.表现层 Servlet、 Jsp、 JavaBean、 Taglib

* g8 }0 J3 v+ \2.逻辑层 EJB(SessionBean)

* \% O- U2 e- f& |7 `( I3.数据层 （　JDBC 　EJB（EntityBean））
# z$ E' U1 r; b3 D% J
! f1 d0 V7 e- {" j4.服务 JTA（JAVA事务架构） JTS（JAVA事务服务） JAAS（JAVA授权与验证服务）

5.分布式通讯 RMI（IIOP）+JNDI 、JAXP（JAVA 的 XML 架构）
  ?4 |( f( D$ l, v
' l" F. U- i4 E1 x9 k3 QJAVAMAIL（邮件服务）、JMS（消息服务）、IDLC、JCA（JAVA连接器框架 （成））


* N9 L- x. t  d4 c
  R/ H5 P* j# E+ UJEE的体系结构： 是一种组件的体系结构
6 d, p% U2 Q) l! v( K# H9 t9 K( O8 l1.组件 ： 能够完成一定功能的封状体（独立的功能的集合）

0 p( u8 {' _( `; C" t# @不能单独运行，必须运行在容器上
" @( ?9 u. Y% D4 p1 [
# y# q# V. j4 k- b% O分为两类：web组件、ejb组件

2.容器 ： 提供组件的运行环境，并对组件进行管理（一段程序）
/ x) V4 u8 ^% @) U
管理组件的生命周期

- t7 x; J) i3 J+ w. d% c3 M# {, I( i不能单独运行，必须运行在服务器上

/ d9 S# Y) r, O程序（组件）通过上下文来调用容器（context）

组件通过web.xml向容器描述自己，使容器能够认识组件

- h0 X! V* b9 k. M' B! ]9 G2 |/ O4 t容器通过回调方法来调用组件

) O# L& E, c: k2 z" T分为两类：web容器、ejb容器
) l0 ~* N/ W- n2 g
3.服务器 ： 提供容器的运行环境，提供大量的JEE基础服务
6 \# ], \+ V4 Z' ]: o9 W
  O. `8 w" V: r2 O9 `( hweb服务器（只提供web服务）

jee服务器（提供web、jee服务）



3 B6 x+ Y  {; V# `什么是回调方法
由容器自动调用的方法，就叫回调方法。

+ |; h; c3 X) V

ＲＭＩ远程方法的调用机制
& [' v4 Z9 M4 \: n4 X例如：Ａ主机有Ｂ（）方法，Ｃ主机有Ｄ（）方法，Ａ　想调用Ｃ主机的Ｄ方法

- K( T6 @  l* y) v( {! B+ R  L
$ n% O* w$ z& K1 O
5 y2 `" {' s% E/ J
8 U! s+ p$ T, a: d0 ~
, p. H2 b8 [# q5 l学习方法
1.规范（熟记） 2.熟悉API 3.多练 4.多想

admin

Servlet
) j0 q  ?# ?1 l; ~! k: f. W4 S

•     描述war包、jar包、ear包的结构
  # k* r7 C- L. M( |
  4 ]/ O: [. u( ~% i) k. b
  

war-                            web文档压缩包

—WEB-INF

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

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

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

. F$ D3 l' h, e: }! H. ]' \

jar-                             java文件压缩包

—META-INF

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

' z4 L3 l3 J$ Z% L# X0 r. n

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

–META-INF

—Application.xml 配置文件

–*.war

–*.jar

8 v) U1 G6 _9 U+ S

• 什么是servlet？servlet主要做什么？
  
  & @5 M5 i4 R* K( v! w/ V9 u# u: F7 N
  ; y" v3 X1 b# M. }7 u! g$ n

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

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

• servlet 与cgi相比的优点？servlet的缺点
  7 T3 F+ _  U0 G
  * w' g" f, Z' G0 ?' @
  

优点：

性能（线程比进程更快）

可伸缩

Java强健且面向对象

Java平台独立

缺点：

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

1 x# [* D- {) a

• 常用的servlet包的名称是？
  
  * n) y8 P/ X$ E# g# C' R
  . r" G- g8 d! J" V3 ^: Z

javax.servlet

javax.servlet.http

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

Servlet

–GenericServlet

–HttpServlet

–自己的servlet

ServletRequest

–HttpServletRequest

ServletResponse

–HttpServletResponse

+ U: L; C3 J6 I1 |4 v7 r* p

• 对比get方法和post方法？
  
  , T% i' V$ Y- r+ U
  # M# t2 [6 N$ R: s  i# O) |

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

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

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

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

* |0 K3 U; N+ U. Z8 \5 Z

• 归类描述HttpServletRequest接口都完成那些功能
  . f; p8 y5 H! v% e. D5 e
  
  
  • 读取HTTP头标
    
  • 读取cookie
    
  • 读取路径信息
    
  • 标识HTTP会话。
    , ^& t) D: |. ^8 |
    # T* x! H4 u2 h+ u. L3 ^) F' y

• 归类描述HttpServletResponse接口都完成那些功能
  ) ^' g/ ^! A, b( {, z' L  h
  
  
  • 设置HTTP头标
    
  • 设置cookie
    * R: b- g2 H0 x% J- D5 }! D  k
  • 设定响应的content类型
    2 I( t  t" U' F! c$ Y0 s# j  J
  • 输出返回数据
    5 y- l0 h+ D+ C
    

• 描述service方法所完成的基本功能？默认是在那里实现的？
  , w8 z' m) ]) t% `5 B
  
    o, q+ }) k5 s

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

实现：默认在HttpServlet类中实现

3 ~  B+ f0 j: `* Z& d: ^) q

• 如何开发自己的Servlet？描述应该做的步骤和每步需要完成的工作
  0 ?- Y  F5 A6 p6 g: Q" u
  $ n8 T% U4 `  }. q' ]
  

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

• 为何servlet需要部署描述？
  
  
  6 X: {- J( d- I8 M; t9 W: U) G4 \

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

6 n1 A4 \" \5 n1 m

• Servlet基本的描述应该是？请写出来
  - Y5 w) {3 M" t
  3 W& ]+ X3 Y  ~! ~5 w
  

1 a3 W" h& m' ]( b

<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
    j( k8 f/ F1 C' x
  * U  T* H; ?2 n7 v9 p
  ! V& D! [* e1 A

FORM标记

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

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

语法：

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

{HTML form tags and other HTML content}

</FORM>

( R) y* i6 h7 {3 B3 y+ n% Q/ P0 A6 \! v

• 如何接受request中的参数
  
  String userName = request.getParameter(“userName”)方法
  2 I' y/ B4 |; a% V
  " [9 r3 O2 a5 P

• 如何接受request中header的值
  8 p' G) e: K3 L
  
  & e( {8 c- Q% l5 n* {+ H0 W! ?

request.getHeader(name);

request.getIntHeader(name);

request.getDateHeader(name);

request.getHeaderNames();

• 如何输出html
  
  
  

PrintWriter pw = response.getWriter();

pw.write(“<html>”);

pw.write(“Hello”);

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

6 C* l: P. G. G

• 如何设置输出的contentType
  
  
  , |/ r/ U8 G8 S+ a

response.setContentType(“text/html”)

$ j& d1 d  w5 c" T

• 描述servlet的生命周期？
  
  
  

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

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

* @& G: ]$ x, }* y, c

• 描述init,service,destroy方法的功能和特点
  7 F  U6 [: J+ U) w! b! ?9 m
    F# }9 @0 \. y1 P$ V0 u) i
  3 c) D) R0 k# o) n

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

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

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

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

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

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

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

  L( L$ O4 D( e; g' X

• 什么是回调方法？有什么特点？
  0 o+ O; n! C  a9 @: T2 x5 l
  
  

由容器来调用程序的方法

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

• 如何设置初始化servlet的参数？
  . ~5 |: t+ e, A6 s/ H
  ; {% s2 M5 c- |! L; M在<servlet>中添加如下配置
  & ]8 M' b* r4 ^# P  @  K; M
  

<init-param>

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

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

</init-param>

• 如何获取servlet初始化的参数
  7 f+ ~- B2 v0 ^7 w( _: s$ c
  
  

public void init() {

greetingText = getInitParameter(“greetingText”);

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

}

• ServletConfig接口默认实在那里实现的
  
  
    q' |" ]* r9 w7 \

GenericServlet类实现ServletConfig接口

: C- T$ c& C# y5 @

• 什么是ServletContext？有什么作用？
  
  
  2 Z8 g6 \* M& s* t$ a* ~1 H5 f

Servlet上下文

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

• 如何访问ServletContext接口？是在那里实现的？
  " F' `2 ]: q$ Z& ?0 L" H- o
  7 h' W' C- u1 `# d# B) V7 S' D
  1 N) q  w0 B* }4 q7 x# f. N9 {/ |

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

GenericServlet类实现了ServletContext接口。

• ServletContext接口的功能包括？分别用代码示例
  " O4 c: R9 G* [1 n8 |& E- o
  % W( Y8 l" c+ ^
  

只读初始化参数：     getInitParameter(name:String) : String

getInitParameterNames() : Enumeration

读写访问应用级属性：getAttribute(name:String) : Object

setAttribute(name:String, value:Object)

getAttributeNames() : Enumeration

只读访问文件资源：    getResource(path) : URL

getResourceAsStream(path) : InputStream

写web应用日志文件：log(message:String)

log(message:String, Throwable:excp)

• 如何设置ServletContext的参数？
  
  
  

<context-param>

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

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

</context-param>

• 如何获取ServletContext设置的参数值？
  
    y, M! T4 j7 F, x# {
  : w/ i6 T3 [' D1 d9 A

ServletContext context = this.getServletContext();

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

• 描述Web应用的生命周期？
  
  ) ~: r+ h+ e9 A& ]. ^* Y# Z: n- U$ d
  

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

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

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

• 如何用代码实现监控Web应用的生命周期？
  
  
  4 H9 g1 }+ Q: u1 k
    I# K4 {3 J$ V

public class Test implements ServletContextListener{

public void contextDestroyed(ServletContextEvent arg0) {

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

}

public void contextInitialized(ServletContextEvent arg0) {

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

}

}

$ }2 p) X, r% F6 |

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

• 描述Web应用中用声明方式来进行错误处理的两种方法
  6 [# B5 t/ P+ `7 x2 c/ u
  ' O1 m( _% H5 w' t9 W( S6 P
  

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

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

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

• 描述记录异常日志的方法，都位于那些接口？
  
  ! t0 E- {: m. X1 U! V
  

GenericServlet：

log(message:String)

log(message:String, Throwable:excp)

ServletContext：

log(message:String)

        log(message:String, excp:Throwable)

' s" y# i% t( ^* M9 m

• 什么是会话？
  
  ) f0 M/ _: g5 I5 m
  + d6 p$ y. @6 W( `* Y+ s

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

• 如何获得会话？
  
  
  HttpSession session = request.getSesseion( );
  
  + J) p1 z8 X2 w% k. z

• 会话Api的基本功能？
  
  
  

getID() :String

    isNew() :boolean
. `1 P5 `  @7 g" U& c

    getAttribute(name):Object
, |% i- B  ~: S* |" K( L/ W, F5 E' W

    setAttribute(name,value)

    removeAttribute(name)

• 如何销毁会话？
  1 ~) V# Y. D( d7 l$ I
  * r7 |( d) t& X1 O
  

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

<session-config>

         <session-timeout>10</session-timeout>
* S. W. @! x0 h9 N9 n2 ]1 h; u' q

     </session-config>

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

invalidate()

     getCreationTime() :long
9 U; b2 U" J1 {* |( x8 m8 X

    getLastAccessedTime() :long

    getMaxInactiveInterval() :int

     setMaxInactiveInterval(int)

• 描述会话保持状态的基本原理
  9 D! W4 @% p' r* X6 Z, ?. M
  
  

    client server
$ f& p  j9 ]2 P3 ]

* s; ~' K; l/ @. N9 {

request
9 o  j$ T$ K( O8 V" H% l& T" r

response (sessionid)

request (cookies)

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

• 请描述session和cookie的异同之处
  
  
  . J# k% F( Y& C

• 如何读写cookie，代码示例
  5 }% g, h8 V+ v
  
  

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

response.addCookie(c);

读：Cookie[] cookies = request.getCookies();
- C3 L* ]6 }, f

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

            String key =cookies.getName();
- x3 N* ~& v& N1 l1 F: t, t

String value = cookies.getValue();

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

     }

• 什么是URL重写，如何实现，代码示例
  
  4 p, F! g7 ^$ C  |1 L3 S
  

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

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

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

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

• 描述web应用的4种认证技术
  
  
  ; N! j% D+ u3 ?% e0 w+ |9 `

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

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

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

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

• 什么是授权，什么是验证？
  " \' x/ ?* a* o: _6 x
  8 x' E* Z( ^. z4 k4 F# ~
  : m1 h# Z4 B* n6 }( E: z% I

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

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

• 什么是HTTPS
  $ J( k6 G9 T5 S! D
  - ^; [$ G- ?3 z& _1 D2 _
  + X, g1 N& ~# h

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

1 w3 J2 x5 i/ \& k/ X

• 什么是审计？
  ) F+ e* y1 ~1 L. `& z) O
    M' V$ m; V) J' `8 M4 M
  

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

7 \# a- r# G4 w

• 如何实现声明性授权
  
  
  3 X0 ], X2 C5 c8 W7 t/ j

1、标识web资源集

2、标识角色

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

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

在 web.xml里配

• 描述servlet并发问题？
  0 q; B% r& x2 n; T1 z9 t5 b
  
  

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

; B8 N- Y  F6 U; T

• 描述Web应用中的六种属性范围
  
  . V% x9 h6 D' h2 u1 H) x* t) g1 M( k
  

局部变量（页面范围）

实例变量

类变量

请求属性（请求范围）

会话属性（会话范围）

上下文属性（应用范围）

• 指出上述六种哪些是线程安全的
  
  9 P* Z% {+ i4 O+ X) s& x
  4 _3 |/ C+ o7 k' i7 G0 s

局部变量和请求属性

• 什么是STM？如何实现？
  6 \: ^6 q0 G* J: i
  # D! Q: o7 d$ Z. ]; y4 q4 g1 G
  7 A2 P! z2 m7 Q# I/ ~

SingleThreadModel接口

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

• 如何实现并发管理？
  $ g  \! J. e4 m: D. x# A
  - b  U9 B! F3 _# z; Q7 q$ X
  7 H+ H5 V! i2 m# C9 h: F4 d) X

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

使用synchronized语法控制并发

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

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

# D8 x& x5 @5 l5 m" m% Z/ a

admin

Jsp
什么是Jsp?
" b8 R9 H6 t) r3 d! Y6 m2 OJava Server Page    结合java和html在服务端动态生成web页面的技术
) i3 |, }6 ^; Q/ s. m1 u$ t" ^
4 H* j' M8 N) p! I
) D! ?9 w, s+ h6 K' C6 f* c9 \
3 `" r7 O" M: }- F/ n7 c6 H描述Jsp页面的运行过程？
第一步：
$ S4 o+ A* `/ g' q
! [# d& z* b9 ]: s7 @9 Z请求进入Web容器，将JSP页面翻译成Servlet代码
+ }5 ]9 k2 B9 h6 {
第二步：
- Z! H0 V8 b; O5 S3 J5 [, J
编译Servlet代码，并将编译过的类文件装入Web容器（JVM）环境
& @6 G  b; U( l1 |  {; i
, |- s5 L$ g5 q- y第三步：

- g( D. _/ D+ w! B% t( g" M8 T- \Web容器为JSP页面创建一个Servlet类实例，并执行jspInit方法
6 w/ W2 [0 z% s3 k# ]  \2 ~8 D
第四步：

# a- F) @+ ?; ?8 c" _Web容器为该JSP页面调用Servlet实例的_jspService方法；将结果发送给用户


, Z; Y6 n. i" \" z5 X
描述Jsp页面的五类脚本元素的功能、写法、并示例
8 Z) {& V7 l8 |4 k% k注释 <%– –%>
' f6 }2 I# `& R9 X7 y& \( d$ x- e
; d. |7 p6 P6 V' D0 U<HTML>
2 }/ B9 B1 S* {+ f' ^! S; \* M
- y& g2 a+ k8 }9 U* X8 f7 ~# t5 H<%– scripting element –%>

</HTML>
: C$ V2 e" V$ {! i
指令标记 <%@ %> 指令标记影响JSP页面的翻译阶段
, Z! \& U5 B4 a# D3 Z
, {3 M- N; O3 i* R: c<%@ page session=”false” %>
! e4 R9 k# u& b9 Y0 O
声明标记 <%! %> 声明标记允许JSP页面开发人员包含类级声明

6 z  x" N2 G2 L' A: J2 _. c6 l( o<%! public static final String DEFAULT_NAME = “World”; %>

, T3 r4 D2 U3 F) y' G    脚本标记 <% %> 脚本标记允许JSP页面开发人员在_jspService方法中包含任意的Java代码

/ ^' a0 Y6 F; R6 `' }    <% int i = 0; %>
8 {7 S6 }+ Y) \; Y; ~' R! i$ I0 J
1 w& I. A4 g& H表达式标记 <%= %> 表达式标记封装Java运行时的表达式，其值被送至HTTP响应流 <B>Ten is <%= (2 * 5) %></B>



) W" a2 ~* C. R: k, S( ?7 f描述Jsp页面中的注释种类和写法
# q  m/ j# Y/ P+ ]6 WHTML注释

<!– HTML注释显示在响应中 –>

JSP页面注释
9 R5 H& `; c( v- j2 Y
. c' s7 P+ `$ p5 P' {, B<%– JSP注释只在JSP代码中可见，不显示在servlet代码或响应中。–%>

Java注释

<%
# O/ a$ P: M1 |8 J$ H6 }
/* Java注释显示在servlet代码中，不显示在响应中
" [, }) t, Z" c9 b& E3 R, e
*/
$ B) T: ?! \& G
%>
3 v6 ]. z% z3 H7 a! p
. V4 o" W) ?0 _" [( _: {: w

' q+ [- {4 z6 E, g2 Z' z/ W描述Jsp页面的指令标记的功能、写法、并示例
指令标记影响JSP页面的翻译阶段

<%@ page session=”false” %>

<%@ include file=”incl/copyright.html” %>
* r2 m8 z  r, Q! y; K( v+ G
<%@ taglib %>



描述Jsp页面的声明标记的功能、写法、并示例
1 {$ ~0 y* I8 l) p$ O声明标记允许JSP页面开发人员包含类级声明

写法：

; Q8 w3 s3 x2 |* T+ N$ a# s2 G<%! JavaClassDeclaration %>

" _  E' _" g4 p" ?1 E( ^* ]7 e例：
! j% s3 i* K# s6 p8 Y, O
; F7 f* G4 x8 T4 ?5 l6 h& H3 x<%! public static final String DEFAULT_NAME = “World”; %>
0 D8 U: y0 u% a; Y0 _
& c- r. b+ Q+ R+ X( T4 S9 U2 o<%! public String getName(HttpServletRequest request) {

8 d0 n3 Z9 ?, B4 G/ ureturn request.getParameter(“name”);

}
1 q7 W" u6 e7 Q+ p
' a( t2 R/ `# Q- M) T%>

<%! int counter = 0; %>
' U% u* W- _8 m8 ?) Q+ l& E3 B


描述Jsp页面翻译成Servlet的规则
jsp中的注释标记被翻译成Servlet类中的注释

% d0 [+ j6 p, F/ m4 k4 v4 T$ t5 ljsp中的指令标记被翻译成Servlet类中的import语句等
% e& W: ?& W4 S7 e- Q. J
jsp中的声明标记被翻译成Servlet类中的属性
' |9 e& v: o7 |! @0 o
jsp中的脚本标记被转移到Servlet类中service方法中的代码
  d; l1 j7 ^. D4 W
jsp中的表达式标记被翻译成Serlvet类中的write()或者print()方法括号中的代码
8 I$ h: S, s- \4 X6 c
: Q; B9 q* d% ^$ `0 \
/ m# K" O* I  k4 F1 [) B/ q# g1 U
9 Q( u6 h; _; \$ V! Q描述Jsp页面的九个预定义变量的功能、用法、并示例
request 与请求相关的HttpServletRequest对象

response 与送回浏览器的响应相关的HttpServletResponse对象
  X% W7 M* M+ S; x
out 与响应的输出流相关的JspWriter对象

    session 与给定用户请求会话相关的HttpSession对象，该变量只在JSP页面参
  w1 A- \% @6 J( Y2 i! [
+ u8 _; V+ H& m( H( h: [/ \4 B* z与一个HTTP会话时有意义
- L  X. |+ V- Z5 b* k7 G$ w+ M
- s8 M; q% _- S2 Q    application 用于Web应用的ServletContext对象

config 与该JSP页面的servlet相关的ServletConfig对象

3 G, D5 S& ~& d8 E) c+ apageContext 该对象封装了一个JSP页面请求的环境
- ?" ~# n: X" V& [* w, y
page 该变量与Java编程语言中的this变量等价
8 Q# M4 T+ T) U
    exception 由其它JSP页面抛出的Throwable对象，该变量只在”JSP错误页面”中可用



page指令的功能，写法、并示例，并描述它的如下属性的功能和用法：import、session、buffer、errorPage、isErrorPage、ContentType、pageEncoding
import import 定义了一组servlet类定义必须导入的类和包，值是一个由
  ~# y5 b; `0 j4 S: \5 N
逗号分隔的完全类名或包的列表。

session session 定义JSP页面是否参与HTTP会话，值可以为true（缺省）

  V& M6 Q' x. @. l4 E/ e& w9 i. }或false。

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

- J% \7 a/ m1 d. c, Lnone或Nkb，缺省为8KB或更大。

2 K5 M9 j  P* Y9 p, S2 BerrorPage 用来指定由另一个jsp页面来处理所有该页面抛出的异常
% |1 X% z1 D( M+ d6 k
isErrorPage 定义JSP页面为其它JSP页面errorPage属性的目标，值为true或
1 n) c; n- L9 I5 p7 @2 M+ b9 O: g
4 B( Z& n% Z6 L# k9 A0 I% A; nfalse（缺省）。

- i5 ?( V+ k  j4 a  l. r2 kContentType 定义输出流的MIME类型，缺省为text/html。

pageEncoding 定义输出流的字符编码，缺省为ISO-8859-1
( s9 d+ T4 ~! |0 I


% v6 {2 T* R+ K+ b! M% @" R描述MVC各部分的功能？MVC的优点？MVC的缺点？
* e# j) j- W8 a. B& NMVC各部分的功能：
$ R5 o6 j; M6 m1 Z) N
3 f! \, g9 a. f9 pModel（模型表示企业数据和业务逻辑）
, S8 B& O& u7 e
封装应用状态
! f+ z5 T, g9 |. e
响应状态查询

  {9 j  J4 ?6 q# o- Q: H) W暴露应用的功能

Controller（控制器接受用户的输入并调用模型和视图去完成用户的需求）

验证HTTP请求的数据
; i! f9 u6 `. D$ ~) u) ^+ Y
# `- X4 \7 N+ S1 F7 C2 G将用户数据与模型的更新相映射
8 Q- J2 ]4 l! M( ~+ S
选择用于响应的视图

View（视图是用户看到并与之交互的界面）

8 f2 Q; \6 e" [3 [; s( o- ~5 Z产生HTML响应

请求模型的更新
7 n$ ]  ]. F5 R' X' t$ @
提供HTML form用于用户请求

MVC的优点：

; B" i* M  G( |9 B# G2 y/ K        低耦合性：视图层和业务层分离
/ b; u  @$ g. V: J4 v# v  ^
高重用性和可适用性

较低的生命周期成本

快速的部署
7 F9 |. e! `7 d; {) j" q
) b* @0 A$ N8 l3 e可维护性
- R( y! b+ E: p& ~- Q' u  t) y1 C
- j% s1 u3 {' Y- U7 K5 w, J有利于软件工程化管理
7 F$ C) A: O8 i/ K& x
提高软件的健壮性
5 r2 ~6 L3 M8 A, f+ P5 @+ W& [9 ]
5 x% @* ^. k( N7 r. DMVC的缺点：

        工作量大，增加工作的复杂性，MVC不适合小型甚至中等规模的应用程序
6 L) W* b2 s1 Y5 O) j

% J6 X  G. c% I6 j+ b! O3 L
0 |; j1 L4 q; F3 s什么是Model 1结构，以及结构中各部分的功能
结构：jsp+javabean

Model1中使用jsp来处理web应用中的视图控制部分
& h6 T! k% U- ^# i9 |  X
Javabean收集参数
% v3 B; ]( _( d. J
# D: N8 Y7 A) c0 z# S+ J' ^

' Z) V9 `. O5 W什么是JavaBean?
9 h* M" Y4 P: w1 b用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。
$ R" W4 o, ?# ~3 z, H- L


  A/ B' X; a% H* U3 h: z: vJavaBean的规则？
使用get和set方法定义属性
7 w- u8 ~5 R; W4 p: Q/ ?* z. e
一个无参构造方法
) r- ~, O& n# T% S) ~8 |5 a
0 I# J0 J. R  d% Q: q5 X  y9 ?无public实例变量( 所有属性私有化)

# E5 W& b7 \3 p% j: a
* U4 ?2 X+ C8 j' f* p1 k; M
" S7 n; P, H2 ^% X. ~* [什么是jsp标准动作？包含那些？分别都是什么功能？如何使用？
JSP页面中使用类似于XML的标记表示运行时的动作

" h5 _/ C. z  k9 Ejsp:useBean

jsp:setProperty

jsp:getProperty
: Q7 w6 z& G2 G+ D
jsp:param
: d5 \* [5 ]$ X( M: l4 Y& x
jsp:include

jsp:forward

) K6 ~' s9 _, Z  X5 D

) U3 [0 ~: m$ z/ I- E/ j, \用代码示例如下标准动作的使用：useBean、getProperty、setProperty
+ Y) l5 r! P4 `2 I  b: P4 K4 G% p) l6 G9 ]<jsp:useBean
' E) `8 p+ g8 x& P& s7 q
$ M5 v% }  n0 I4 Zid=”myForms”
* z3 `0 \5 }* i/ ]" _5 T; l8 L
' m9 n+ y: {/ K3 f' B  Pclass=”com.base.mystruts.forms.MyActionForm” scope=”session” />
: k: Z. J' i- G! G
    <jsp:setProperty name=”myForms” property=”name” />

9 B& v! m5 f. Y' _' x# t* F$ ^<jsp:getProperty name=”myForms” property=”id” />
1 {" _* c2 i5 E, x& \
/ U- i+ N  a& H

描述说明Bean的四种scope
3 N- w2 [/ \2 rpage
- X) V9 X3 t0 T0 ]1 V: D
( a4 B# Q: u8 d" {request
8 \& E) @: H4 t, v; ~- U
& r2 T% q5 ~' {) l6 ~session
9 u9 N* B+ [2 j% Y" K7 {
application
7 w4 W( V+ W8 t, w$ c  N
9 w# y5 r4 t5 H; l& g

6 H* v6 y$ C9 W8 V描述说明页面上的字段和Bean中属性的对应规则
4 U7 Z" R/ m7 r5 L- Jid 指javabean的变量名

class指javabean类的全路径

1 \2 t: L5 E- z+ r1 ~" }' B" mscope指javabean的应用范围

: x" Y9 f. U+ l9 s  Sname指所用到的javabean的变量名
0 ]3 e5 Q; _) b
9 W# J  Z, z( z/ d8 O# }    property指javabean中的属性
. n% z  A5 F* a* f0 x+ N, e


4 K! ?3 G1 H  y描述useBean动作的处理过程
$ g. {9 m; }1 r  |/ _' P) P0 o使用id声明变量

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

如果没找到

创建一个类的实例

& j4 y0 Z4 k$ B5 L执行useBean标记体初始化对象

如果找到
) v( J0 ?# ~! k  e, O: U
     将对象转换为类指定的类型

, X3 j: u$ s2 W) S: d( ?7 b

描述forward动作的功能
: D6 C+ t# I) m( v9 ?5 E  J使用脚本代码处理请求时，可用jsp:forward 动作产生一个不同的视图，
  E; i1 {+ d. ]" s5 ?7 i* @* s
使用同一个request：
; T# S, x3 t: p6 O$ p


6 g0 e' l( o7 x/ i什么是Model 2结构，以及结构中各部分的功能
1 b3 _& F9 N" t# V) r1 z' j& Njsp+model+servlet

! n* `  h$ C) K5 \% cModel 2架构使用MVC模式，JSP页面充当视图，Servlet充当控制器

6 g5 r% Q+ f" _) gServlet控制器：

" G# \7 d' J1 }* _3 I6 g验证HTML form数据

2 p$ N6 b  x8 O5 Z2 w. H) T调用模型中的业务服务
% c# h# \+ }  o9 {0 F* m1 h* G
存储请求（或会话）范围内的域对象

选择下一个用户的视图

3 q, I; [. h6 j- T$ @# kJSP页面视图：

使用用户界面（在HTML中）

0 j) n' N) m; ~: ^% I' I0 z        访问域对象
" U- Y  E, q! V0 E2 m

' x) @. t' }7 K4 l- K
! j8 Z+ Y. W8 \8 K/ M  B+ d6 r如何获得分发器？分发器的功能？
$ W7 l6 `9 ^; y( w- n上下文对象中的分发器：

ServletContext context = this.getServletContext();
, i/ ~# U9 D! b3 N
5 `. [" o2 Z8 l: B7 s( }9 VRequestDispatcher servlet = context.getNamedDispatcher(“MyServlet”);
9 a! o7 \0 v1 P
/ p; O% c" D% c7 O: mservlet.forward(request, response);
3 f3 y9 E2 Z; M8 d1 A; s; ]! T
+ |' n  u' `7 E& Q9 O* a% u/ {请求对象中的分发器：

3 U& r( O, w  h4 F3 {/ hRequestDispatcher view = request.getRequestDispatcher(“tools/nails.jsp”);

7 d( m& B/ _1 f* t  @view.forward(request, response);

2 @" x1 R. n) i! C* o# g3 n3 B可以将请求转发到另一个jsp页面，并保持请求的传递性
/ R0 A7 B" _, ^3 B$ Y  M


' I) i4 A0 m, wJsp中页面跳转的两种方式？
5 b' I, e$ B6 S, ?使用分发器跳转页面
RequestDispatcher dispatcher = request.getRequestDispatcher(“url”);
3 g: y$ W$ r  D
0 `9 m+ c5 A& x- g9 ?2 idispatcher.forword(request);

# `2 [3 @8 y/ S/ v, {: w* u) I    特点：保持请求的传递（上一次请求中的数据，在下一个请求中仍然可以得到）；
  p3 G& r+ J# l) @
        转发的页面只能是同一个Web应用程序的其他Web组件
! D* H: @: F# f* |1 a2 J# x4 j
使用重定向跳转页面
; i$ @! T0 [1 X4 y  F2 r. bresponse.sendRedirect(“url”);

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

        重新定向的页面可以是任意的URL
* W8 G5 a! A6 {& E" N1 @
: `5 g: I9 U$ E8 Y' E

描述Jsp中引入另外页面的两种方法，并比较两种方法的特点？
% X( Y& ]. }; T4 A, S2 E( v7 J<%@ include file=””%> 在编译期间把另一个页面完全嵌入这个页面,可以说是一个页面
+ ~2 G% A0 ~9 r1 C6 y( Q* K
1 G7 @, Z8 O3 o4 o/ K' w在这里可以共享变量

<jsp:include page=””> 动态的再运行期间把另一个页面加入这个页面,可以说是两个
5 c  D9 o+ |' ~; y8 t- I- _
6 y, a+ C) o' \+ _  G8 o2 Z6 V页面，不可以共享变量

6 u/ s0 N8 j2 G/ a) ^  W. w
( b5 e3 X" `1 o5 o! S$ M' G
( L2 e5 q% Z6 T5 b% f什么是自定义标记
自定义标记库是一个Web组件，
; o8 z2 I5 J+ k+ T: ~
, f0 O, {2 S7 S6 E( t包括：

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

所有相关的标记处理器类(*.jar)
# c- f) T' _" o$ g- c: _0 D) I. l
" ]* u$ M$ L6 w1 f. n5 A6 ^5 v
1 B; ]* ?& ?. f) s, Y
+ }9 y/ E, h  G( s描述使用自定义标记的步骤，以及每步详细的工作
' F, u- I" G) a- V, x6 Y使用自定义标记前，要拿到.tld和.jar两类文件

把.jar文件放到WEB-INF的lib里面。
9 d$ |9 D8 h1 n! F2 \( y7 ?! I3 O把.tld文件放到WEB-INF根目录下。
8 t1 |" }( M  |- r4 a在web.xml中配置。
( [8 ^3 C8 o( P) |<taglib>
  y% V  ~1 r; T7 s
) x2 w5 l( ^+ c, p<taglib-uri>http://java.sun.com/jsp/jstl/core</taglib-uri>
: G3 Z( Q9 K1 {4 j; X/ f  `
- I! T" x) V7 s8 a' A* n. [- o6 k     <taglib-location>/WEB-INF/c.tld</taglib-location>

</taglib>

0 s  @0 s' K1 f/ f% t- N; Z在页面中引用。
# J% E2 p7 R; @9 ]0 Y" a. n- k& l<%@ taglib uri=“http://java.sun.com/jsp/jstl/core” prefix=“s”%>

uri必须与web.xml中的uri对应
) I+ w- \% w4 {% c
prefix是前缀，用来区分是哪一个taglib
7 v! X6 u2 L+ \5 R6 S( L
$ n$ _% x, T) O使用标记
格式：<prefix:tag名称 属性>

5 ?0 \# H! O# N+ c<s:forEach >

admin

在tomcat下配置数据源
1、服务器与数据库的连接

配置server.xml文件

1.oracle

8 ], B5 }8 |4 ]3 Q' i<Resource name=”jdbc/company” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”

                        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”
) x+ P) |# u7 w# u9 ]
) _% \* s4 A" G" _$ A4 P) {  n' Ourl=”jdbcracle:thin127.0.0.1:1521rcl”

3 T; e5 ^$ x5 Q9 C: [8 Y9 PdriverClassName=”oracle.jdbc.driver.OracleDriver”

username=”aa”
8 s4 _! ^- V; Y7 l) z. E  f
password=”aa”

% k) j, G; u) Q2 u4 x  I! DmaxActive=”50″

9 K: j! X: @7 nmaxIdle=”10″
9 k2 R: W# H! O/ @8 L
( k; @% e% A0 c. ?  xmaxWait=”-1″

/>

2.sqlserver

<Resource name=”jdbc/webpage” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”
: p; O* g9 M% g; i5 V
; I0 X7 o  G9 V5 x: M  y# t        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”
% q* T+ Q4 }, U; ^5 Z( V
, C7 k4 e2 {! p% P9 uurl=”jdbc:jtds:sqlserver://localhost:1433;SelectMethod=cursor;
7 J0 U; R$ [7 T1 g* e, \
) q8 z: d0 L; `/ r2 xDatabaseName=webpagetest”

driverClassName=”net.sourceforge.jtds.jdbc.Driver”
& x5 R) e5 a9 [0 A* |
& y# A5 p7 U0 c: Susername=”aa”
6 Q) r# X# [: V. E
password=”aa”
5 A  ]+ o1 C6 G- ]
4 o# w0 j8 Y! u6 X0 `0 G6 d0 DmaxActive=”50″
7 E3 K$ g6 o3 C) n9 k% g: m. M
maxIdle=”10″

  Q- {  G: V) ]4 z1 I7 t" w2 ImaxWait=”-1″

8 Q) ?. Q9 K; u7 Z& Y8 j3 x/>
  W* ]# K; ?0 ?" m) b) W
2、配置自己的web应用的xml文件
, ]% W5 [: W5 W
8 l1 k; e( i7 i( H5 U

<Context path=”/eb03web” docBase=”F:/workweb/eb03web”
3 }/ T) ]  P# c# S; E; z
privileged=”true” antiResourceLocking=”false” antiJARLocking=”false”>
$ A, r" ~# g9 q2 Y! H/ P
<ResourceLink global=”jdbc/company” name=”jdbc/company” type=”javax.sql.DataSource”/>

</Context>

% C, ]: |" C+ o4 a5 h! l& M

7 e' g; O; V/ l/ B& w3、配置web.xml文件

7 X7 Z9 a% v# `5 ]. t( Q与服务器建立连接

9 _+ h' q& L, N4 _- l* J<resource-ref>
+ w) i* y2 w' r( t; Z3 \, ]# W
$ u* w6 @; o" {" W* J) a. M<res-ref-name>jdbc/company</res-ref-name>
) {; k* v1 m( ?+ `" _: Q
! Y& p' E+ p( u- v. ~, c! S5 Q<res-type>javax.sql.DataSource</res-type>

, E8 M$ K5 I$ Y8 A, o: _<res-auth>Container</res-auth>

</resource-ref>
1 _/ C+ I' @6 |: b5 w" Q" |
1 R; f; m' l7 ]: A8 g4、在应用程序中不直接与数据库连接，通过DataSource连接池建立连接

8 G$ y& R/ V; P2 c9 C( a. R//1.在程序单独用时设置系统的属性，在tomcat下可以不用配置，
& y8 d% T, }, }7 K4 e1 ?
System.setProperty(Context.PROVIDER_URL,””);
3 Y7 I3 v) R( c* |2 {  C. u2 E
System.setProperty(Context.INITIAL_CONTEXT_FACTORY,””);
) {9 ?% l' D4 ^6 ?
//2.创建一个上下文对象

InitialContext context = new InitialContext();

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

DataSource ds = (DataSource)context.lookUp(“java:comp/env/jdbc/company”);
3 c5 X$ C9 b2 {$ F( Y5 ]( S
1 w$ i( q6 B+ I7 H; N6 W4 ~' U! s//4.通过数据源建立连接

ds.getConnection();

admin

ORM对象关系型数据库映射
(Object Relation Mapping)
, C* ^: u  \9 x: ]' I( Q: x
4 p8 L& l) n  {. U% l; V一、映射的特点

& l* G7 P. D- i* j& L1.一个对象可以对应多个表
* B! ~+ s# t. }0 d& w6 r
8 t" r5 P; m/ A& T4 O2.一个表可以对应多个对象
9 F% g+ c9 }4 u( v2 T2 z+ R+ k
* o6 h, k. u1 L5 v; z: t3.对象和表的关系不用完全对应
1 L" j" j% ~2 o3 _; @2 q( O
  ^: r- r. C7 R8 `4.对象的属性的名称和表字段的名称可以不同

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

  B# N# `4 l4 P5 N# H6.对象中必须有主键，数据库的表对主键无所谓

# i0 m. O8 T4 y- b% ~/ J( v7.数据库中有主外键关系时，对象中可以有，也可以没有
- e! z$ w. j- y0 ]% ]
) M  C. V& A0 R1 W- w5 C& b3 }
: v8 q' J4 J9 T1 ^
二 、有一个映射的描述文件————>xml

三 、怎样实现描述文件————>一段程序

对象 映射（mapping） 数据库
/ C8 v3 L# h6 |  W% t) v( r4 l
user

  `( x1 j2 C/ u* P, Fid=11

name=”张三”———— > (1) —————> tbl_user(id,name,age,tel,address)
9 L3 E7 z! o4 E4 D
& H" ^6 O1 m# C; w5 v& Dage=25 <————(2) <————

. Q+ R. T& h* _' X& {, J
% }- d2 P7 m, i* f/ d$ E3 [4 O
$ I, c+ G! a+ }8 M; `7 r(1)从对象映射到数据库

1.JDBC
5 M; l5 x! O6 @3 h# E( C
2.根据描述文件来动态拼接sql
7 d7 ?0 @& _, s% O5 U* L% O
& X9 h! s, Q, F8 m- ~  v3 Q3.执行，添加到数据库中
/ E8 ], N6 e' S! m8 A0 Q

9 E1 b5 F, A/ r$ E
(2)从数据库中映射到对象
& r* O9 z- s* w3 Z! I% M
% a9 X+ h% m& _8 W; @5 b' n1.JDBC
" O* }( R1 w4 X7 R% p
$ `8 a7 r* ?$ k: ~! \( c2.拼接查询sql

9 U5 x. c  |1 B% C8 Q$ s5 K3.ResultSet

4.Model
; t8 y/ _7 D# S) O
6 T- }. x2 L/ Q0 B- n. }4 f

4 v1 ~, K' J; H, ^hibernate
; b( C- v  _& a* u  @% B开发流程：
5 }4 N5 P0 l4 Z- t( T  C6 P
是什么？
hibernate是一种基于orm 的轻量级的框架



) T) d; H9 {1 S/ v0 G有什么？
1. session 保持连接状态（依赖事务和连接池）
9 y7 A( j) x, ~& P. K
2. Transaction事务
" w- ?6 w1 U3 @, ^  L. H- U  s: N+ _
5 b8 H; F6 K8 \  c0 f8 ?3.
Connection Provider 连接池
7 @* j0 A; ?- v7 k
5 C5 z. f  I: G
. [# O$ w  p5 J6 F* j% L0 R
能干什么？
% l: R* j/ t6 D) f1.orm

& w* ~8 z( e1 x0 L  E/ }/ q2.提供操作数据库的接口，简化数据持久化的编程任务

4 a1 d$ r" D4 M- ~+ J5 o5 q" g
& R; n. {6 o' N  u/ ?
怎么做？
1.搭建hibernate的运行环境，将hibernate的包和hibernate所需要的包拷贝到lib 文件夹下

9 g6 F! q- ^# C2.O（vo）
- T0 O2 G/ v' G: o  Q6 L1 `
9 W0 ~! _! o5 p" U6 n, p* e: P* b3.R （关系型数据库中的表）
& y/ F" {& G/ l% Z4 D9 m3 z3 ]
4.配置文件
1 y' \; t: o# D" n) I( F
) N5 _2 `; _% @) W: X- A4.1 cfg.xml 放在classes根目录下，默认名字为hibernate.cfg.xml

a.与数据库的连接
) W" o: i+ f1 p* d0 ^4 o
b.可选配置

- n7 Y" @* ~/ R5 _( Gc.映射资源的注册

4.2 hbm.xml文件 名字与类名相同 并且与类放在一起

a. 对象与数据库表之间的映射

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

c.组件之间的映射

d.对象与对象之间的关系映射

# S# Q1 t# S' D6 \5、客户端
% _1 K4 [! }) |5 v' U- Z8 K/ U( }
( O+ }- D! x* u$ b3 f. M2 L: \  t1.得到SessionFactory

; M  K% D5 x% N2 S' e' V2.通过SessionFactory 工厂来创建Session实例

4 |6 e% b1 N' P( M: P3.打开事务
/ x; {# U, F# t8 u+ L8 M
4.操作数据库
+ w7 W: x( O! R/ `3 j( G
5.事务提交
- p* U+ L) h* L, c8 D$ T( v
6.关闭连接

# b- U2 d5 ~: S9 W5 N0 j" R运行流程：

整体流程
5 A1 \% c6 v6 b9 g; m" d9 w1.通过configuration来读cfg.xml文件
/ x; H8 O! n* r% w' r2 K
2.得到SessionFactory 工厂（根据数据库的连接来创建sessionfactory）

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

0 V: N; v4 @3 b7 ?" h; n$ w4.打开事务
% g5 C& t/ y1 g7 Z* x
5.通过session的api操作数据库

6.事务提交

7.关闭连接
6 h6 b7 {+ e$ c/ C
8 \6 M( F+ V9 Z6 r* [+ N

save
) S: m9 N2 M' y( @* `1.to—>po
8 [( p" d! i, U5 {
2.根据model和cfg.xml中映射文件的注册来找到hbm.xml文件
! }4 |  u2 z; I! M. Z
8 K3 x8 r6 ]9 z3.根据hbm.xml文件和model来动态的拼sql

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

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

, y/ Z' T( k& A& M9 D
3 u+ \0 \* Q  Y7 |6 b
update、delete
1.根据model 的id在内存hibernate的缓存中查找该对象

, u3 `( L- G5 t5 P- M0 i% v如果内存中没有就到数据库中查找来保证对象的存在
& C- U4 v9 K- o2 R
! B( `4 G$ o# g. X! x" m2.根据model和cfg.xml文件中映射文件的注册来找到hbm.xml文件

& r6 @4 ?- y' Z$ l5 U4 i7 L3.根据model和hbm.xml 文件来动态拼sql

4.客户端提交或者刷新内存
) P$ v; G4 E7 U1 p
5.执行sql



Query
" f9 b: Y$ o* o+ T% rload
; _. C# Q$ L# h
5 C6 R7 {2 i! w7 p: O1.根据model的类型来找到hbm.xml文件
! R3 {8 x- N# I3 M% K7 A! `
2.判断id对应的对象在缓存中是否存在，如果存在，就直接使用，如果不存在就进行下一步。
. J& q  i6 G$ m4 O9 g
3.用id做为查询条件来动态拼sql

; y3 I* z& Y: E" @% s* a4.执行sql 查询（先在内存中查找，如果没有找到（会抛出例外），就去数据库中查找）
. a$ h( Q- r% P" U+ @
5.返回一个model类型的对象
$ P8 y. Y3 c6 N* Q! p, k2 L
get

    1.根据model的类型来找到hbm.xml文件
/ ^" u. z& X+ E8 ?1 h- |3 f
2.用id做为查询条件来动态拼sql

, d4 \: A- h8 Y3.执行sql 直接在数据库中查找，如果没有查到就会返回null

' s) k0 W3 I1 b8 N) _query
/ _' d- ?( f$ F2 v& h1 h( j
" p) W  p" x7 J: L1.分析hql语句，得到model的类型

7 H+ I1 \& {3 _% V. ^2.根据moedel和cfg.xml文件中映射文件的注册找到hbm.xml文件
. q9 j: @3 Z9 w3 ?7 w1 d
3.根据model和hbm.xml文件来动态拼sql

4.执行sql查询数据库
" s& ^* V% a5 z
$ s' @6 x& E! a; {, a5.返回一个resultset

1 Z1 B% Z$ q2 S% |% c' k" Y6 j6 p6.循环resultset的值，放到model中在放到集合（List）中



# y0 p0 F# _' S1 J谈谈hibernate缓存机制
/ }5 v( c* |& X
缓存其实很直观的理解为放到内存或者硬盘上的一块区域，缓存就是一个缓冲的作用，有很多时候，我们的数据需要经常访问，如果放到数据库中，不是不可，只是效率上低，如果有了中间产物来代替数据库，就省很多事情了。打个比方，去买酱油，不一定一定要去酱油的生产工厂去买。代码中需要数据的时候，可以先到缓存中查找，如果存在，就直接拿数据，不存在就去数据库中取，也省了很多事。
, ]# ]: o3 X  n& l


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



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


0 ?; T4 U. S! i
$ s$ b3 E& ]9 E" e| 一级session缓存| | 一级session缓存| |一级session缓存| |一级session缓存|

: a# V& p1 ?6 F# v) h2 v3 ]# O| | | |

! @) d5 {6 _( m| | | |
& L" t  `2 U' j1 e7 n
$ @/ w9 B8 s/ U$ O' d4 I1 [—————————————————————————————————

* ]% O9 }" Q( C& M" ~9 @3 {& vsessionFactroy级别的二级缓存
2 j1 `  F% i/ y. V
——————————————————————————————————————-
' w: O1 [: P+ N- ^6 \; B! R5 L
|
0 l" }( p6 P; K" v) B$ t/ e
|
0 N3 [: S" y) q" ?: g0 K
|

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

DB

. X4 L' b3 G& Y1 ]' `$ F—————————————————————————————————————–

admin

Spring

• 是什么？
  . K5 i  R9 J" A6 A/ ^* [3 ^
  8 }( t- O. u! c# ^3 r; C

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

+ R+ W2 T4 U  c2 J9 J8 b' l+ |

• 有什么？
  % ~! Q4 o! d* M
    l. T5 ~0 K3 ^. ?3 V5 }' e. U

每个包的功能：

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

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

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

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

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

AOP ：面向切面编成

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

  f* |$ ^$ r4 ~- ~

• 能干什么？
  
  3 P8 z2 H& g- j: Q: i6 U

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

+ ?0 s8 x# t& ^- g

• 怎么用？
  8 }" k% D. [+ n
  
  • 搭建web工程，引入spring的jar包
    
  • 在web.xml中添加如下配置
    
    
  
  
  ) f3 {7 Z( ^" s* Y3 L

            contextConfigLocation

            classpath*:applicationContext*.xml
" O0 ]5 r; N3 V4 r, j

   
9 q4 a! R; c& e* i/ V- \0 [

        

            struts2

            

                org.apache.struts2.dispatcher.FilterDispatcher
' d7 `" b" [" N2 w

            
% b# |; F" o8 @8 D( y2 F

        

        

            struts2

            /*
6 O( p4 m" @- X# J

            

                org.springframework.web.context.ContextLoaderListener
! I/ H  r6 I* O& h4 t

            

        

• 部署
  
  5 }5 [2 d$ F% ~

• 容器和bean
  # I- S& t& k) O' I2 H/ y# |& @# S- `

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

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

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

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

• IOC控制反转
  
  / I% Y& G" f; l( s* H- V; C1 s* k
  
  
  / d. U1 u. }5 S& K5 h+ k# D: j
  从前的应用程序想要得到A的实例他会直接主动的去拿，当用了sping后，应用程序由主动的去取变成被动的等待，由spring来控制应用程序所需要的对象
  
  
  • IOC的优点
    
  1.可以通过IOC来获得实例
  2.可以通过DI来获取注入的资源
  • 配置IOC的原则
    
    • 一定是可变的资源才采用依赖注入
    • 一定是层间的接口或者是模块之间的相互调用才采用依赖注入
      ' o" F0 `& J# B! ^# d

• DI依赖注入
  5 j2 E6 i0 e' N" b! e

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

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

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

例如：

在配置文件中

" S  l0 ~! a6 ~- W/ c% n

在应用程序中

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

4 t6 Z5 b$ [7 x3 {* S

• Aop面向切面编程
  
  

1.AOP面向切面编程 一些较好的模式或者是示例—-范式
% L$ u  J- E2 m& W$ S1 x& s3 u2 l8 g

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

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

3.AOP 的概念

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

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

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

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

5.引入 ：扩展的功能

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

7.aop代理 ：实现机制

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

4.AOP的事件机制
  d  l3 f! A  @$ u$ I8 ^5 @( T

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

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

3.找到切入点

4.确定连接点

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

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

( A$ B7 U2 i, u& s% L; W) F/ Y0 @



5 P: v) p& Y# S. W  ?, b$ d
( U& d5 a7 ]1 U, i0 d2 r1 ]

5. AspectJ
0 X/ s/ x! t! p, S4 z) t

5.1.在xml中配置比较烦琐

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

, }2 r, Q2 j! g; [
5 r8 C/ ]; B$ y# o  r1 c+ e) G

         

( o1 m$ P: L' y2 C) Z
0 d+ n- l" I( N  w! d         

        
+ P, F0 I" p0 i$ \6 U

        

expression=“execution(* com.javakc.aop.MyTarget.t*())”/>
, ?7 c& }+ ^$ N( r8 F. p

        
0 V/ o  p" h* [, l( t9 O

        

   
/ J" i: r* U8 `! ~& v; [+ z# H

' B2 O" \* l# C

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

@AspectJ的基本语法

1.@Aspect声明一个切面，将一系列的共同的功能定义成一个切面
) S7 D! [9 N. ~" v; r

直接在类上定义@Aspect

2.@Pointcut声明切入点

2.1、用一个专门的类来定义pointcut，类中的方法名就是该pointcut的名字
0 {  T* W( L! P8 v& ?

2.2、可以使用匿名的pointcut

2.3、执行切点的几种方法

2.3.1 execute（public * 包结构.*.*.（..）） 可以指定到具体的方法
' K' M; Z' m/ @

2.3.2 within 指定到包，不能指定到类
+ i$ S* q% w* i7 u* u

within（”com.javakc.spring..*”）
6 A9 h3 Q4 m  F5 J& s

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

2.3.4 target 指定具体的实现类

5.4.advice的五种类型的示例
% r3 W, U- c" `/ b4 {; `% {) Q

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

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

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

在注解@AfterReturning中必须加上pointcut和returning两个参数
: z% ~. Z/ ^/ w, M

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

得到目标对象的方法的返回值，来作为参数，进行下一步的处理,参数没有顺序，按参数的名字进行匹配
: x0 W. d  E7 }/ _* i0 h# m

完成追加的功能

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
! X5 Y0 b8 k+ M: F

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

(2).
6 _$ P$ W7 Q! }3 z1 A/ v

     2.直接引用匿名的pointcut
' K& n; c5 P) f) d1 e

     (1).@AfterReturning(“execution(
* j' y1 \2 q1 q. f, M

* com.javakc.spring.schemaaop.Api.test4())”)
' E: F% _" x/ q7 s4 k

     (2).@AfterReturning(pointcut=

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

args(str)”, returning=”retVal”)
, B+ C; i$ i, k$ N1 `) w

@AfterReturning (pointcut=”com.javakc.spring.schemaaop.TestPointcut.t4() && args(str)”,returning=”retVal”)
; V% p* N1 d1 ]% Z

public void testAfterReturning(String str,Object retVal){
- l/ m/ Q- w: m

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

    }

5.4.2.@Aronud

     注解@Around环绕追加功能；

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

     必须有参数；第一个参数的类型必须为ProceedingJoinPoint；
& x" ?/ `! ^% P# H2 \. e3 ^# T9 n

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

目标对象的方法

     1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
( v2 @6 S1 p! |) n

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

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

&& args(str)”)
1 l8 m% y; x4 a4 d. X2 J* U

2.直接引用匿名的pointcut

     (1).@Around(“execution(
7 l2 ~' f# {$ L/ v  X1 ]5 U* l

* com.javakc.spring.schemaaop.Api.test1())”)
6 L; N) D: {: u$ l

     (2).@Around(“execution(

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

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

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

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

    System.out.println(“around1==========before1pointcut==>”+str)
2 x+ X7 v+ I- x5 B8 X4 ]$ a

        Object obj = prj.proceed();
# ?0 z5 K" n! M& V: m8 j& p

        System.out.println(“around1==========after1pointcut==>”+str);
' G. ^8 c3 u$ m$ W2 P) {2 L

    }
1 X! V  {7 H/ D7 r! R. t, _

5.4.3.@Before

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

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
4 u! G/ y0 [: _" Z3 B5 F- c* D& s

(1).@Before(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
5 U4 o% h# w0 X1 X' r; r

(2).@Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
4 E  K: M4 p6 {( g. ~7 G& D

注意args后的名称与参数名相同
! |5 ~, H( C9 @! t7 R0 f+ c

2.直接引用匿名的pointcut

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

(2).@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
5 e) x6 R7 ^% m( U2 `  d$ L+ i

注意args后的名称与参数名相同
/ I5 k+ }( ?& {3 U6 x0 f

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

}

5.4.4.@After

注解@After在执行目标对象的方法后追加相应的功能
2 }8 @' b, B0 H1 {0 ?: Q

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
7 c1 @) Q& ]3 u: j0 k. W( V

     (1).@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
, R# T& _$ h+ H  v' j

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

    }
2 r6 G  ?! U1 F  i; k% _" W9 {: b! A3 Y

5.4.5.@AfterThorwing
* A" U1 \& @/ u  ?$ Z; _' m+ ~

% j* G  Y- ]$ N  r
' c2 }- z/ l) U! @

• 描述一下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”);

! M4 I. @  ]9 e: g

• 谈谈spring对DAO的支持
  
  

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

简化 DAO 组件的开发。
Spring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法，用来简化代码开发。
5 k, f7 r% r$ O; g2 S( t

IoC 容器的使用，提供了 DAO 组件与业务逻辑组件之间的解耦。所有的 DAO 组件，都由容器负责注入到业务逻辑组件中，其业务组件无须关心 DAO 组件的实现。
9 p& g! D3 T' `; Q! z" l+ i

面向接口编程及 DAO 模式的使用，提高了系统组件之间的解耦，降低了系统重构的成本。
; Q  u2 F& N3 {( T. L5 g

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

异常包装:Spring能够包装Hibernate异常，把它们从CheckedException变为RuntimeException; 开发者可选择在恰当的层处理数据中不可恢复的异常，从而避免烦琐的 catch/throw 及异常声明。
& F0 P- G- j' U, k) Q0 W

2 X2 u9 e4 o7 F/ X  p3 D

• 谈谈spring对hibernate的支持
  
  2 l0 O2 q3 |" f: Q& O

在所有的 ORM 框架中， Sping 对 Hibernate 的支持最好。如 SessionFactory 的注入、HibernateTemplate 的简化操作及 DAO 支持等。另外， Spring 还提供了统一的异常体系及声明式事务管理等。
/ p9 x6 M7 J$ o' S3 I8 ^

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

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

        class=“org.apache.commons.dbcp.BasicDataSource”>
" Q' Z% ?6 k- S0 L4 ]( d/ s

        

            oracle.jdbc.driver.OracleDriver

        

        
4 |4 i: c* y% q' N) A3 i; {/ {

            jdbcracle:thinlocalhost:1521rcl
3 B! j% G2 e7 E% Z+ p8 V9 P

        
* ]4 n/ e: H$ o5 o1 I) R6 I

        
  f8 ^" e6 G: |1 o4 t

            javakc2
3 z: K4 ?* q0 _- z4 T! f/ b

        

        

            javakc2

        
5 I1 g# k! l1 H2 ]! V) \3 h$ A' `

   

   

        class=“org.springframework.orm.hibernate3.LocalSessionFactoryBean”>
8 R* v- H- y$ Q

        
0 r& S+ L4 k3 M4 z- c% h

        

            
, @& d! j; @* A1 ?/ k

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

            
- u' M, z/ u! c0 M# F4 p- s

        

        
+ Z! ~. A7 _! M* _

            

                hibernate.dialect=org.hibernate.dialect.OracleDialect

            
' i7 a& i% i& Y

        
" X& c0 E" O1 ^

   

   

        

   
8 T- D  K, a: {% {* Y

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

   

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

        
; @- j' r" Z, L4 u

            java:comp/env/jdbc/myds
% H5 B  X9 o5 y

        

   

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

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

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

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

   
, I# F: z! p. |$ @7 x

        
$ w5 n0 z/ {4 c* A# p

   
4 G0 B9 E% p2 ?7 J

   
; ^+ R! g* L4 \

        

            

        
% W- r: m' b( C  U& Q

   

" r( v8 S  Y& i* x$ p7 U

   
+ G. p% |! q" @

        

        
$ h8 h5 y9 k: A$ ]" F

   

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

Spring2.0之前事务的写法 - |$ }9 E. u+ q         class=”org.springframework.transaction.interceptor.TransactionProxyFactoryBean” ; y' W' y8 X- v. g        abstract=”true”> . g8 w! I2 J7 }" N                 PROPAGATION_REQUIRED,readOnly 6 e: D; E& }/ t* }+ ]                 PROPAGATION_REQUIRED - M: Z( v7 a/ I4 k& T- _ % h/ @6 u1 k2 ~$ Q$ g: z; } / J( y% V  u: q

! g; y0 k$ b' O/ k

• 谈谈Spring对事务的支持
  
  

3 ~. G; x6 ^  _. A1、声明式事务管理：

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

2.做法：

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

2.2

2.3 注入数据源

" P+ X6 B) [, T0 h0 O
) ?3 c: a0 ?7 ]

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

  }' }$ c- S3 I& i. T

$ W; ?- o. I4 P# k$ k) F

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

, E4 D+ R9 x/ G0 X6 Z7 v

2.6 定义切入点

2 }0 Z5 P! q1 V; S
9 O& J. _+ F6 \. |
6 G7 z' f2 S3 K# P7 T- K9 v! o- I

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

1.注解@Transcational

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

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

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

: F% ?& w! L2 j
; K: J' x2 O! c. F) `2 b' j9 \

如何在Spring中使用Hibernate的事务：
+ f" l: W, g2 M$ [; x2 G# D

" H; P5 Z8 v, z% e# F

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

) O" h3 _, t0 W1 @6 x7 |% R

admin

事务
ACID
9 c+ e( k3 l4 G; q- x- e1 z9 ~（1）原子性（A）：一系列的操作具有不可分割性，要么成功，要么失败
3 [! C5 Z% x: E- ^- k$ X3 w& ?
, k3 z& a& L3 o$ W4 O) ^（2）一致性 ：操作的前后满足同样的规则，保持平衡。
. D4 v# r3 p5 u1 v2 X- Q, V0 \
: e! F  ~3 X! b: H- r1 ~（3）隔离性 ：在事务运行的过程中。事务内的数据对外的可见性和可操作性（必需由数据库的支持）
7 p, d: \- v/ }9 a. N
（4）稳定性 ：保证数据在事务的操作的过程中不会遭到破坏，而且是永久性存储的

4 o. t  ^' ]+ p0 G" D, c/ h% X
# B9 G' n! E  K$ I6 b4 P
! b8 z3 O* L  v( X6 x) O, e2 L5 `$ {事务模型
（1）经典事务模型又叫平面事务模型（JDBC） 事务不允许嵌套

+ |: C' K! E' S$ A/ O（2）嵌套事务模型
) L. N& |  i, O% `. Q4 h
6 a/ s, F- f, M" R) F

$ i* l4 w" m9 k: s事务的两种方式
, W4 I. c. Z) d$ [（1）声明式
5 a* w8 Z/ o3 E4 ~3 _
+ V, \+ c. Z) w1 [) S* @+ e在配置文件中设置以下6项
  F4 I3 H. V, y0 s- y8 p1 D( z; V0 d
（１）.required
5 W5 V4 p: P  d0 V: D
: M) }0 e1 G: Z0 @8 i如果客户端没有事务　在bean中新起一个事务
! l, B4 G/ u1 V7 ~
如果客户端有事务bean 中就加进去
) n2 n! Q# e; X) @# s& T9 q% J
4 [% j5 e2 e7 n(2)、 requiresNew

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

9 ?/ a6 D- L8 x! [5 y7 C如果客户端有事务就将事务挂起
7 H, m6 @/ k$ Y
(3)、supports
: @; O2 H$ d- g  q
! U5 W/ e4 v  t: d如果客户端没有事务服务端也没有事务
* |% _4 f9 A2 G9 b
2 v# D4 d1 H/ `+ d4 Q8 m如果客户端有事务服务端就加一个事务

(4)、mandatcry

如果客户端没有事务服务端就会报错
, j+ W9 r' y* [* M, h+ Z7 [. J
: p' l* u: y; w' n, N  A6 x, t如果客户端有事务服务端就加事务
( I+ b% f2 o2 S; \9 ]) T7 L
(5)、notSupported
8 C; U. ^8 }" r3 g8 u% e
不管客户端有没有事务服务端都没有事务

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

(6)、never
0 D& R8 X5 p2 q1 t$ q: V3 N" N$ E( J
不管客户端有没有事务服务端都没有事务
1 ^/ V: g2 m* x5 J9 u4 q* N+ v; x
8 g0 r9 V# M/ J2 B  I0 j如果客户端有事务就报错

（2）编程式事务
. i* n! S6 p7 _2 l' I" T) V
Javax.transaction.UserTranscation

% ?0 D% q# D4 l' e4 B4 DJTA 事务可以精确到事务的开始和结束

; Z  m$ S: e7 @! X

事务的隔离性
Read-uncommited
& [4 _* j1 `5 N1 M" E
, @0 `# l* @7 y: d9 B, t7 \读取未提交的数据（基本上没有锁）脏读，存在不当读取的问题。

1 Q* T/ h- p. A* |Read-commited
4 x4 M) b% ]9 K+ s9 X
读取已提交的数据（行级锁）
, J# w; f) D9 ^1 I1 K
( \$ K1 C& a4 l无法读取已经写入，但没有被提交的数据。

Repeatable_read

读取的数据不允许修改或删除
9 _) X% T/ F9 Q' \2 Y- q3 p1 p
不可重复读（行级锁+不允许修改/删除）

Serializable
. l) Y! p& n2 z
5 @- x% z! K7 h8 h( u幻影读（表级锁）
7 `4 n+ t) @1 a7 e, ~( U  a


struts
( d; a- K. [- L& Z3 g* {% t开发流程
/ K3 D& t& e! ~4 F+ h
$ u! G0 Q6 }: X3 y7 Z: S: p& s6 U1、创建表单
& }) C5 h( X, V2 O
2、从表单中获得输入

& d& w9 T' C+ U0 U4 m5 ]+ T, p3、处理输入（业务逻辑）

/ a8 u8 Y9 r. A5 ^: {) O$ @4、根据动态输入改变输入流

  j' a5 G. v3 M1 d# U' a要完成上述四步，我们需要创建
9 x- ^+ F* A$ |7 X2 {8 x# B" n
1、一个ActionForm

2、一个action

3、一个配置文件struts-config.xml
' _' ]0 `  z6 Q* p$ v+ }
+ j+ _7 W2 k' D# x4、创建页面

创建ActionForm
" K. s. o0 \6 C; U0 p
1、写一个类继承ActionForm
+ N& J' Q" k: d* E
2、私有的属性
6 A2 `! u& s3 t' ]4 C
7 n# k7 m* a2 D$ D6 z: E  l3、相应的get、set方法

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

创建action
2 j7 Z/ a. \  [  n- n9 B
1、写一个类继承Action

2、实现一个公有的方法（回调方法）

public ActionForward execute(ActionMapping mapping,
% U! n/ ~  l* d" d  f
0 ^( U4 ~( f& G- J, V' i, bActionForm form,
+ `) ~9 g5 Q6 B" N
) q9 f  B3 G( r- x: Y3 n( lHttpServletRequest request,
8 w4 V) y% y% g( b( [! Z1 ]! z! D
HttpServletResponse response)
& S4 Q7 R7 l- Y
, c, r+ u  b* F6 j9 R, |{

//1.收集参数
/ u$ t( A8 {+ @6 f) {
8 D2 E! i, p$ G" r9 ~7 b8 gMyActionForm myForm = (MyActionForm)form;
+ \4 l1 k- H# ?, o! ^; V% q, L
//2.组织参数



% Z6 E/ `* X1 r# h//3.调用逻辑层

/ N+ N7 l6 [' W8 K! h+ \boolean flag = true;
4 A/ D+ [& A0 [5 b' ]; l2 y
//4.根据返回值来跳转到相应的页面

. a8 R3 N  B  ?6 K, M$ VActionForward af = new ActionForward();
6 [: ~. T7 e8 k$ F
if(flag){

af = mapping.findForward(“1″);

}else{

6 e! v+ j5 P9 h1 q1 qaf = mapping.findForward(“2″);
( Q( Z, }# ]. L
}
+ l( K7 [, M2 h. x* L2 X' k
return af;
2 s/ x: z, `( {% t. U! n# \
}
0 O, R/ h) {) Z5 |
) o5 B: M6 b9 T) l; M6 M9 d配置struts-config.xml文件

1.<form-beans>
. M1 J- b" ]) N3 s8 }, n+ u
+ z% G0 `0 V5 F7 {8 \8 I<form-bean name=”myActionForm” type=”全路径.MyActionForm”/>
) f# \7 y2 @0 L- {
- Y" T- X) t( U* u9 ^% ]7 H# H<form-bean />
* v1 a: v/ r6 J& Q% |
</form-beans>

) r$ O% i+ W! O6 C2.<action-mappings>

<action path=”/sll”
% I$ ?9 F2 i0 }4 E
name=”myActionForm”
6 d# g7 ?5 {0 I+ @
type=”全路径.MyAction”
6 X4 l( h' ]* ^7 g. }, c7 ^
# i. a* y0 W( Sscope=”session”
, W! \6 _' q, F2 {# f. ?' [: T
; N. Z+ i+ e7 s1 a* ^input=”错误返回的页面”>

; S/ m  m8 k8 h<forward name=”1″ path=”/1.jsp”>
% [) {, I4 v: M5 \( c; A
4 t. l+ r! G# g. f- Z. _<forward name=”2″ path=”/2.jsp”>
& T& y' z) i' g- J$ k$ l3 Y
7 U4 _7 B0 |/ P9 _, @% ~  Q, l</action>

+ |* c/ O1 Z* N5 Y4 i% z</action-mappings>
  \5 K& M" b; }; F3 w) M
5 F. Y4 d! I( V1 S, x- d步骤:

1.创建一个空的web应用
) I# A. I3 O, @- w: r
2.将struts的包放到lib文件夹下

0 C% n: m! B' s# _5 w- K/ k: A3.将.tld文件文件和struts-config.xml、web.xml放到WEB-INF的跟目录下

0 J% h0 X) ~- R* b$ [4.配置struts-config.xml文件和web.xml文件

5.在页面引入tag文件uri

STRUTS运行机制
1 m7 i+ W/ A, R& c/ [0 r
( ?2 ?% |9 E) a% D1、界面点击产生请求
5 p8 `$ q7 G0 ]" F- B# ]7 @
' R5 V* y1 L. Y2 w6 h* @8 }' p2、容器接到请求
3 I4 G: z' ^* U; \" {) \" B
3、匹配web.xml文件中的*.do来调用ActionServlet
9 k& P7 a  d. |) _
% c3 v1 }9 }' A: ^4、ActionServlet的处理
7 j- g6 ?- S+ \7 O3 H+ \4 _4 G( Q+ \
4.1 读struts-congfig.xml文件形成ActionMapping

4.2 通过path 来匹配Action类，通过Action的name属性来匹配ActionForm类
3 i' e5 v) k7 p! C3 t" R
4.3 通过反射机制来给Form添数据
( E5 [/ v% U& d# S! V2 [2 g
4.4 由ActionServlet转调Action的execute方法

4.5 得到execute方法的返回值，跳转页面
' |- m! A; N# {! K, |: o
* X8 O2 O) h5 `0 @) h3 \. |; |4.5.1 RequestDispatcher

4.5.2 response.sendRedirect(“list.jsp”);
" r6 \% n. _. Y1 a, E* ^
- q& B! |8 o- B3 h8 f; @5 c

: l2 ^8 U5 t* k, f进入execute方法

! i0 Y& t8 C5 x1 收集参数

6 p/ k, T) ?2 ?" i! x2 组织参数

3 M) {4 Z+ R! C& j8 ^3 调用，逻辑层
8 Y" F5 B6 e* x( J3 d3 ^3 U! M
" }: I6 t+ d8 x+ u% s4 返回值
4 z+ e# V# j" f9 E$ ]
4.1 选择下一个页面 （ActionForward）

: E/ i9 ?5 w. e. s. z; G! X4.2 把值传给下一个页面



比较struts和struts2的不同

# D" t* {# ]  s0 U& @Struts
- @7 Q8 R+ D; u
Struts2
: j$ G2 f! {- _% W$ t1 n: g
组成        五个部分：ActionServlet，ActionMapping，AtcionForward，ActionForm，Action        十个部分：AcionContext，FilterDispatcher，ActionMapper，ActionProxy，Configuration Manager，Action Invocation，Interceptot，Action，Result，Taglib
url        .do        .action
! r8 q5 k! T/ x5 ^& S- @分发控制        AtcionServlet        FilterDispatcher
+ f6 J6 p) e: |收集参数        利用JavaBean技术，将数据封装到ActionForm的子类中；
0 U: V( a' t: x. N" m1 I5 U一个Action对应一个ActionForm的子类
- O6 E" f, N. X! M& O: @8 F
使用拦截器将数据封装到值栈中。
& R+ t- t" Y! H( t. t使用域模型，一个Action对应多个值栈中的Model
3 @5 V8 }- v" N- \( {, b# l
/ T. M7 V: l& \- o0 B& J3 s读取配置文件        ActionMapping        Configuration Manager
拦截器        无拦截器        执行Action前后有拦截器
返回页面        将字符串封装到AtcionForward，进行跳转页面        Action中直接返回字符串，通过Result跳转页面
页面跳转方式        两种：dispatch，redirect        三种：dispatch，redirect，chain
值栈        无值栈，Action通过在request范围内设置属性，向jsp页面传递数据        有值栈，Action和jsp页面通过值栈传递数据，jsp页面通过OGNL取得值栈中的数据
配置文件        struts-config.xml        struts.xml
中文问题        不能解决（需要使用filter）        可以解决中文问题：
1、在jsp页面添加Meta；

& P$ k( I& }0 T. \; @* m# f0 n5 @2、修改struts.properties中的设置。

admin

其他开发工具和技术
Ant
Ant是基于java的批处理工具
1 @4 j' |; p+ A+ R8 _" h
* I* v) O9 u/ g- L- W3 U5 A9 U7 x一、配置ant的运行环境
8 M7 m1 S, v2 W- \
1.将ant的bin目录添加到path中
. l" q9 u! g; F+ b( O' b) S" x
# O& O' J5 {( I2.配置JAVA_HOME

3.配置ANT_HOME
2 I! D. D- G% M6 i8 U+ R' `
二、配制build.xml文件，该文件放在应用程序的根目录下
, p0 G5 [3 F2 V3 m6 ~
编译java文件
, Z8 b% C% p9 H+ }' _
% ~! p1 Z& K1 q4 g3 ]执行java文件

' [* y: h  |! ~5 c& v; Jcopy

删除

& x0 b9 Z. K2 g2 f5 |& U打jar包
0 N, q6 q* A( z) {4 k5 A2 h2 f5 g
, O, Q! \" Y$ c7 w9 @2 z( [2 I0 @根据注解生成配置文件

$ `% m, y: j9 n& `9 ~Xdoclet
  v, H, `0 |: m& s6 D, t! Z3 m通过注释生成一系列文件的工具（txt、xml、java、html等）
2 `% U. F( ], j/ I( u7 a4 {4 B
+ |5 a' N. t5 P  j3 Lxdoclet本质是摸板技术+字符串的替换
5 h7 H  A/ Z3 r( \7 }* P% F* X/ Q: V
1.在java文件中写符合要求的注释（将hbm.xml文件的内容搬到java文件中去写）
# t2 @3 Y' A. z7 w$ a' X6 i) U% e
4 ~# ?  p9 P: I, F! y* {7 `0 y1.1 在类的上面 写与表的对应

1.2 将每一个属性的注释都写到get方法的上面
4 g: W/ H2 z) }/ ?+ e
2.在ant中引入相应的task来驱动xdoclet
( W  Y  U+ h/ o) G( P) W- F. j, ~) ~


log4j日志管理
1、是什么？
2 o4 v+ l* R; r6 s6 T2 c! A4 W3 D
在开发期间用来测试、对整个日志信息进行管理的工具
2 y1 q% k2 u$ `$ d. k2 }0 [
2、功能

1.控制输出的目的地
% r' O3 j: Z, a
# w* z5 h9 Z6 \3 }0 I* ~+ G) i2. 控制输出的格式

3. 控制输出的级别

3、日志的级别

1. debug 调试
4 g3 _# H. E7 A
/ W5 e7 ]1 X" `2 M  K8 u# c) ~2. info 给用户的提示信息
; S: @: [/ Z% a( F2 o
3. warn 给用户的警告信息
6 z8 N" \: {; u- U
4.error 给程序员用来调试

Debug—-〉info—-〉warn——–〉error

4、配置
6 ?1 w; ^7 ~, @/ [. B6 Z$ H5 ~
1.配置级别

2.输入源 （控制台和文件）

3.可以进行分包控制
- B6 u4 V6 ?! g: j2 O
Log4f.logger.包结构 = 级别
7 A/ p2 u: e3 ~4 i
5、使用
3 z  c$ g* n4 ?
Logger log=Logger.getLogger(Test.class);
/ Q% u, T6 W' _0 _, E9 c
    public
void t3(){
7 Q7 i1 p& U5 d" L3 ^4 v, v' W* w
; Y& E' {4 y/ j6 R/ J/ c        log.debug(“this is debug”);
+ I3 V4 u0 C% x) D, y
; d2 \- p3 p. ~        log.info(“this is info”);

4 @7 t4 y6 m- J* y/ J( e4 {4 }        log.warn(“this is warn “);
/ `- D6 F% U5 t( r
% L, g" c# J) X/ A        log.error(“this is error”);
" @3 s! l1 H: \- v3 E2 e
    }
5 W7 R" p" d' o( d
; j4 v0 c( g9 q7 y8 j1 LJunit
1.是什么？

单元测试的框架

2.怎么做？

写一个类继承TestCase

2 O3 `+ }& L/ [& I( Q; O+ t测试的方法一般都以test开头并且没有参数
6 I' A4 X, ]2 [
6 n' E( b3 p: Z- Z在测试方法前执行的方法public void setUp( )
% o% b0 d2 n; Q8 W8 N0 _
在测试方法后执行的方法public void tearDown( )

error和故障的区别

. q' p; S5 w7 R3 J  s; d  f+ ierror ：代码有问题

- O9 e! w; |2 x+ z/ k2 l' u5 u故障 ：逻辑有问题与祈望的值不相符合

4 L4 j  I( u; R4 g! J7 l/ K/ w生命周期

8 T% n, [4 q5 A# ]6 \测试—〉SetUp（）—〉testXX（）—〉tearDown（）—〉结束；
0 [5 @5 {* z7 i2 E
TestCase套件
# h9 W4 S1 G: Q8 j" ?
+ v. G3 U7 I0 h0 ^# {public class MyTest{

5 t/ T, b4 Z9 ~# N  F0 d        Public static Test suite(){

: O: G# e( |9 v6 ?TestSuite suite = new TestSuite();

# X' H( ^- T$ @0 jsuite.addTestCase(Test1.class);
0 V, C, W' Z* E2 Z& r+ d( r
; Z* C/ j* p! `2 s8 H2 a! Ksuite.addTestCase(Test2.class);

; h8 r; J- H2 {$ _: N9 `}

, A5 Y! d6 ?8 o# D2 P  D5 d7 \& K0 g}



Ajax
是什么？
1 X2 Y$ D5 t8 j. A# C' k- fAJAX即“Asynchronous JavaScript and XML”（异步JavaScript和XML)。是一种创建交互式网页应用的网页开发技术。
: M5 U; L! h$ d% h8 U5 r$ n: E9 Q
% ]$ K/ r/ c8 i; D/ t! K. t; j无刷新页面。
! u" m3 a0 w/ b: R% J8 f
有什么？
$ j0 ^) r) I2 w) xAJAX是多种技术的综合，包括JavaScript、XHTML和CSS、DOM、XML 和 XSLT、XMLHttpRequest。
: g) ~& f6 h  n9 ]
; }& `/ G2 k* s" c/ j) i3 p能干什么？
使用XHTML+CSS标准化呈现；
+ t6 V  ]) a5 ^使用DOM进行动态显示及交互；
/ P7 ~( J( a# c* v& o# j; }: e使用 XML 和 XSLT 进行数据交换及相关操作；
使用 XMLHttpRequest 进行异步数据查询、检索；
. x& o( b  _( Y' Q1 D, B* F7 r使用JavaScript绑定和处理有所得数据；

传统的web应用允许用户填写表单(form)，当提交表单时就向web服务器发送一个请求。服务器接收并处理传来的表单，然後返回一个新的网页。这个做法浪费了许多带宽，因为在前後两个页面中的大部分HTML代码往往是相同的。由于每次应用的交互都需要向服务器发送请求，应用的响应时间就依赖于服务器的响应时间。这导致了用户界面的响应比本地应用慢得多。
0 H5 I  x& _: j, L7 h9 N! L
与此不同，AJAX应用可以仅向服务器发送并取回必需的数据，它使用SOAP或其它一些基于XML的web service接口，并在客户端采用JavaScript处理来自服务器的响应。因为在服务器和浏览器之间交换的数据大量减少，结果我们就能看到响应更快的应用。同时很多的处理工作可以在发出请求的客户端机器上完成，所以Web服务器的处理时间也减少了。

! i. x  t, D0 n0 r使用Ajax的最大优点，就是能在不更新整个页面的前提下维护数据。这使得Web应用程序更为迅捷地回应用户动作，并避免了在网络上发送那些没有改变过的信息。
4 L; G7 C$ }) i, i
对应用Ajax最主要的批评就是：
1 它破坏了浏览器后退按钮的正常行为，就是用户点击后退按钮后不能看到之前的数据；
2 一些手持设备（如手机、PDA等）现在还不能很好的支持Ajax；
3 用JavaScript作的Ajax引擎，JavaScript的兼容性和DeBug都是让人头痛的事；
4 Ajax的无刷新重载，由于页面的变化没有刷新重载那么明显，所以容易给用户带来困扰――用户不太清楚现在的数据是新的还是已经更新过的；现有的解决有：在相关位置提示、数据更新的区域设计得比较明显、数据更新后给用户提示等;

怎么做？
: F" V8 X' a$ b5 w+ ^0 |0 J' p6 w<script language=”javascript”>
8 N9 C$ l9 ~( U1 X! @8 G; Z
var req;
( e9 ]  A' ?7 K1 @7 E
& E' Y; I' G1 m* C4 @/ U- Kfunction add(){

//1:创建用于传输的对象

3 A$ \  K( |1 @" Areq=new ActiveXObject(“Microsoft.XMLHTTP”);
. q5 @* ?; P# v6 u
3 W# Q$ R' z3 V5 A! [8 W3 A9 y( g# V# t// 声明返回后，处理数据的方法

) l0 q; c6 T9 V$ V# U& f  d: Dreq.onreadystatechange=manage;
5 O! m# ^5 r/ A
: X+ V" [4 U# c9 v//2:准备传输的内容

var str=”test1111″;
1 t. ]& @) ~1 z+ V" U) R
//3:发出请求

  r$ V- p! E+ L( Nreq.open(“GET” ,”/others/ajax/test/t2.jsp?str=”+str);
! K  e9 d/ f4 {* i! c) X$ T: j
. r5 E: r) C( i4 `, F+ Ereq.send(null);

: W3 Y: k" L8 e, F0 B}
) g1 P7 g6 V* o! Y7 a% ?+ G) }
//4:接受返回并处理

( W$ x. S' x$ ~2 I, V- ffunction manage(){
/ {. W7 I% @/ p8 C$ N
if(req.readyState==4){

alert(“r==”+req.responseText);
  o6 v+ E, f/ e7 o+ k7 N" N! B# J
6 |7 V/ n1 ]- d}

6 [$ h; l7 X# F) t5 C}
$ h4 D) A6 k* d0 a+ W
- J" H/ t( V* y& J0 x</script>

9 g( t- x3 Q& H! I0 c( LreadyState的取值如下：

　　0 (未初始化)
3 }% p: Z. O) M4 B% Q& q
% J! m6 Q: l$ Y6 f- J* o　　1 (正在装载)
# W; y+ P: p( {) S+ a" s. s
* ^7 Z' ~+ u! h4 |; {  b+ o　　2 (装载完毕)

　　3 (交互中)

　　4 (完成)


9 v# |! e6 H" E
  v9 X. a2 N: g" V7 I原理
% ]& f) u4 T! \8 D: kAjax的原理简单来说通过XmlHttpRequest对象来向服务器发异步请求，从服务器获得数据，可以是xml格式，也可以是一个字符串，然后用javascript来操作DOM而更新页面。

Dwr
( r6 X/ `' J3 p7 M/ w/ W2 P3 @是什么？
DWR（Direct Web Remoting）是一个开源的类库，可以帮助开发人员开发包含AJAX技术的页面。它可以允许在页面中使用运行在WEB服务器上的JAVA函数,被调用的JAVA函数就像是在页面中JavaScript方法一样。
2 Q* p  _/ W: w( [. d* g, I
4 y% y, B  `! r有什么？
它包含两个主要的部分：允许JavaScript从WEB服务器上一个遵循了AJAX原则的Servlet中获取数据；另外一方面提供了一个JavaScript库可以帮助web开发人员轻松地利用获取的数据来动态改变网页的内容。
" I- Y5 k" `" j


能干什么？
  ]: B9 P4 N5 C% }& `! p$ z动态地把java类生成为JavaScript，感觉调用就像发生在浏览器端，实际上代码调用发生在服务器端，Dwr负责数据的传递和转换。这种从Java到JavaScript的远程调用功能的方式使DWR用起来有种非常像RMI或者SOAP的常规RPC机制。
# w- D9 w& J1 Q* `, d1 m6 j

; Y' R, C0 E* [& f  ?, {
7 e6 Z  O0 Y+ ~% `9 b怎么做？
① 编写配置文件
  M' V+ h+ D0 F: D% J, s* V' v7 }8 Q
web.xml
9 S. y3 r" p# ?3 x# d/ |' h
2 j3 O. D7 I0 I7 M) S5 I: W<servlet>
% u% y) j6 a7 K) C; G8 M, W
& N5 j1 p3 f, x( Y+ c& u0 _8 \3 ~- x<servlet-name>dwr-invoker</servlet-name>
& i0 }  V6 o* b/ b% n8 \' J  h/ d
<servlet-class>
2 W/ b" a$ }: |
% [' W4 y! Q* ?/ Morg.directwebremoting.servlet.DwrServlet

</servlet-class>
1 j: S+ p+ E: P+ _* ^
% H; a+ b0 Z# o$ j. @4 k( u1 `3 i. I<init-param>
0 M( v, R1 @- a: `
2 n, I9 y; g# u9 Z<param-name>debug</param-name>

<param-value>true</param-value>
. C3 I7 k3 w5 A8 _" t, W! m2 c' t
' S) u7 `- t, K! E# a# w2 \- j4 L</init-param>
4 C8 v: `" ~4 a3 }& a; ^& @9 r- h
</servlet>

<servlet-mapping>
' m( e5 f( [4 T  |' A
<servlet-name>dwr-invoker</servlet-name>
  Y6 w5 G# k# p6 a# M& |% p# t
<url-pattern>/dwr/*</url-pattern>

</servlet-mapping>

dwr.xml
1 a6 M4 `3 A) i# ~
! S6 o, o/ I: j  W6 x6 L<allow>
0 N' D: m9 N8 V
+ H0 g, s  N7 K: ^$ J<create creator=”new” javascript=”kc2″>

<param name=”class” value=”dwr.Service” />

</create>
$ l! {; v- G+ {3 q+ W
</allow>
9 b/ ^1 l5 n2 K
②编写service
1 R9 a6 c5 h% K6 W3 n! l2 n) G
public class Service {

$ I9 x: V9 S7 c& Z! h1 u% Vpublic String sayHello(String yourName) {
5 W- o/ B9 s) F5 s# G
6 P% b! m( y: P+ o//可以是访问数据库的复杂代码

return “Hello World ” + yourName;

9 W' W; ?3 ~1 \0 G# }: d}

}

③测试DWR

7 T/ Y9 i. x( c/ F$ O  S将代码放入应用服务器（比如Tomcat），启动。
( y) A; u6 a& s. ^
然后在地址栏输入http://localhost:8080/你的工程/dwr

" g- `! u7 P, q/ Q3 r④编写jsp页面

% L$ }3 Q1 W. |7 S! r# N1） 要引用3个dwr的js，其中engine.js必须要，如果需要用到dwr提供的一些方便的工具要引用util.js
: a8 n- D; K1 F1 f# {/ }
2） 然后还要引用dwr自动生成的js，dwr/interface/service.js，注意js名字要和dwr.xml配置的一样
* J' }0 L4 U; D7 A- U
2 B( n* A* G% E; E# T4 u3） js里的service.sayHello和java类的那个有一点区别，多了一个参数，用来得到返回的数据