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

admin

JEE
简述JEE
  A1 m6 o4 |  W; q5 r- sJEE　： JAVA　 PLATFORM　 ENTERPRISE　 EDITION

JEE是一个规范集；

JEE是一个框架集；

2 ^6 d! _# u- h5 h  f& D  zJEE是一个技术集或API集；
1 w: a' Z2 ]4 H- b) g5 @5 R
适用于创建服务器端的大型的软件服务系统

$ k  I1 W# m( Y2 k

. L$ C2 b* \0 ^# hC/S B/S 模式
, y/ W6 m9 ?2 a4 N* L1 {C/S client/server即客户机/服务器模式，客户端也参与程序的运行与计算（富客户端、胖客户端）

  h2 Y3 u2 @7 xB/S border/server即浏览器/服务器模式，又称为瘦客户端，客户端不参与程序的运行与计算
' r6 @4 J4 O8 h! M' d8 m$ g


企业级应用（大规模的应用）的特点
" o! B1 X; D* F% V1.生命周期长、稳定、可靠

) n* w5 u$ i& }) C+ w6 C2.组件往往分布在异构的环境中，能够跨平台
4 g2 p9 r3 b9 U# z+ p. |
" c- X. Y2 a& k6 ?3.维护性、扩展性、重用性
% k1 m/ @2 e* N, p4 [
4.有事务、安全、线程
2 u6 V; ]  G4 P6 p

- g$ U* c3 u- E, U9 U
什么是业务逻辑？
2 i) s# V6 E7 D& B: [依照业务逻辑划分模块，
/ e! p4 V! @2 b
" T0 {! d' X$ M3 n  z- x& h所谓判定业务　就是具有以下特征：
/ T. j9 X6 K( X3 |3 r% q9 J; ~
; H  v3 _! S. M1.业务流程

2.业务判断

3.功能组合



7 U' V9 c) c0 J4 C* V" J1 t平台（角色）的划分
1.平台供应商。提供满足API集实现的厂商（BEA weblogic IBM webshphere）

$ ?7 A% d$ f- j9 @8 n' Z2.组件供应商
9 c; ^( |; {9 m; M2 J
3.组件装配人员

4.部署人员
% ]. h' K) I! F6 _: h5 Q
5.系统管理人员
9 J8 ?8 T- a! U/ e% }5 S& G& w
& |6 j9 M4 E( h% P6.工具供应商 提供开发组件所使用的工具（Jbuilder、eclipse）

* o& w. M" G; o, T
" a# ^; j) I9 [) ?) ]8 g
java技术分布（设计架构 模块内部设计）
" j) Y; w5 W- A2 G0 c7 u1.表现层 Servlet、 Jsp、 JavaBean、 Taglib
/ @$ i4 ]8 A; v2 H9 {
0 M+ ~( x) N8 }. P: H, ^! a2.逻辑层 EJB(SessionBean)
2 f/ R3 N$ a6 p  F0 E4 Y
3.数据层 （　JDBC 　EJB（EntityBean））

+ A. z# s2 W  X* ^: g" ~9 s4.服务 JTA（JAVA事务架构） JTS（JAVA事务服务） JAAS（JAVA授权与验证服务）

5.分布式通讯 RMI（IIOP）+JNDI 、JAXP（JAVA 的 XML 架构）
  S+ P0 v! s: y  Y8 Y
" q+ Y2 n; Y, g6 wJAVAMAIL（邮件服务）、JMS（消息服务）、IDLC、JCA（JAVA连接器框架 （成））
7 @; C# z% Y7 w3 _9 I( ]
, S  g" x1 k9 j7 ?5 Y  L# ]% L6 ?

) i& [: A6 Q6 a: h2 x# b; lJEE的体系结构： 是一种组件的体系结构
9 S0 a4 K: R# v  R0 O1 H7 A1.组件 ： 能够完成一定功能的封状体（独立的功能的集合）

不能单独运行，必须运行在容器上
: j1 A% b& e% X" p+ n# _+ ]& Q9 Y
分为两类：web组件、ejb组件

* _# K" e2 w- ]$ S" V1 p, ^2.容器 ： 提供组件的运行环境，并对组件进行管理（一段程序）

6 D7 T. u, B+ K( Q$ s, B& N管理组件的生命周期
% m& ~+ ]  d& g) f/ v' v
不能单独运行，必须运行在服务器上
- Q9 d+ k  m$ G
程序（组件）通过上下文来调用容器（context）
  J: W: s. H6 M# g8 A
. a  v, \; N8 O3 Q组件通过web.xml向容器描述自己，使容器能够认识组件
7 ?+ A5 d& E3 L& K" r
2 m. l  q% I% ]+ a7 q: U# d3 L- Q( K容器通过回调方法来调用组件

$ p- x5 T1 K6 Z$ u+ k1 |" G( y分为两类：web容器、ejb容器

, B, c) z# d% @) R3.服务器 ： 提供容器的运行环境，提供大量的JEE基础服务
) ]/ f% H1 u/ c" o" s
web服务器（只提供web服务）
- Y! D4 J: _( a  A
jee服务器（提供web、jee服务）
. {/ t# t) O8 ]6 u0 m

' T2 q3 F5 ^; i
0 U3 {+ N3 b" G' \$ N什么是回调方法
' t% P! l5 a& o5 K$ Q% h7 f由容器自动调用的方法，就叫回调方法。
% K' M+ z1 M4 e0 |: o9 x! h6 b* E


ＲＭＩ远程方法的调用机制
5 U  q2 O# I4 k例如：Ａ主机有Ｂ（）方法，Ｃ主机有Ｄ（）方法，Ａ　想调用Ｃ主机的Ｄ方法

+ w* l- w4 A/ v9 Y! g) }. ]
5 H- I5 q" H, e7 ?! L


学习方法
1.规范（熟记） 2.熟悉API 3.多练 4.多想

admin

Servlet

•     描述war包、jar包、ear包的结构
  ) D  R& i+ {. J3 w
  
  8 F8 H7 L% m1 }" n  h6 i

war-                            web文档压缩包

—WEB-INF

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

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

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

' v: q; G: S0 c) Y  @

jar-                             java文件压缩包

—META-INF

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

; B9 ?$ C3 z! ~. h: I- Z$ ~' X0 d

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

–META-INF

—Application.xml 配置文件

–*.war

–*.jar

• 什么是servlet？servlet主要做什么？
  
  
  

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

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

) s; N+ ~* Z0 g5 Q" Q

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

优点：

性能（线程比进程更快）

可伸缩

Java强健且面向对象

Java平台独立

缺点：

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

• 常用的servlet包的名称是？
  9 \4 ]; Z& @! `/ L6 |% s# ?
  
  

javax.servlet

javax.servlet.http

• 描述servlet接口的层次结构？
  
  
  / d5 x5 w2 {( g1 ^  q

Servlet

–GenericServlet

–HttpServlet

–自己的servlet

ServletRequest

–HttpServletRequest

ServletResponse

–HttpServletResponse

• 对比get方法和post方法？
  
  
  

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

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

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

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

• 归类描述HttpServletRequest接口都完成那些功能
  
  7 G" n& s( h6 K# {7 N7 h
  
  • 读取HTTP头标
    $ _' r& t+ j) @1 \! [  q) A
  • 读取cookie
    / g- ]  f3 w, |5 a) J
  • 读取路径信息
    $ B$ ~1 a7 u5 z" q# i4 C3 L) u
  • 标识HTTP会话。
    0 _3 i, n, A/ d% q
    % u, e# g. K5 B5 D! ]

) d; x- m% h( X

• 归类描述HttpServletResponse接口都完成那些功能
  
  ) P8 D# G9 g5 M5 a! t
  
  • 设置HTTP头标
    
  • 设置cookie
    / ~% S7 G; P/ ^7 j
  • 设定响应的content类型
    
  • 输出返回数据
    
    

8 _( r) o" r; _9 P

• 描述service方法所完成的基本功能？默认是在那里实现的？
  0 r! o0 }" N$ G5 }# Q
  : U' K( y4 \5 T
  

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

实现：默认在HttpServlet类中实现

6 [0 p+ M" N5 Q" c% X

• 如何开发自己的Servlet？描述应该做的步骤和每步需要完成的工作
  ; k  y. W% O4 E3 N' s. O- X: T
  ( z' t- m$ A. B
  

1.引jar包

1)构建开发环境： 新建工程，把tomcat下lib文件夹下的servlet-api.jar引入到Eclipse的工程中

2.开发servlet类

1)首先继承HttpServlet

2)重写 doGet( ) doPost( )

3.部署

安装web服务器，例如Tomcat

在Tomcat的webapps目录下新建一个文件夹作为web应用的根

    在根下新建一个名为WEB-INF的文件夹，里面建立一个web.xml的文件、一个classes的文件夹、一个lib文件夹

    按照servlet的DTD配置web.xml文件

把编译好的servlet的class文件复制到classes目录下

lib文件存放程序所需要的jar包

4.启动服务器

• 为何servlet需要部署描述？
  : [7 O% Y$ Q0 ?4 I7 q
  
  4 h5 |- E7 D7 h2 \" w

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

0 f- D1 c+ d% V2 Z8 k6 T

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

<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
  + n2 R* W% n8 s3 |
  
  

FORM标记

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

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

语法：

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

{HTML form tags and other HTML content}

</FORM>

- D1 D9 u* ~, T% B- I4 ?

• 如何接受request中的参数
  : p9 J3 U: Q* x: ^; Q8 ]
  String userName = request.getParameter(“userName”)方法
  & v, U$ V8 g# f# G3 Z; z4 o, ^( a
  + k/ j9 u' n7 S" h7 g: v

• 如何接受request中header的值
  
  ' Z! X4 X( @  |0 m. Y
  

request.getHeader(name);

request.getIntHeader(name);

request.getDateHeader(name);

request.getHeaderNames();

• 如何输出html
  
  + a4 \; Q* R0 U5 I, x
  / S7 R$ O: ~* D/ M

PrintWriter pw = response.getWriter();

pw.write(“<html>”);

pw.write(“Hello”);

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

2 o0 Y& b% w% ^) J" o9 y

• 如何设置输出的contentType
  
  
  

response.setContentType(“text/html”)

• 描述servlet的生命周期？
  
  $ G7 Z, I) W$ N5 U/ z* b; D8 ~& t
  

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

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

& w8 ]2 k, `% i+ @( C, w6 y  Z2 B2 g

• 描述init,service,destroy方法的功能和特点
  / a* o# w. D% ~
  
  

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

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

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

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

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

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

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

• 什么是回调方法？有什么特点？
  & D' ^: k' y* T6 b/ v1 p9 S; i
  
  ! E9 _% V; Q- \# O# U) u* `

由容器来调用程序的方法

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

$ N3 ?5 L7 S! I7 s- ]. a9 m1 i& l

• 如何设置初始化servlet的参数？
  
  在<servlet>中添加如下配置
  ! a& \! G  _# c
  # m- G9 J- J2 s

<init-param>

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

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

</init-param>

1 e' U+ _4 h/ h/ J6 a; w. L. g% k& C

• 如何获取servlet初始化的参数
  ' {5 B3 H* [9 M5 {" p6 x  X
  
  % X2 s' H. b" j0 _

public void init() {

greetingText = getInitParameter(“greetingText”);

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

}

• ServletConfig接口默认实在那里实现的
  
  9 H- l0 j; E7 ?" W
  

GenericServlet类实现ServletConfig接口

• 什么是ServletContext？有什么作用？
  
  
  

Servlet上下文

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

• 如何访问ServletContext接口？是在那里实现的？
  # C- U) D" J) l% {/ R7 g6 j0 [
  $ ~( }6 i8 ^9 K' u
  

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

GenericServlet类实现了ServletContext接口。

• ServletContext接口的功能包括？分别用代码示例
  
  4 P: L: e& X* y6 h! ?- G! @
  ) v5 J, y( m1 I4 J! w. j5 O5 Z0 V

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

getInitParameterNames() : Enumeration

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

setAttribute(name:String, value:Object)

getAttributeNames() : Enumeration

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

getResourceAsStream(path) : InputStream

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

log(message:String, Throwable:excp)

• 如何设置ServletContext的参数？
  
  
  3 I- l2 Q1 }  h3 G

<context-param>

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

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

</context-param>

4 A0 v3 t0 t# T% f3 x

• 如何获取ServletContext设置的参数值？
  
  # |8 O& x: i( |1 g8 G
  

ServletContext context = this.getServletContext();

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

/ f3 S! S* w- k- p0 v4 p# c

• 描述Web应用的生命周期？
  , m9 T; H$ T. b8 n
  % [5 }) Z; m! Y  _1 m, m
  0 U* r) z( I6 `

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

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

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

7 u* t' n! G- X9 K" ]- G

• 如何用代码实现监控Web应用的生命周期？
  
  
  
  , U7 [6 @% [  w

public class Test implements ServletContextListener{

public void contextDestroyed(ServletContextEvent arg0) {

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

}

public void contextInitialized(ServletContextEvent arg0) {

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

}

}

! r; i! g6 b# m2 @4 p+ s

web.xml文件中的配置：

<listener>

<listener-class>

com.csy.Test

</listener-class>

</listener>

• web应用中如下错误码示什么意思：400，401，404，500
  3 a, ~( k: F( t# h( R3 ^
  
  400 Bad Request//错误请求
  401 Unauthorized//未被认可
  404 Not Found//没有创建
  500 Internal Server Error//服务器内部错误
  
  

• 描述Web应用中用声明方式来进行错误处理的两种方法
  
  ( p0 |' I0 }* O, _( ?
  

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

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

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

! U  k+ m' S# L# T; O+ u4 e

• 描述记录异常日志的方法，都位于那些接口？
  2 n" C' `+ z/ E# i  D! s
  " A, V6 K/ D& V% Q" [$ U
  6 W' B/ U% W$ C( v6 H3 G

GenericServlet：

log(message:String)

log(message:String, Throwable:excp)

ServletContext：

log(message:String)

        log(message:String, excp:Throwable)

  w! N3 w+ ]5 L2 Y' U

• 什么是会话？
  0 R0 T& V4 H0 I# t  I
  
  

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

• 如何获得会话？
  
  : i; H% _+ }6 L( w  k
  HttpSession session = request.getSesseion( );
  
  

• 会话Api的基本功能？
  
  $ H3 ~( c( o  W8 d  `
  - C( X# h$ l  B9 u9 U3 p

getID() :String
3 o. i" N+ C8 n8 d

    isNew() :boolean

    getAttribute(name):Object
* H/ `% \7 M2 r8 A0 K/ U0 r( w5 q* D

    setAttribute(name,value)
0 k6 G% Z  Q6 z" P8 e

    removeAttribute(name)

2 p9 C8 n$ w4 c  {5 p5 D# B

• 如何销毁会话？
  
  
  / o4 v5 T2 l2 C' {2 p

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

<session-config>
3 m6 H9 w& w1 R( m3 W

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

     </session-config>
1 D5 J0 z+ s9 z

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

invalidate()
9 ~6 Z$ n3 ?' y- h; f# x

     getCreationTime() :long

    getLastAccessedTime() :long

    getMaxInactiveInterval() :int

     setMaxInactiveInterval(int)

; Q- N% h( E7 h

• 描述会话保持状态的基本原理
  - s+ z6 N% ?# a
  
  

, A5 J) n, X# ]# g+ h0 a1 I7 q

    client server
9 X, n3 l+ O, G* \2 |% Q! _, U# t

- V' Z, j- L7 E' O

request
; M% X- z. H7 X. @' z

response (sessionid)

request (cookies)

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

  e* _6 g  A* M2 B$ |

• 请描述session和cookie的异同之处
  
  : \3 [  \7 b. g6 [( F4 J: k
  

/ b* @2 L" T! A5 p
+ J* I8 a% u2 ]/ r$ ~5 s# G

• 如何读写cookie，代码示例
  
  
  

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

response.addCookie(c);

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

        for ( int i=0; i < cookies.length; i++ ) {
; c& l3 V( u- _

            String key =cookies.getName();

String value = cookies.getValue();

System.out.println(“cook”+i+“:key=”+key+“,value=”+value);
* K  z+ B  F6 b( ?$ `& ^( e; w

     }

8 ~/ I5 P, f* J9 ~8 a5 l& y

• 什么是URL重写，如何实现，代码示例
  
  ' M  X' b( s& m# @" |: `0 b
  + c2 B3 m! H$ {# L) }: l8 h

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

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

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

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

/ T9 x& v! w, f& U5 {1 A
" t! k/ M, ?. O

• 描述web应用的4种认证技术
  
  0 J+ [: c$ k4 p
  

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

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

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

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

) q2 M6 D0 A, `4 X

• 什么是授权，什么是验证？
  
  
  

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

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

4 I+ Z8 F& J$ Z" M: N0 P: L

• 什么是HTTPS
  ) H" c6 I+ P: f. {- B. v
  
  5 Z3 o5 ?  k) n. N6 t' n% s% g

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

• 什么是审计？
  
  8 F1 R1 e+ j8 D
  

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

# I# i) N$ _1 W* Z+ U& W

• 如何实现声明性授权
  # @) ~+ p4 P$ `/ ?) }' M% i
  
  ! H: ]% t% D1 h: ^) R, _) }

1、标识web资源集

2、标识角色

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

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

在 web.xml里配

• 描述servlet并发问题？
  8 S2 N+ e0 b  Q* O( W  ~7 {* I
  9 e1 c7 N% a0 k$ @# S6 v" v
  ( I: h$ ~' B; e+ y/ p; U

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

1 W% q4 S- H& m  S% \/ D! i: s

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

局部变量（页面范围）

实例变量

类变量

请求属性（请求范围）

会话属性（会话范围）

上下文属性（应用范围）

" B! p  p) s9 o

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

局部变量和请求属性

• 什么是STM？如何实现？
  
  
  

SingleThreadModel接口

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

2 F" z5 v+ N: Y% {0 W# k

• 如何实现并发管理？
  
  
  + |( Y5 }" ]1 s/ X, N! a

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

使用synchronized语法控制并发

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

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

admin

Jsp
+ H: R% }  r+ R; n8 h/ G/ ]$ ?- _什么是Jsp?
$ a/ k2 `# y/ B# w2 M7 P. S# m3 iJava Server Page    结合java和html在服务端动态生成web页面的技术



描述Jsp页面的运行过程？
3 N/ x& d  T! h第一步：

请求进入Web容器，将JSP页面翻译成Servlet代码

第二步：

7 g$ N3 o3 ~- Y7 D. O4 n编译Servlet代码，并将编译过的类文件装入Web容器（JVM）环境
, M4 n9 |$ ?3 h2 |
第三步：

2 A. x2 i1 h9 p6 t+ B# jWeb容器为JSP页面创建一个Servlet类实例，并执行jspInit方法

第四步：

Web容器为该JSP页面调用Servlet实例的_jspService方法；将结果发送给用户
% m; P. w+ M; B' O  E+ J

/ \& G' L# j& }( _, J0 C
描述Jsp页面的五类脚本元素的功能、写法、并示例
% n# z8 [& }6 ?5 N注释 <%– –%>
/ z' A" w& ~3 h5 V% T( b, T* X
4 \! z0 }& Q: p. J$ ^<HTML>

( k; q" y" R2 o2 V<%– scripting element –%>

</HTML>

/ S- |% K2 ~: t8 m' [- {  J指令标记 <%@ %> 指令标记影响JSP页面的翻译阶段
8 `$ F; e/ j) l$ q3 P3 _
1 f5 |2 x9 t0 P$ q8 }<%@ page session=”false” %>

0 x7 T7 z+ I- b/ q& V4 q% `- |5 j% P声明标记 <%! %> 声明标记允许JSP页面开发人员包含类级声明
2 J: C$ J$ C% M6 ?
<%! public static final String DEFAULT_NAME = “World”; %>
' A6 n1 \# k5 G1 P! S
    脚本标记 <% %> 脚本标记允许JSP页面开发人员在_jspService方法中包含任意的Java代码
. {5 K3 G7 S8 W# O  F
    <% int i = 0; %>
6 i1 I2 ]. ?: E/ Z7 k+ j/ E
0 T" r+ B7 c9 L+ f3 \表达式标记 <%= %> 表达式标记封装Java运行时的表达式，其值被送至HTTP响应流 <B>Ten is <%= (2 * 5) %></B>

4 J% b8 b. d3 V& \+ k

描述Jsp页面中的注释种类和写法
HTML注释
+ b0 g' ?9 b9 ]; R, r* M: `7 f4 I+ U
8 X* t  X3 {& S/ r- O1 ]; M" M: N1 J; }<!– HTML注释显示在响应中 –>
9 H, m# G/ Y7 u/ P5 G) A
. _" \3 J( h4 L; [) u" p, `3 K' s5 mJSP页面注释

4 S$ t( V% E, Q. n7 g+ o* v2 |( F<%– JSP注释只在JSP代码中可见，不显示在servlet代码或响应中。–%>
# Z! s; y: l9 L* T7 v
Java注释
9 \& }& C) ?  l& r6 @& D8 a
% ?' [7 M9 N  h. u/ T* U' C<%

/* Java注释显示在servlet代码中，不显示在响应中
0 |" Q% S" j% Z/ ^* G
8 E* g# X2 _5 E6 L2 h% Q2 ?$ ^*/

%>
4 n; m4 q7 p  Q' V5 l* M4 A; T
9 `) `; o8 p; }  U

* h) _2 Q" q/ N3 q- ^3 D, f描述Jsp页面的指令标记的功能、写法、并示例
' b) E( p0 C5 R7 e. v" ]  P$ F. T. A指令标记影响JSP页面的翻译阶段

<%@ page session=”false” %>
3 v& g8 b" M% q4 e% A; e7 @7 n7 a
<%@ include file=”incl/copyright.html” %>

<%@ taglib %>
3 D- u  m/ n' D5 ]* t+ J+ A


8 W+ p( B7 q+ @2 T5 E7 n描述Jsp页面的声明标记的功能、写法、并示例
5 R9 B- f! N: U. |( `! g声明标记允许JSP页面开发人员包含类级声明

  M# r1 v4 c# N4 ]- x" K& m写法：
  d: U8 F/ j* _5 @( u7 x
<%! JavaClassDeclaration %>

例：
6 ~) a6 ^* u) |* Y4 ?8 A# y4 J
1 F" K/ h# f4 l<%! public static final String DEFAULT_NAME = “World”; %>
0 _, H7 N) B& w* g+ F" s- ^
<%! public String getName(HttpServletRequest request) {

return request.getParameter(“name”);

  q9 Z0 B( d4 u/ S; @}
# `* R% n, U% R5 J6 S) L6 m
. n$ Z3 f$ G. e: e! {: r%>
1 T4 [$ y' Y+ i
<%! int counter = 0; %>


8 R: J- m7 ]$ j  \) A7 o
描述Jsp页面翻译成Servlet的规则
jsp中的注释标记被翻译成Servlet类中的注释
% |. B$ M7 x# v' g; Y
jsp中的指令标记被翻译成Servlet类中的import语句等

jsp中的声明标记被翻译成Servlet类中的属性
2 k  L- _' T& h5 E/ L5 ^- v0 _
jsp中的脚本标记被转移到Servlet类中service方法中的代码

- `0 v6 P3 ~5 P; T' ^  rjsp中的表达式标记被翻译成Serlvet类中的write()或者print()方法括号中的代码
" ]- Y3 V* ~0 v+ W3 W% P1 a
. V% }  }2 b1 g. Y
+ O1 @9 t2 |1 x) l3 V4 J
8 T$ o  g' w5 X描述Jsp页面的九个预定义变量的功能、用法、并示例
% w+ r% `. |% r: s4 ]request 与请求相关的HttpServletRequest对象
/ r5 ^. h/ Z( Q6 K/ X
response 与送回浏览器的响应相关的HttpServletResponse对象

out 与响应的输出流相关的JspWriter对象

    session 与给定用户请求会话相关的HttpSession对象，该变量只在JSP页面参

与一个HTTP会话时有意义

6 L% N6 t2 Z- F8 {: v    application 用于Web应用的ServletContext对象
( s% ^" ^. N) P' k; h1 v& r
config 与该JSP页面的servlet相关的ServletConfig对象
: t7 f$ y9 q8 B1 A
pageContext 该对象封装了一个JSP页面请求的环境

page 该变量与Java编程语言中的this变量等价
3 f/ v: ?3 f, v
% t$ ]/ M- ?5 l! |5 N9 Y    exception 由其它JSP页面抛出的Throwable对象，该变量只在”JSP错误页面”中可用
, S# M0 m$ C* E4 N5 F2 @3 M+ ]


5 K" ~, G4 ?; U& d0 v; Q  U: S) Rpage指令的功能，写法、并示例，并描述它的如下属性的功能和用法：import、session、buffer、errorPage、isErrorPage、ContentType、pageEncoding
  g" k6 Y" b) E6 Y% k$ ?import import 定义了一组servlet类定义必须导入的类和包，值是一个由
  q8 c# A6 W1 i, K6 e8 N0 c
逗号分隔的完全类名或包的列表。

; X% i( m: s. t0 Esession session 定义JSP页面是否参与HTTP会话，值可以为true（缺省）

或false。
- D) K9 J% S/ G5 ^6 ^
buffer buffer 定义用于输出流（JspWriter对象）的缓冲区大小，值可以为
( w2 K" l- t" f0 Q4 h
9 S0 k" p' t1 @* rnone或Nkb，缺省为8KB或更大。

errorPage 用来指定由另一个jsp页面来处理所有该页面抛出的异常

isErrorPage 定义JSP页面为其它JSP页面errorPage属性的目标，值为true或
+ [& I# i  L5 b" x% L# _' ^
" k# b+ Y( N7 p9 X+ b5 \false（缺省）。

ContentType 定义输出流的MIME类型，缺省为text/html。

pageEncoding 定义输出流的字符编码，缺省为ISO-8859-1
4 y8 |9 Q+ X( d0 V( L8 C

2 X7 _; X2 s7 l
描述MVC各部分的功能？MVC的优点？MVC的缺点？
MVC各部分的功能：

! {. T! B; Z7 T$ u1 SModel（模型表示企业数据和业务逻辑）
: j0 B! ^0 {5 c4 E
封装应用状态

响应状态查询

暴露应用的功能

( q; b4 ^# Z6 ^/ j/ {Controller（控制器接受用户的输入并调用模型和视图去完成用户的需求）

验证HTTP请求的数据

将用户数据与模型的更新相映射

选择用于响应的视图
" j4 n8 h  K( e8 L
8 _1 h( n$ i- \% rView（视图是用户看到并与之交互的界面）
* S# I! F) z: r: M8 R
, s" |, k' ~3 z& u5 U产生HTML响应
. P& x# B2 N5 d1 I/ _
请求模型的更新

提供HTML form用于用户请求
3 e& W- ], ~3 n! ^# `# R% k6 J' l
, @* G6 ~  e: |MVC的优点：
4 J) _- F3 p0 o7 J% U* n
        低耦合性：视图层和业务层分离

9 {2 M+ ~  c( i- S8 X7 k( g高重用性和可适用性
  D2 H" B3 q, z& [0 `
# c" e. ^2 M" P, C- _较低的生命周期成本

快速的部署

可维护性

- \3 e& v8 W3 l/ M( k有利于软件工程化管理

提高软件的健壮性
# c3 g/ H5 |' N& Q! W% \! i: B" o9 z
MVC的缺点：

1 ~4 r( x' d6 N        工作量大，增加工作的复杂性，MVC不适合小型甚至中等规模的应用程序
' o; X" _& O. o. i& S' X
0 b+ c) c: g) z' x
# i9 k+ f6 h+ h- M
; w* k5 y& }8 G" Z. z. T什么是Model 1结构，以及结构中各部分的功能
8 S2 t! [/ e" V0 Z结构：jsp+javabean

& v( L3 y6 |" _( }; y# e1 ^. ?Model1中使用jsp来处理web应用中的视图控制部分

Javabean收集参数

4 a% k) b5 @4 k, v9 ~

8 s& @0 X+ n7 D6 S& O什么是JavaBean?
: H3 M5 A$ g3 a% p6 [6 Y3 ^6 a用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。

$ J" ?! ~' c5 y$ a: J( I

JavaBean的规则？
使用get和set方法定义属性

一个无参构造方法
" l% u% u( Z7 H* g9 y
无public实例变量( 所有属性私有化)
2 A. @/ L9 H$ [0 X; {' |8 p

$ n  N) A! \. N" [" B
6 J! }3 W/ W0 n! Y, I4 `1 J- w3 g, ]什么是jsp标准动作？包含那些？分别都是什么功能？如何使用？
JSP页面中使用类似于XML的标记表示运行时的动作
) E& e0 U( k: L( T
; f9 G3 I$ z4 V1 `' Wjsp:useBean
; \  d0 q* r' K) U
* Y% ~2 ?3 D2 s( ]* tjsp:setProperty
' y8 T- i# c% A$ C
jsp:getProperty
! c) v  Y' X/ z( d% I
jsp:param

6 S4 |5 \9 U8 C" R! v1 H- a, Sjsp:include

jsp:forward

5 }2 E* a* S) G; _0 \

4 G8 v" S$ ^+ y. j, N8 I7 i用代码示例如下标准动作的使用：useBean、getProperty、setProperty
1 W. M, U- l2 A<jsp:useBean

id=”myForms”
. N& m% N$ C$ f# t7 {. p; g
% R5 z. n. r- e) Y0 [class=”com.base.mystruts.forms.MyActionForm” scope=”session” />
& L1 m. l4 B$ s
    <jsp:setProperty name=”myForms” property=”name” />
) I2 z, B- s% S" J1 V% L9 k
7 L2 A) o- q) P& F8 \<jsp:getProperty name=”myForms” property=”id” />
3 q( I4 S! ^0 C
% ?& Q4 {$ h9 G# A9 C! e$ P: ^
- k. ?' \+ Z5 b! P) H2 @
描述说明Bean的四种scope
" k! V; c0 x6 M( n8 L! V. ^0 fpage
5 M1 l) E+ J" V3 m- A
request

8 a8 ?# Y: }3 H3 J3 L7 Asession

application
5 l1 q: u2 s, C" I" W; d
  Y$ p, k, ?3 o/ V) {' y* f! ^

描述说明页面上的字段和Bean中属性的对应规则
5 t, v6 E- a# F5 cid 指javabean的变量名

class指javabean类的全路径
! L7 V9 R! P+ ], h8 h2 T
scope指javabean的应用范围
, G% @% p' P8 w% ]/ w& B9 W% {
- }8 Z# u+ N% A7 \* pname指所用到的javabean的变量名
3 p- h' j) H% y: s) Z
    property指javabean中的属性

  y% [. x6 e% r/ a$ |+ a
3 B# r9 F- X& h  B& ]
6 q" ]: ~- B& Y3 @5 e% Y' |描述useBean动作的处理过程
0 J, J( {- J" `  C! W+ o使用id声明变量

试图在指定的范围内查找对象
& x7 b$ Z; |: X  j# A1 v9 S/ Z
7 l" o0 t. T1 ]如果没找到

创建一个类的实例
# {1 Z9 \- w: }. E8 r  P
; ]  b2 a0 Z- g4 A" N! \- U执行useBean标记体初始化对象
6 \0 x: F. ]8 s: q: J9 ?
如果找到
' e9 k- M. B# a( m, \, G* K# |
' P# e& ~1 n! s0 K" o) j* `     将对象转换为类指定的类型


" @. {3 e1 u6 w" }, U7 L8 r- f
* h, E$ k' P. F4 H1 b描述forward动作的功能
1 K8 E) u# P% y' z: b' I0 r& H使用脚本代码处理请求时，可用jsp:forward 动作产生一个不同的视图，
( E) [/ ?1 |' T2 X
使用同一个request：


# {! l3 ~8 \* A; [: w' I
' ?3 D5 {; G6 n( G2 c9 k什么是Model 2结构，以及结构中各部分的功能
; w9 o( ~$ [% Xjsp+model+servlet

; w  D5 O: {: zModel 2架构使用MVC模式，JSP页面充当视图，Servlet充当控制器
* L* J3 m/ j8 O+ z7 F
! R! C8 e3 K+ R3 t: I, S5 RServlet控制器：
$ }( C3 H2 `' r! D- ]
$ M8 U- N$ t# t) [验证HTML form数据

4 V! Z7 _+ k9 t3 M6 e. K- e; P调用模型中的业务服务

3 R8 m$ C# @" a存储请求（或会话）范围内的域对象

4 E; z+ W4 v; S. b9 G选择下一个用户的视图
3 t" X5 N5 U7 ^  A
2 e5 W( \+ s( a1 _( Y) a% S+ p, ?JSP页面视图：

使用用户界面（在HTML中）

  B5 X2 N+ @4 }! v8 p        访问域对象
% a& a4 G! A& F( S; ^9 K6 i# x
; M' U* K) D9 ~( d) s4 A+ I

如何获得分发器？分发器的功能？
上下文对象中的分发器：

ServletContext context = this.getServletContext();

RequestDispatcher servlet = context.getNamedDispatcher(“MyServlet”);
, _; F: C" r% K3 A; n/ x
servlet.forward(request, response);

请求对象中的分发器：

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

view.forward(request, response);
. F$ h! n* `' l, f: c
可以将请求转发到另一个jsp页面，并保持请求的传递性


: B* H2 l) S1 d* P: K
  Q) \- T  A/ b1 OJsp中页面跳转的两种方式？
2 N% g4 \) ~. m* |( T$ G1 J6 E3 i使用分发器跳转页面
$ a. B: }! `' vRequestDispatcher dispatcher = request.getRequestDispatcher(“url”);
7 y: S4 Q2 C0 A# m% d8 H+ [; Y+ S# P
; G, ?1 d- V  u2 X5 S1 `dispatcher.forword(request);
8 T+ ?3 Z9 u% d
    特点：保持请求的传递（上一次请求中的数据，在下一个请求中仍然可以得到）；
6 Q1 s" G$ X" }2 D% z! M
        转发的页面只能是同一个Web应用程序的其他Web组件

3 D7 @; ]) C0 b1 e! {8 f( h使用重定向跳转页面
8 h$ f; N5 }# Y) _response.sendRedirect(“url”);

" ?) n9 Y! o. Y1 a" |    特点：产生全新的请求，（上一次请求中的数据，在下一个请求中不能得到）；

        重新定向的页面可以是任意的URL
9 J2 M' q$ ]/ Q5 K


% }: P$ L7 L# `" b' E描述Jsp中引入另外页面的两种方法，并比较两种方法的特点？
+ T4 z3 a' w2 N9 A/ J<%@ include file=””%> 在编译期间把另一个页面完全嵌入这个页面,可以说是一个页面
1 ]$ U- g- N3 v
9 W' E2 l% b9 Z4 b1 ?6 V在这里可以共享变量

1 A- x! ?; h9 [- m: \<jsp:include page=””> 动态的再运行期间把另一个页面加入这个页面,可以说是两个

! \. s' ]( e. l% V页面，不可以共享变量


$ t! y' \% Q( |4 Q
& Y5 t! ~7 {1 l$ J9 B什么是自定义标记
自定义标记库是一个Web组件，

# [+ c7 X) f# i包括：
* }  \$ c+ h9 G( C! q( }8 U
. d; w/ M6 \) h* n+ l一个标记库描述符文件（*.tld）

8 C; p  u- c& b; |+ e6 h0 e9 ?所有相关的标记处理器类(*.jar)
: R8 ], t4 v% P( Z" G
7 q- o5 q" S7 g1 x
9 C$ n) l* s( C; E  F+ }; p- p
描述使用自定义标记的步骤，以及每步详细的工作
- Z, T( h" H- Q使用自定义标记前，要拿到.tld和.jar两类文件
5 e9 U: x! B" G
把.jar文件放到WEB-INF的lib里面。
: e( q, x( q2 B5 i- H把.tld文件放到WEB-INF根目录下。
6 N0 Q! u2 ]0 F' _在web.xml中配置。
: s+ i3 j. \/ f$ c" D8 h% O5 i<taglib>
( e+ F: F4 @: e) a
* O( {$ Q, l- N$ f$ d; l<taglib-uri>http://java.sun.com/jsp/jstl/core</taglib-uri>

     <taglib-location>/WEB-INF/c.tld</taglib-location>

9 k, x5 `: N! p- g</taglib>
  ]4 J% A% N( {6 ~4 S0 P
* K+ W5 ?* f6 U# r& L) t在页面中引用。
; f) l% R/ ]( b% z9 W<%@ taglib uri=“http://java.sun.com/jsp/jstl/core” prefix=“s”%>

9 H' ~: v2 x9 [6 B% ^( a; C, ]; curi必须与web.xml中的uri对应

prefix是前缀，用来区分是哪一个taglib
9 F" l/ z8 ^1 B' N# ?
" Z1 E) Z- Y" v* W使用标记
2 o# l" Y7 Q' [4 K, N格式：<prefix:tag名称 属性>
8 b' \' l8 n) P$ o& F! j
, a9 z8 @1 H9 u<s:forEach >

admin

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

配置server.xml文件

1.oracle

<Resource name=”jdbc/company” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”
! r, y8 B; @- k* W# R
                        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”

url=”jdbcracle:thin127.0.0.1:1521rcl”

2 N8 C/ U' I+ ]driverClassName=”oracle.jdbc.driver.OracleDriver”

username=”aa”

0 ]% G+ }: a0 q- l5 \password=”aa”

maxActive=”50″
0 ^: O8 _$ K% t0 c. ]
maxIdle=”10″
+ X, ]( A0 `! F6 @# G# Z8 w
maxWait=”-1″
' R+ F8 V  F" {3 s( q
/>
+ ~, r4 a9 `" h; h- w1 T
. z2 f9 C$ m* G/ W) J! [2.sqlserver

<Resource name=”jdbc/webpage” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”
' S7 r7 w9 C8 u
& L5 q4 v1 T; \0 z4 u5 s' N        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”
0 G4 d  A/ o" v- s- |& r6 w
url=”jdbc:jtds:sqlserver://localhost:1433;SelectMethod=cursor;
! l( K8 _/ i' c% u. }3 [* }
4 N. A* R2 {$ j: r$ E8 jDatabaseName=webpagetest”
! D8 O, M! L2 [
driverClassName=”net.sourceforge.jtds.jdbc.Driver”

username=”aa”
+ A2 [; U, Z! S' z6 H
7 W! B0 |+ g) ~( L3 _password=”aa”

maxActive=”50″

maxIdle=”10″

maxWait=”-1″
7 _- f  \& j* z; ^' m& s1 g9 w
9 o" j8 F+ `/ y* Y/>

2、配置自己的web应用的xml文件


1 f# N: V9 w/ {9 J9 j
<Context path=”/eb03web” docBase=”F:/workweb/eb03web”

% Y0 J+ R3 r; `4 F0 p, h+ fprivileged=”true” antiResourceLocking=”false” antiJARLocking=”false”>

- d4 l" V  p. f' K4 G5 f<ResourceLink global=”jdbc/company” name=”jdbc/company” type=”javax.sql.DataSource”/>

</Context>



3、配置web.xml文件

8 D5 U0 g' [2 q- o" q, `与服务器建立连接
9 V! z. Q* J9 [# n+ q
$ @7 d# k5 S9 }) j% ]<resource-ref>

- s+ p! f4 }' T* D<res-ref-name>jdbc/company</res-ref-name>

<res-type>javax.sql.DataSource</res-type>
3 e5 C; |, N  C8 f2 F1 n' _$ G
  A" y6 c6 X4 U: ?& ^5 f<res-auth>Container</res-auth>
2 I$ f) v2 p, I4 m8 S
3 _5 ]9 y+ @) E2 c2 j4 G</resource-ref>

0 w  _% D& |1 y3 i/ N4、在应用程序中不直接与数据库连接，通过DataSource连接池建立连接
, i! b2 Z$ y4 @$ h3 c
//1.在程序单独用时设置系统的属性，在tomcat下可以不用配置，
/ c, }: R* B. l
! ^, Z- d7 a& j2 {5 \System.setProperty(Context.PROVIDER_URL,””);

System.setProperty(Context.INITIAL_CONTEXT_FACTORY,””);
2 i& Z& \5 B0 d
# C8 N+ e/ s, w0 e# K8 B2 ^//2.创建一个上下文对象

5 P  u0 j* `6 G; z  fInitialContext context = new InitialContext();

2 _6 t) U1 f* r6 b//3.通过上下文对象在连接池中查找DataSource

# V% n+ v1 }- l8 N; U1 iDataSource ds = (DataSource)context.lookUp(“java:comp/env/jdbc/company”);

9 X! w  }6 J0 p# X* n0 ?: V//4.通过数据源建立连接

0 t: M# h2 O4 O% e) q8 m, @. Kds.getConnection();

admin

ORM对象关系型数据库映射
* @, w( W! l- I; z- P(Object Relation Mapping)
& T' T) J/ t, _
' u0 B/ o: i) p  k  q一、映射的特点

1.一个对象可以对应多个表
/ F' k& l$ I$ t! S: e6 u- C
0 w1 j- k9 u# t- o2 b' A0 M2.一个表可以对应多个对象
3 U) e: A' r% `0 Q, y4 x6 w
# Y7 M# _0 v9 f; w' ~8 r3.对象和表的关系不用完全对应

4.对象的属性的名称和表字段的名称可以不同
# n& S2 H5 m! C8 c
5.类型可以不同，但数据类型之间可以转换
' E6 D# P& y5 J) a! _% b
6.对象中必须有主键，数据库的表对主键无所谓
1 s- b, O6 T( Q5 q' m8 y" d! V
; Y1 [( Z/ {6 R. s2 i7.数据库中有主外键关系时，对象中可以有，也可以没有

( N* A; F, Q* D& E. T$ A' E" l$ i  f
8 t6 [  V7 Y' C: L' }
二 、有一个映射的描述文件————>xml
; b: t% z' V6 [; S6 h
三 、怎样实现描述文件————>一段程序

5 C( X7 |/ u% V  T) F对象 映射（mapping） 数据库
4 R7 \2 ~( z+ v
user

, V% Y6 n4 t2 e7 d1 Rid=11

/ f3 i  @9 V; z1 t/ e3 A  j4 ^name=”张三”———— > (1) —————> tbl_user(id,name,age,tel,address)

age=25 <————(2) <————
  N) T- m# V; ?) n
0 ?: C$ n7 w" t2 P  Z) i4 O* Q

4 p5 A8 P; c6 _2 C+ h8 Y$ h(1)从对象映射到数据库
) y1 m( M8 y, Y; h% I9 s8 i" q
1.JDBC
; K; x- v$ O' J
2.根据描述文件来动态拼接sql
% G2 p' j: T! \& d& S  }, b- C1 ~3 P
7 T1 X6 l( t% k' v3.执行，添加到数据库中
7 ]4 X( O. e% d$ k) V' L$ O6 U1 e- ]
" I% H& }2 D+ l) o* S
8 P8 R/ V2 w; Z" M$ A6 n# \
9 X! ?. d9 D2 P(2)从数据库中映射到对象
& ?" o* g9 `& A
1.JDBC

0 K" g9 g7 |7 U8 w% i3 [2.拼接查询sql

3.ResultSet
! s' P! X5 `: q+ x9 d2 |% Y, M
4.Model

( y5 f/ I  {  l( O* F' V

% `, l4 ]; ?: p7 Zhibernate
开发流程：

5 Q/ ~* `7 h5 s1 p- j是什么？
. v+ l+ ?5 _6 Z4 |$ X( y- C& Ghibernate是一种基于orm 的轻量级的框架
, }- D5 Q" G% h; x# ]- U

, H4 X4 W0 g7 @) C7 Q- a
有什么？
) @# `. A/ i' W0 Z6 `1. session 保持连接状态（依赖事务和连接池）
$ y, y& O5 e- V) u$ p. |
8 o% _/ H( W6 @2 m9 F/ ~2. Transaction事务
4 y) w2 x/ N# {& d1 t  Y) j
3.
Connection Provider 连接池

% w8 R  V$ b* q
# ]2 S3 A7 t: v- m6 D. |2 u! }
能干什么？
# c, O5 Y# `8 K3 v# I1.orm
0 m# M% i, s  ], E2 X, u. h
2.提供操作数据库的接口，简化数据持久化的编程任务
+ b% u4 b2 Z0 r' \7 R/ @) C4 H

- e* B$ C: a4 h
* I0 L& D$ A% {$ _$ Z9 C怎么做？
0 \8 U# q4 l6 X1.搭建hibernate的运行环境，将hibernate的包和hibernate所需要的包拷贝到lib 文件夹下

( l( n  S% ^& p! C2 _2.O（vo）
8 e! h" g1 Z3 J1 p' B0 k- M/ P6 Y
3.R （关系型数据库中的表）

0 w6 n, T4 c8 V4.配置文件

# B- l' F3 V4 H1 A4.1 cfg.xml 放在classes根目录下，默认名字为hibernate.cfg.xml
. f5 |3 W: ?% ^; ^/ b0 E% ^0 t
a.与数据库的连接

b.可选配置

c.映射资源的注册
# v8 c6 y7 v& l
1 f- {; e( b) h7 n6 x, b4.2 hbm.xml文件 名字与类名相同 并且与类放在一起

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

! n2 F: c4 G: ]7 }, L% @b. 对象的属性与数据库表的字段之间的映射

+ F( F1 l) c! g( _! {c.组件之间的映射

d.对象与对象之间的关系映射
, N. G/ S8 j+ R& [7 J
5 R. W; c, o+ t" I5、客户端
) E: A; k4 O- H! z
, E: g/ L' S" w+ S& J9 D2 }1.得到SessionFactory
- q1 _5 V3 t; T; z* z3 u- u. n
2.通过SessionFactory 工厂来创建Session实例
0 X2 U8 H5 K, h0 u& S
: w. c$ @6 ]# k6 x( }- A/ U3.打开事务

: W. }3 ~" D+ _! V. S* H4.操作数据库

+ s3 |7 q* n4 n. N5.事务提交
7 n4 _& g# l# r8 f$ v# J/ M
6.关闭连接

运行流程：

整体流程
) K1 U, `; B/ z8 \9 v/ @" d. v+ q1.通过configuration来读cfg.xml文件

2.得到SessionFactory 工厂（根据数据库的连接来创建sessionfactory）
. ^2 T/ r% ]; a, f- \
3.通过SessionFactory 工厂来创建Session实例
# O8 q* L- R# d" ~
4.打开事务
; R% ?5 ?) o4 Q6 j4 G+ ?8 F$ v& b
8 h, O4 B, a9 r# z, ~5.通过session的api操作数据库

6.事务提交
3 K: r- l+ |- |
7.关闭连接
2 U6 B# r) V! |2 Z3 W

! o; ~* D6 M8 O2 t/ t% G- Y& |4 z5 S" _
! o, ~1 u/ d* P* [* @% l; w; K  R5 @save
% D' u2 a3 c# A4 D/ Z1.to—>po
- l& T6 z% V" o' |5 G
2.根据model和cfg.xml中映射文件的注册来找到hbm.xml文件

0 ~: E* ~. o* ^% }+ {4 J5 [3.根据hbm.xml文件和model来动态的拼sql
) e. T0 o" i* X% |" r
4.客户端提交或者刷新内存

- `% ]6 s* M7 D+ R0 L5.执行sql，值放到数据库
% [$ {" a! P7 E9 V9 u2 g9 I
! M$ V8 Q+ Y9 v- \; |0 N

update、delete
1.根据model 的id在内存hibernate的缓存中查找该对象

如果内存中没有就到数据库中查找来保证对象的存在
+ F" i% m* Y: i
2.根据model和cfg.xml文件中映射文件的注册来找到hbm.xml文件

3.根据model和hbm.xml 文件来动态拼sql

# G$ N& w4 U' ~) K2 B4.客户端提交或者刷新内存
  U; I5 r. O! o: c: Q( L
7 p( n" m' p* k) x5.执行sql
9 I* c5 I2 _1 L; k3 D1 u4 I/ }

; \% V6 g( o& Z% A! r+ R
$ u6 L+ A$ i# VQuery
- {2 _7 X6 Z: F' qload

& m8 Y. O- p6 }4 r4 I1.根据model的类型来找到hbm.xml文件
, w8 v7 q7 g+ T
" r0 V2 `% t* i2 ~2.判断id对应的对象在缓存中是否存在，如果存在，就直接使用，如果不存在就进行下一步。

2 l: M7 w1 r! z: p& k. m' \$ V3.用id做为查询条件来动态拼sql

+ E) y  y% A5 N1 j2 d( F4.执行sql 查询（先在内存中查找，如果没有找到（会抛出例外），就去数据库中查找）
  M$ E: B, g0 `8 [  c) K7 f( {
/ V8 M' l8 }2 ~$ w5.返回一个model类型的对象

get

    1.根据model的类型来找到hbm.xml文件
( a7 A- A$ e. m  c/ V' N8 }
4 w! S& C: O5 U4 q* h2.用id做为查询条件来动态拼sql

3.执行sql 直接在数据库中查找，如果没有查到就会返回null

3 I$ a1 S3 }4 h6 k6 ^query
, b# c  O$ Q$ h2 Y0 m; a
1.分析hql语句，得到model的类型

, h  t1 F( C( L) {8 j2 P% a. R. c+ x2 Y2.根据moedel和cfg.xml文件中映射文件的注册找到hbm.xml文件
1 J2 v, Y. h9 m4 S3 v
7 C! k! g8 e6 m% q% s3.根据model和hbm.xml文件来动态拼sql

! w. Z, J! s- e& H/ \. v4 g- t8 r4.执行sql查询数据库
$ `0 Z- b: P9 P' d
5.返回一个resultset

+ p- i: K2 `6 L1 A6.循环resultset的值，放到model中在放到集合（List）中
8 L$ o& z+ B: w8 q- _
  |8 s* O2 q7 _6 J5 X3 m7 j

0 n+ `7 ~2 O2 q谈谈hibernate缓存机制

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

' j0 z+ x# j8 W* B5 j

hibernate使用的是二级缓存，有两个级别，分别是Session，SessionFactroy级别，一级缓存是Session级别的缓存，Hiberante来管理的，这个我们一般不用管，二级缓存是SessionFactory级别的，可以进行配置和更改，加载卸载，就是我们平时用的hibernate配置文件中的配置SessionFactory的属性。
2 K2 {$ r# b& r7 G- N! E

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


/ d; `  i  H0 d* y. [
| 一级session缓存| | 一级session缓存| |一级session缓存| |一级session缓存|
% N' n/ s/ g. k8 f
4 c, C$ v0 y0 S* Y  H| | | |
6 B/ z7 q; {4 `4 W8 Q
| | | |

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

; F& a: T$ v& M/ M2 A$ ^* o% KsessionFactroy级别的二级缓存

——————————————————————————————————————-
" G$ L  x8 M6 {) f+ `( _
, Q; |- A: @( P4 H|
  m3 f+ Z" G) q. N: E
|
: ]9 X/ v3 B1 d# w/ ^
8 i$ o! m, T4 [% ^' ?( V0 `! c|
! Q. j1 w0 R% q5 y( B
. i- |) O) y# o2 T: F5 r——————————————————————————————————————

/ p3 Y8 r, i8 `% q4 D3 QDB

—————————————————————————————————————–

6 ]# \) V; d6 z7 c. K, I- e" T! R$ ]

admin

Spring

• 是什么？
  
  2 i7 T7 o# F% ^

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

, n/ [- R/ O0 }* G! I) I

• 有什么？
  9 k: J, V% b% v6 J4 ]
  

6 C+ R& p- m0 t0 w# o& S

每个包的功能：

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

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

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

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

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

AOP ：面向切面编成

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

• 能干什么？
  / L# _" p0 L; W: k" [, M
  ) g5 u5 V  E/ u$ A# _

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

• 怎么用？
  
  7 ?" K% \4 n: p2 l+ d) R
  • 搭建web工程，引入spring的jar包
    : i+ V0 G* S: J* f% }6 z/ M- k
  • 在web.xml中添加如下配置
    
    * ?0 H" ^7 Z8 Y- j/ h7 E7 L
  
  
  

            contextConfigLocation

            classpath*:applicationContext*.xml
; k; Q) P: d1 o$ @

   
$ z0 O! z+ j; S; \$ R

        

            struts2
- ^6 ^2 n1 V4 P+ O- t$ ]9 v  @

            
8 j1 n5 B7 o! S) \3 G% a# z

                org.apache.struts2.dispatcher.FilterDispatcher
- y7 U7 V. h; v; k

            

        
+ y/ w  z! J0 b3 Y& H' b

        
" F) S' u$ u) {1 l3 a" T; ?

            struts2
2 D6 F  y6 f- W' |5 u

            /*
* A- w9 I% u/ x. l& F3 s- T& A

5 J5 h8 q' j: i

            

                org.springframework.web.context.ContextLoaderListener
8 N) H% x1 X8 B

            
, _% f) r- l& K. f* l+ _  C) |

        

• 部署
  
  0 w2 P7 x) A; k4 t% w

. v+ [/ L; E# ~5 H" F" h3 N4 ~$ N9 E
5 [5 M3 ^9 O& T9 ]2 Y/ e8 o2 J

• 容器和bean
  

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

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

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

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

: |0 n- v7 c. c  ?

• IOC控制反转
  
  
  
  
  0 G( T. T  @9 A- N# j1 N+ I7 m
  从前的应用程序想要得到A的实例他会直接主动的去拿，当用了sping后，应用程序由主动的去取变成被动的等待，由spring来控制应用程序所需要的对象
  
  2 h) i9 l5 G1 P- _5 M7 S$ X
  • IOC的优点
    & a2 `1 G# w9 F) r( T1 J) F2 @
  1.可以通过IOC来获得实例
  2.可以通过DI来获取注入的资源
  • 配置IOC的原则
    
    • 一定是可变的资源才采用依赖注入
    • 一定是层间的接口或者是模块之间的相互调用才采用依赖注入
      

9 b" J$ D2 O) J# w6 P# j

• DI依赖注入
  

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

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

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

例如：

在配置文件中

4 T9 U# f8 }0 y' R! i2 G! S4 }' t
% m( ?9 }! P/ @" D+ z0 m, X5 `% y
' O: N) p8 a( F/ l3 w4 Z( G

在应用程序中

Public DBDAO dao ;

Public void setDao(DBDAO dao){

This.dao = dao;

}

3．构造器注入

0 ?# x' k) K5 w8 S3 f2 S4 @

4．ref 表示参照其它的bean

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

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

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

6.lookup注入

7.singleton

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

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

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

8.DI的优点：

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

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

• Aop面向切面编程
  
  / y& ]* F& u3 v7 @

1.AOP面向切面编程 一些较好的模式或者是示例—-范式
) y) i! T  D- X- d

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

2.AOP的思想： 主动—->被动（追加功能）
! T1 v4 k6 w8 @4 R6 ?

3.AOP 的概念
* v4 b! c, b* ], _0 @- }- Q% M" {$ N7 T

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代理来实现动态织入

& Z, K" j0 h( ?( R  b

$ K2 C( F% \* k5 p4 m  `
: h& Y; s  Z* O( k6 A8 {' R
+ F- ?- Z( @6 g1 S: I9 w7 }
# ?$ h; p' {8 p; b, j
* S' v; r8 B; q# E8 X: W

5. AspectJ
& x9 Z1 `- u2 }9 L/ L- C+ N: w

5.1.在xml中配置比较烦琐
- P+ I" C% M4 @! w/ B

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

         


         
5 `/ o' n' W; w/ t

        

        

expression=“execution(* com.javakc.aop.MyTarget.t*())”/>
$ E2 V  d: ], w7 t

        
% G% b7 I) Y; A0 j+ H8 A( f

        

   
1 E; @: N2 d+ u" u

& O8 B9 }3 R9 Y, C# a

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

@AspectJ的基本语法

1.@Aspect声明一个切面，将一系列的共同的功能定义成一个切面
9 j( g$ k! o/ Y! Y

直接在类上定义@Aspect

2.@Pointcut声明切入点

2.1、用一个专门的类来定义pointcut，类中的方法名就是该pointcut的名字
2 g5 o+ a4 Y8 n! f

2.2、可以使用匿名的pointcut

2.3、执行切点的几种方法
* F  b8 J% p! l# y- i' D% k

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

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

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

2.3.3 this 指定到实现接口的所有的实现类
4 ?2 Y$ E; {7 @# b: t! U

2.3.4 target 指定具体的实现类
, B4 I' ]- g* r  f1 f1 e

5.4.advice的五种类型的示例
: v6 w( h1 b! x# w( d% s' W$ J' Z

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

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

追加的方法的参数名字一定要与retrning的名字相同
4 \2 T& e# `1 Q! f& {' ]

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

pointcut指所要监控的目标对象的方法
: u; r" j, S5 T5 f8 d; ]5 Z; H

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

完成追加的功能
' `5 r7 p1 Q+ _6 h8 W

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

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

(2).

     2.直接引用匿名的pointcut

     (1).@AfterReturning(“execution(
" {( r# M2 F, W

* com.javakc.spring.schemaaop.Api.test4())”)
2 u6 r8 g) t, P+ [6 C2 x

     (2).@AfterReturning(pointcut=
. T" x5 n% u* P& K$ e5 _

“com.javakc.spring.schemaaop.TestPointcut.t4() &&
* b7 f1 G& u9 j" @

args(str)”, returning=”retVal”)
. X# t6 A% d# N: s

@AfterReturning (pointcut=”com.javakc.spring.schemaaop.TestPointcut.t4() && args(str)”,returning=”retVal”)
- K* v4 b% }( [' J

public void testAfterReturning(String str,Object retVal){
6 O- p5 O3 ], R& G: x) h' o! s

    System.out.println(“afterReturning1=>”+retVal+”=>”+str);
6 M! j5 K0 U" |6 r

    }

5.4.2.@Aronud

     注解@Around环绕追加功能；
# y, G" {* G" h  B

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

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

     通过ProceedingJoinPoint的实例的proceed来调用所监控的
9 N4 N0 L6 P% I* H) x" G2 L1 \

目标对象的方法
5 P) g3 b2 ~+ m9 I

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

     (1).@Around(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
* {1 q' x, [3 `- U7 W2 w

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

&& args(str)”)
, m; i6 b3 a6 G

2.直接引用匿名的pointcut
- i5 |# u+ ^6 K; o/ m* m% t" |

     (1).@Around(“execution(
( q% [* \4 ^7 f

* com.javakc.spring.schemaaop.Api.test1())”)
9 J: }1 V  v1 q! `) P) n* M

     (2).@Around(“execution(

* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
  O* D" T3 ]" p& @- J, K) {

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

     @Around(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
! E, n6 y) z( Z( `8 j1 n/ C

public void testAround(ProceedingJoinPoint prj,String str) throws Throwable{
/ h: ]0 W( m& s# [$ k5 M! C  }

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

        Object obj = prj.proceed();

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

    }

5.4.3.@Before
( C) p4 L+ S, ?; r3 |+ m" a

注解@Before在执行目标对象的方法前追加相应的功能
) a4 e; J1 A: Z

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

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

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

注意args后的名称与参数名相同
; P7 k. K. Y- ?  q  F

2.直接引用匿名的pointcut

(1).@Before(“execution(* com.javakc.spring.schemaaop.Api.test1())”)
( V* T, P- I# R( f; t

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

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

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

@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
0 s$ M4 r; e' S3 ~( N8 D

public void testBeforeParam(String str){

    System.out.println(“before1=param=>”+str);
5 a4 E. \8 X5 p* f! f1 L* n# I6 r

}

; f: d" j+ [0 I2 H2 S0 N  c+ Y

5.4.4.@After

注解@After在执行目标对象的方法后追加相应的功能
6 d7 W5 Z: l2 S3 R$ H8 J1 b: w

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
$ H( v/ u" K9 v

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

     2.直接引用匿名的pointcut
# z% {% s" ^  c( E/ ?: v8 Q

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

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

    public void testAfter(){

    System.out.println(“after1== >pointcut”);
+ W7 A$ [# g3 _* f

    }
# g8 B& |# S& C( a! X. j1 z

5.4.5.@AfterThorwing
) y0 d+ R. \) r) T( l

• 描述一下spring中BeanFactory和ApplicationContext的差别
  1 U7 M( H' ^1 _5 r; V7 S3 t7 L) S
  

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

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

代码示例：

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

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

• 谈谈spring对DAO的支持
  
  

Spring提供的DAO(数据访问对象)支持主要的目的是便于以标准的方式使用不同的数据访问技术。
6 ^' X, J( O- g9 A0 D* R7 Y

简化 DAO 组件的开发。
1 w" y+ W$ R8 e' q% I+ @- RSpring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法，用来简化代码开发。

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

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

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

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

  B- \- ?4 }- X- g

• 谈谈spring对hibernate的支持
  
  ' P( G. p# @( c3 f$ m

在所有的 ORM 框架中， Sping 对 Hibernate 的支持最好。如 SessionFactory 的注入、HibernateTemplate 的简化操作及 DAO 支持等。另外， Spring 还提供了统一的异常体系及声明式事务管理等。
" h7 s, K, n8 [8 W

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

1、通用的资源管理: Spring 的 ApplicationContext 能管理 SessionFactory，使得配置值很容易被管理和修改，无须使用Hibernate 的配置文件。详细配置如下：
3 j* g0 [  g3 J3 {% j4 r6 x$ r# O

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

        

            oracle.jdbc.driver.OracleDriver
* v  I! [$ e. K0 F: w2 b

        

        

            jdbcracle:thinlocalhost:1521rcl

        

        
7 p+ i( L! S+ ^, E  }, @: E

            javakc2
) G$ N0 C3 V; x& g9 v

        

        
. X6 s2 }4 |* O" r$ E

            javakc2

        
7 K: U% ^+ @" B+ C) T* \' h$ t

   
3 X8 W  |& }( n. I2 S

   

        class=“org.springframework.orm.hibernate3.LocalSessionFactoryBean”>
) \* U2 M1 f. K5 Y

        
1 ?0 g8 k4 k) a! G" [

        
8 L6 p7 A3 ]) c# }

            
! M1 w* u6 I6 L! Z* G  V4 _

                com/javakc/spring/h3/UserModel.hbm.xml
  A: ^% A& A) t9 W- \0 U

            
& ?6 W+ }% W+ H- C& [, l

        
. \- D, k1 z4 }& O! w. @

        
& A1 @2 P9 i' j* o

            
) \0 Y; K  V5 }+ P* f

                hibernate.dialect=org.hibernate.dialect.OracleDialect
) ?  F8 Y; }/ D, T+ h% f3 a; s

            
; S8 ?0 V2 @1 G* D

        
3 ~6 h" ?' e: M2 \% O. @

   

   

        

   

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

   

        class=“org.springframework.jndi.JndiObjectFactoryBean”>
- R, f+ [2 R$ i2 \- |

        

            java:comp/env/jdbc/myds
" C, z/ O) l. q7 _' P

        

   

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

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

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

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

   
5 O" M; S2 D# Z4 d) s

        

   

+ A; M6 C6 J' P% B) J

   
8 S6 U" `! o+ f/ R8 u4 A

        

            
) d( h9 u9 a6 K/ O) c* m, R2 M. j

        

   

3 x4 S4 W1 O# a3 G0 I5 _/ n- ]

   
8 M7 S4 k+ r. ~

        

        
' J! R5 A3 D& r) M2 G8 T

   

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

Spring2.0之前事务的写法 4 F7 R  j8 j! f' K! c. K        class=”org.springframework.transaction.interceptor.TransactionProxyFactoryBean” 8 B+ M. H# s. q+ g         abstract=”true”> 3 ^8 K( ], X) d! M8 E4 g8 B 1 r2 i/ v8 v& z3 u7 {1 f                 PROPAGATION_REQUIRED,readOnly 6 P8 b) f' p0 I7 D, Q: N+ \                 PROPAGATION_REQUIRED , ?) m- G' b7 y$ j  I7 t: [ ; T, x* U6 X' G' m ; X$ v4 c' D6 f$ C: D

• 谈谈Spring对事务的支持
  5 j0 t/ U7 |8 O# h& ~* O+ G
  $ s# f" f; I3 W. f

4 _5 }* t$ q0 m! ~  O  i. S1、声明式事务管理：

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

2.做法：

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

2.2

2.3 注入数据源

( L7 \* t, ^) F1 i; E
) x) R6 U0 \; Y- t/ K$ }& y
5 g& ~% P4 n' o4 w6 y6 A1 ?+ T

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

" u6 _. d. m% W8 I0 |+ N8 n$ P
6 l! |3 w! @4 k7 t

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

1 s" V3 K7 w/ b2 _

% W5 x4 R5 l0 |* w) `8 I, a

2.6 定义切入点

% s. {1 @' Y5 ^
( k# S% F6 {( c6 p, {/ I2 P( _

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

1.注解@Transcational

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

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

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

, J  r# D/ i3 M3 C
. ]3 p2 w3 G1 n; m" N$ J) C, J, Y

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

8 d& J3 a- l: a8 l3 O  V% c

( O1 Y5 L9 z8 i% T

" M' d4 V0 l4 d' Y6 v" x2 e

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

admin

事务
: Y3 z/ v, B: y7 L& VACID
（1）原子性（A）：一系列的操作具有不可分割性，要么成功，要么失败

4 c9 X; N& [( ^/ `3 v/ z, W! I（2）一致性 ：操作的前后满足同样的规则，保持平衡。

（3）隔离性 ：在事务运行的过程中。事务内的数据对外的可见性和可操作性（必需由数据库的支持）

（4）稳定性 ：保证数据在事务的操作的过程中不会遭到破坏，而且是永久性存储的
: I5 h0 t! F) N! [0 `( u- h
/ k0 Q" [( X* `7 ]0 f, W6 Y' u

( B1 a  J! r. O0 M% K+ i, p2 J# B事务模型
& D7 e$ U- H( ]. \6 ~（1）经典事务模型又叫平面事务模型（JDBC） 事务不允许嵌套

（2）嵌套事务模型



' N$ F. c: E" I  z% E) |事务的两种方式
" O: M$ C" X' L% z（1）声明式

在配置文件中设置以下6项

（１）.required

: C$ F- }" a3 Z  C% H& C9 a' N' L如果客户端没有事务　在bean中新起一个事务
3 b5 x- q. @* j* g
如果客户端有事务bean 中就加进去
6 o: @! e: {; ^, G
(2)、 requiresNew

) T9 ~; B. B/ j- q不管客户端有没有事务服务器段都新起一个事务
- c& z# G: W; X# e/ O' O
如果客户端有事务就将事务挂起

  N! \* H* U- ]: B& L(3)、supports
+ N% [  Y+ B: b8 l# ]4 D9 u* `
+ \: G! ?3 Q! q如果客户端没有事务服务端也没有事务
/ n8 H6 z7 n* @/ \9 n% N5 P( k
, ~* t/ b' W/ L) `. {! p如果客户端有事务服务端就加一个事务
0 w$ V0 s% a& Y( s
) L( E4 m# K, p+ ]: s6 ](4)、mandatcry

9 ^+ o6 `! H: X, s5 `/ h; j! R如果客户端没有事务服务端就会报错
, {6 ~# {7 k9 \3 V5 ~
. v, X' i) K6 {5 m, Z( e2 |如果客户端有事务服务端就加事务
8 F  q8 @: d- Z
0 P' l& O# a# R+ p7 ?0 [(5)、notSupported
4 O) i% P2 x; r7 _6 W8 e) l- c
: S6 ]) ~- E6 K& u- Y. q不管客户端有没有事务服务端都没有事务

如果客户端有事务服务端就挂起
% r4 @: ?  N$ E
( ]4 ^, f$ Z! X2 s' J6 w: ]. d1 S(6)、never

: f5 P8 b+ E1 H, d0 G0 R0 U/ _不管客户端有没有事务服务端都没有事务
1 {, ]6 q7 A8 }7 r6 ]8 P/ \
7 A" x! C, f, I9 Q- Q/ t+ r1 W. `如果客户端有事务就报错
/ F; c% M3 x0 J* K, ^# r
; Z, D2 a3 Z9 e$ V: x# r1 t& @（2）编程式事务
8 d2 E* d" ?( P7 e$ R
Javax.transaction.UserTranscation

6 J3 X3 s8 f1 R9 o' `) k& D: KJTA 事务可以精确到事务的开始和结束
# s7 G" E4 j$ o, E' s


事务的隔离性
Read-uncommited
- l" ]9 T2 @" F6 ~2 r( M
. [% \# D3 {: V$ z& v! J读取未提交的数据（基本上没有锁）脏读，存在不当读取的问题。

. U+ X0 y) ]0 G$ B4 R1 ^; O$ T9 f3 [Read-commited

读取已提交的数据（行级锁）

2 Y% r7 I5 ^% z! r无法读取已经写入，但没有被提交的数据。

Repeatable_read

  ~$ X* }% E! z; Z! ~1 r, p$ f读取的数据不允许修改或删除

" k  _7 y2 b& e不可重复读（行级锁+不允许修改/删除）
, \6 L. L) ?. u& H
! L6 p8 l+ G' ]1 qSerializable

# I8 m, l. t1 h幻影读（表级锁）



struts
开发流程

0 I4 n9 x3 x7 \/ X! [/ m/ z1、创建表单
4 t, L  m, Z0 F) F9 i6 {3 i9 {
2、从表单中获得输入

+ U0 ^5 N: W6 a. P1 c7 ^! Z3、处理输入（业务逻辑）
/ Z0 b2 F% |$ x: k: y
4、根据动态输入改变输入流
- Q) d/ `; \3 J6 P( Y2 V9 Q/ e0 z
要完成上述四步，我们需要创建
" A% p( I" s& \9 Z( R
# J* b) o3 Y& t+ B# F  e1 \. b) U1、一个ActionForm
" Q! K- S' A: q5 I
0 Y) J. ?7 }+ C: b# W* _8 B% Q2、一个action
# i  r  x2 m9 t
3、一个配置文件struts-config.xml
+ H6 L5 F+ T- @2 s8 }, o
' b( K8 {8 z/ q7 f" `4、创建页面
0 Y; h$ S& L- d5 d. u  `
创建ActionForm
6 |% v, Z8 }4 Y3 L2 s+ O; }. V, s4 @
0 a! Z) m& I. D0 _% P& ^1、写一个类继承ActionForm

2、私有的属性

8 y. r% m9 ~. ?2 N1 q+ ]7 W3、相应的get、set方法

. V/ L- `/ Y; x- B) g4、重写tostring、equals、hashcode三个方法

创建action
% C8 f0 d0 q. x& c) \/ z
0 m, O! D: m9 f# |6 Q/ l1、写一个类继承Action
7 C2 A* A9 p- s8 _
2、实现一个公有的方法（回调方法）

public ActionForward execute(ActionMapping mapping,
- l& }) e) d/ ~' W# U8 @1 }
5 C+ i# d+ Y9 Q: G  iActionForm form,

HttpServletRequest request,

HttpServletResponse response)
1 L  {3 w9 |: j
{

) J4 P/ O0 Y/ n* u5 K4 F+ v4 m- L//1.收集参数

% f* |0 n: u# J4 y- n5 Y$ ]) k! uMyActionForm myForm = (MyActionForm)form;

, R" \0 o5 ]! G) G//2.组织参数



- s3 G- E& Y. ]% Y+ g//3.调用逻辑层
) c3 l7 J7 b) _6 h9 ~. h6 p  R& X
7 l9 L6 V0 A5 x9 O$ _& `boolean flag = true;

5 Z8 P% C5 B- u# X$ Z2 g5 `//4.根据返回值来跳转到相应的页面
" i+ N9 X. m9 l& I
, h2 s4 B% L3 G" D- `$ j* q5 YActionForward af = new ActionForward();
. t* d1 {, t$ S* S
if(flag){
' J$ C! ?3 g! Z. I% j2 W, j
. d; O2 N/ h7 z( w3 kaf = mapping.findForward(“1″);

}else{

af = mapping.findForward(“2″);
+ c  u. _" i( X$ J
* |; ~- Z% b' D# f% o}

return af;

}

# C3 W& y( Q, y' x: c+ A" c配置struts-config.xml文件

1.<form-beans>
) |! c& @# p4 x- i
<form-bean name=”myActionForm” type=”全路径.MyActionForm”/>

% q+ N1 _9 c+ W! j( k<form-bean />
7 B; J8 f6 L) ^* |3 z
</form-beans>
9 `$ ^4 O" n, `2 O% V* \
2.<action-mappings>

$ G1 }6 b% N3 C" L( R<action path=”/sll”

name=”myActionForm”
2 B. a* s# j+ Q4 H
4 C, x, I4 ?) D7 B4 [/ Btype=”全路径.MyAction”
# q: |* M, D3 b, c7 {: U
scope=”session”
1 U0 _# z9 t3 C+ B, r
4 l: c+ A0 I+ q1 [% q+ iinput=”错误返回的页面”>

+ h, i) G4 m6 n% O; J% y: g<forward name=”1″ path=”/1.jsp”>
$ F  x5 }* f( J3 G
<forward name=”2″ path=”/2.jsp”>
: `5 y0 M6 w9 d! u8 w+ m
</action>
* s6 d% j2 |8 H/ C/ k, L# f
: l6 {4 {" j# Q2 P* d2 B</action-mappings>

步骤:

3 E* Y" n7 A& t) D' [5 a1.创建一个空的web应用
+ `5 H$ V! d5 |4 N
! O0 N+ j5 q9 m6 T9 W' B2.将struts的包放到lib文件夹下

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

/ j. D5 Q- g# Q8 C: }3 M" j4.配置struts-config.xml文件和web.xml文件

  \- C& k+ \# e4 T# D# R5.在页面引入tag文件uri
. e6 ^1 U& p" d7 y
STRUTS运行机制
2 ?9 F( M, T0 u
1、界面点击产生请求

2、容器接到请求

3、匹配web.xml文件中的*.do来调用ActionServlet
% `0 d. v7 H' T
4、ActionServlet的处理

4.1 读struts-congfig.xml文件形成ActionMapping
/ p# L& L3 o- k0 m5 U& ]% ~1 o
4.2 通过path 来匹配Action类，通过Action的name属性来匹配ActionForm类

4.3 通过反射机制来给Form添数据
/ l4 ^9 f6 F, A: s
4.4 由ActionServlet转调Action的execute方法

; Q8 \1 a! h5 U3 a4 U4.5 得到execute方法的返回值，跳转页面
) D& R5 E0 a1 q8 {
5 d2 C- N, l% s  o% v9 z4.5.1 RequestDispatcher
' D, B* ~! s- M2 s2 Z+ j
4.5.2 response.sendRedirect(“list.jsp”);

* V+ v, N  @3 n9 s/ \
6 d! P- v7 ^9 D8 J: m/ k
" s" ]! D$ x5 X6 w进入execute方法

1 收集参数

2 组织参数

9 H) M' W" v! G! E4 N3 调用，逻辑层

7 [9 x2 s$ J/ u4 返回值
5 P: v  e! X% L. T3 Q0 T6 C
5 _2 l) R& b2 a( j8 r" S2 }% z3 S4.1 选择下一个页面 （ActionForward）

! ?  L: }( n- H" t4.2 把值传给下一个页面
1 Z9 Y$ @/ J. O( `0 O' Q

% Q4 g3 b: f  P7 R1 I) e7 t) `1 o
比较struts和struts2的不同

* r" k$ J- M: e. MStruts
& {5 i. z1 |% v  u
) s7 X! D2 ~' ]% Q! {Struts2
3 M5 L( a  U2 _3 n" m$ n3 }
& w* I3 d) L2 H6 w/ t, |组成        五个部分：ActionServlet，ActionMapping，AtcionForward，ActionForm，Action        十个部分：AcionContext，FilterDispatcher，ActionMapper，ActionProxy，Configuration Manager，Action Invocation，Interceptot，Action，Result，Taglib
& h+ \2 ^  U6 t9 Hurl        .do        .action
分发控制        AtcionServlet        FilterDispatcher
3 p3 B/ \0 _3 J/ L; ~收集参数        利用JavaBean技术，将数据封装到ActionForm的子类中；
一个Action对应一个ActionForm的子类

7 O2 ]8 P: Y( ?1 t使用拦截器将数据封装到值栈中。
* {7 P- P$ |$ j8 ^, e5 n, Q! b使用域模型，一个Action对应多个值栈中的Model
- q, C$ }6 a1 H. |0 t/ R
$ E4 z  @8 z& q$ b8 s  h读取配置文件        ActionMapping        Configuration Manager
拦截器        无拦截器        执行Action前后有拦截器
返回页面        将字符串封装到AtcionForward，进行跳转页面        Action中直接返回字符串，通过Result跳转页面
页面跳转方式        两种：dispatch，redirect        三种：dispatch，redirect，chain
& }$ ?+ _) K6 `" H' {& r7 F) R值栈        无值栈，Action通过在request范围内设置属性，向jsp页面传递数据        有值栈，Action和jsp页面通过值栈传递数据，jsp页面通过OGNL取得值栈中的数据
配置文件        struts-config.xml        struts.xml
中文问题        不能解决（需要使用filter）        可以解决中文问题：
1、在jsp页面添加Meta；

& Z& q0 }2 ~4 G- }% [4 ^! \5 K2、修改struts.properties中的设置。

admin

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

  o8 Z3 \9 f: w+ i6 S一、配置ant的运行环境
2 j& o) x7 j) c
1.将ant的bin目录添加到path中
6 B7 W, x! W, Q# ^
2.配置JAVA_HOME
5 a+ H: j$ J, ~3 ?  X: ^6 B
/ ]- Y5 \4 R) z. c+ U+ a3.配置ANT_HOME

/ l% h; l- o, q  t二、配制build.xml文件，该文件放在应用程序的根目录下

编译java文件
; J9 t, W! k" s9 T
$ l7 r! m0 r$ P9 ~1 L执行java文件

copy
, @; v0 G/ `- E! `7 ?
) f1 n: r2 g# _& d& }删除
" L" E% X/ l: i0 |9 ], x
打jar包

, y' R& K. j$ b" D9 _! Z根据注解生成配置文件

" t5 y: o& Z  r) k9 }Xdoclet
通过注释生成一系列文件的工具（txt、xml、java、html等）
! k& m0 {' h. |2 ~% [: f0 A1 P7 A; i4 y
2 Y1 r! T: _2 \( k8 ~6 M1 k9 Txdoclet本质是摸板技术+字符串的替换
4 }) D& a$ L0 Q# {# c
% @! H! @& k/ u/ p1.在java文件中写符合要求的注释（将hbm.xml文件的内容搬到java文件中去写）

) j) }2 ?) t6 Z$ X1.1 在类的上面 写与表的对应
2 h& u, B3 H- W; z- ?4 O; C
1.2 将每一个属性的注释都写到get方法的上面
' ^! x3 {( ]. [9 |2 s
/ `- I. A7 @$ g+ |2 ^* D2.在ant中引入相应的task来驱动xdoclet
6 i+ r6 G3 r; ~" R; K* a; F* w


$ s5 k1 |- u/ n) clog4j日志管理
( Z( Y/ R  C4 d& q1、是什么？
7 r+ K9 s6 i; ~! X; p
在开发期间用来测试、对整个日志信息进行管理的工具
2 ?8 y4 m# |* O3 \$ J- m( E
1 L5 o6 F3 h- e$ K# x" A2、功能

1.控制输出的目的地
( D! Z. C+ E2 G5 l
) f9 E( [9 t, D; N2. 控制输出的格式

3. 控制输出的级别
/ T9 T4 Q* }9 I. X. p* H5 S9 o0 j
7 R. g, V6 F' Q9 m# t3 E3、日志的级别

1. debug 调试
$ {1 g3 G1 z3 i' l& B
! m6 H; [( x+ \- g; K; T' O+ e" o/ P2. info 给用户的提示信息
( H5 X+ C3 B% K8 W* Y
) h' [( q) U5 P' c" K3. warn 给用户的警告信息

1 i- B2 B0 J! P4.error 给程序员用来调试

4 E9 k( k: g2 r' n7 k- t, UDebug—-〉info—-〉warn——–〉error

4、配置
% Y6 w$ P  P0 V6 m$ V" b
1.配置级别

/ g% a3 {+ @- M2.输入源 （控制台和文件）
: r7 ?3 x# y/ y/ S8 d3 j+ o+ w
3.可以进行分包控制

& p, J6 P3 W" C+ Z# G% TLog4f.logger.包结构 = 级别

" k! H' B* H8 S5、使用

* R) |4 L, o/ O$ i# W4 a4 {& bLogger log=Logger.getLogger(Test.class);
  A; x& R4 `& L0 w1 ?- i- T6 S
( E5 v" B/ ^, ~    public
  D# T4 A8 b. h4 n& b  Jvoid t3(){
- d# @1 q% N$ C4 ?. R
        log.debug(“this is debug”);
" l( ?- a, A4 J/ _9 {
4 H# W% ]; J" s        log.info(“this is info”);

3 m) Q! }, r) P6 ^/ V3 O        log.warn(“this is warn “);

5 p% C- B& Z' z" z1 {        log.error(“this is error”);

    }
+ L4 M4 B8 W) z* e- v. i& _2 Y7 j5 E
1 z& q3 ?* w0 n4 p( CJunit
1.是什么？
1 E# T& w$ V8 Z! C& E: A4 [
单元测试的框架
$ `/ _, K0 Z+ ~
) u' Q4 i" L6 g- `" ~: J4 l2.怎么做？

; q# K4 M6 |% {( o$ ?写一个类继承TestCase
& }6 \) b0 t  Q7 o4 ]
测试的方法一般都以test开头并且没有参数
, N3 r5 R+ s# e0 `, ^; T8 ^
3 t" i) L% R8 V  r在测试方法前执行的方法public void setUp( )

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

error和故障的区别
5 v. i8 O4 C" p+ J7 W& z
$ L0 ~) A  X, n; _# R3 c8 qerror ：代码有问题
5 G  j$ ^0 c, Z
& a! X7 N+ G1 e) O1 V; u9 _故障 ：逻辑有问题与祈望的值不相符合
9 v: ~$ u# F% J9 I  B0 w) @( b& ~
* G" {7 a5 y5 ]生命周期
0 }1 Y0 H% I& y% E$ g
测试—〉SetUp（）—〉testXX（）—〉tearDown（）—〉结束；

% T& h2 k) B6 w- s: H. TTestCase套件

public class MyTest{
4 @( v3 Q6 W3 _" _
        Public static Test suite(){
* J; r& [: p# b7 ?+ A: a2 I/ F0 W
+ j7 S! L* f+ A0 `TestSuite suite = new TestSuite();
( Y2 U( J2 R  [+ m
; `! n" @: j" Psuite.addTestCase(Test1.class);
9 ~" G& p0 x' j- I+ d/ Z
2 n& M$ L6 W) j7 \3 y. zsuite.addTestCase(Test2.class);
8 g3 a, g6 o$ ?% b& x- X
; A6 n1 L" c5 X4 d! U}
0 J9 m' |9 E. q
}

& ]- [  u) n! @2 a
& {+ k5 ]' {2 g; L; ^) W3 o
: z8 X9 r* j& v. Z* lAjax
' K, _' j1 T1 z# `- ^是什么？
* B5 U2 `2 n* ~; eAJAX即“Asynchronous JavaScript and XML”（异步JavaScript和XML)。是一种创建交互式网页应用的网页开发技术。
6 |, r  Z$ ^9 S) |5 Z* `
9 B$ k0 Z9 O) K( V& ]- H, r8 E无刷新页面。

3 W8 f( M2 j4 l8 i0 l有什么？
  y* z& W# ]6 a5 [& m: C: oAJAX是多种技术的综合，包括JavaScript、XHTML和CSS、DOM、XML 和 XSLT、XMLHttpRequest。

2 ^0 L& D) M- ?4 f/ \9 N能干什么？
; G9 C' G/ K! w7 r+ S使用XHTML+CSS标准化呈现；
( f& P  J! {9 F4 F3 F使用DOM进行动态显示及交互；
使用 XML 和 XSLT 进行数据交换及相关操作；
使用 XMLHttpRequest 进行异步数据查询、检索；
& |& f8 C# c( s" M! Q+ G: I: e使用JavaScript绑定和处理有所得数据；

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

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

使用Ajax的最大优点，就是能在不更新整个页面的前提下维护数据。这使得Web应用程序更为迅捷地回应用户动作，并避免了在网络上发送那些没有改变过的信息。
; N$ z. L, I7 N8 X- t/ R
  V. s; c+ p9 s+ u( z# R对应用Ajax最主要的批评就是：
1 它破坏了浏览器后退按钮的正常行为，就是用户点击后退按钮后不能看到之前的数据；
. J+ o/ Y  r: C/ `, C' O4 }! v$ _2 一些手持设备（如手机、PDA等）现在还不能很好的支持Ajax；
1 A5 ^* f  Q4 Q4 G* b. g  [! H3 用JavaScript作的Ajax引擎，JavaScript的兼容性和DeBug都是让人头痛的事；
4 Ajax的无刷新重载，由于页面的变化没有刷新重载那么明显，所以容易给用户带来困扰――用户不太清楚现在的数据是新的还是已经更新过的；现有的解决有：在相关位置提示、数据更新的区域设计得比较明显、数据更新后给用户提示等;

怎么做？
<script language=”javascript”>

2 Z' `1 V5 a. gvar req;

function add(){
& {% l$ j& _1 i, h% E
8 X) l0 M# e- o7 w% Y' B2 l, G0 m//1:创建用于传输的对象

2 V. h4 p. ?0 _& D! A. n+ ireq=new ActiveXObject(“Microsoft.XMLHTTP”);

// 声明返回后，处理数据的方法

+ Z" ]; \1 d  `0 W+ Mreq.onreadystatechange=manage;

//2:准备传输的内容

var str=”test1111″;

//3:发出请求
  K6 g2 S7 }: N
req.open(“GET” ,”/others/ajax/test/t2.jsp?str=”+str);

- w8 ]2 r# M) ^& q  u( P% ~0 Breq.send(null);
2 n! T4 y7 m0 b5 T3 [& M" G
: |3 `, T* M8 w/ _# E: l# d) Z}
" ]4 [  j$ o% b
//4:接受返回并处理

function manage(){

5 T# a4 B- Y6 b/ o6 H3 n$ o  oif(req.readyState==4){

alert(“r==”+req.responseText);

}

}
  r5 L+ d; o. _4 p2 Z
</script>
. \6 `. t4 _- |3 e" f% K% ~2 |5 E
readyState的取值如下：
" n# m$ A+ s( b5 e6 A
) {7 y$ H" P6 B8 m; V( c$ C　　0 (未初始化)
; ^* J" z& o0 [8 j- h: ^3 L
7 x4 |$ }1 b* R  l, n' u　　1 (正在装载)
& @* k9 v, A% l3 U
　　2 (装载完毕)
$ ?* `9 C0 V7 ?$ L& b7 f
　　3 (交互中)
" F4 d# }' x- R% f5 X3 Z
　　4 (完成)



# E/ u/ Z+ n$ }2 G1 L2 L原理
& y4 [; c- Y2 i4 Y' RAjax的原理简单来说通过XmlHttpRequest对象来向服务器发异步请求，从服务器获得数据，可以是xml格式，也可以是一个字符串，然后用javascript来操作DOM而更新页面。
. y/ W' N( q6 J; o# C
Dwr
是什么？
1 s( {' I5 w" d0 a/ {5 FDWR（Direct Web Remoting）是一个开源的类库，可以帮助开发人员开发包含AJAX技术的页面。它可以允许在页面中使用运行在WEB服务器上的JAVA函数,被调用的JAVA函数就像是在页面中JavaScript方法一样。
/ x1 ~8 ~. P  h4 w7 C
有什么？
它包含两个主要的部分：允许JavaScript从WEB服务器上一个遵循了AJAX原则的Servlet中获取数据；另外一方面提供了一个JavaScript库可以帮助web开发人员轻松地利用获取的数据来动态改变网页的内容。
! c; W" M2 J6 [* A2 d; q0 t


! G- S7 G' q0 t) a* u+ E( X能干什么？
5 M% x# d4 g# y! j动态地把java类生成为JavaScript，感觉调用就像发生在浏览器端，实际上代码调用发生在服务器端，Dwr负责数据的传递和转换。这种从Java到JavaScript的远程调用功能的方式使DWR用起来有种非常像RMI或者SOAP的常规RPC机制。



怎么做？
5 q4 n  @! U5 C# g3 p% g* j" X① 编写配置文件

6 c( C5 j7 M: Y% G  ?0 r2 S' u/ Nweb.xml
" L* k  J% F; ]. y7 d: M
) z! o6 n. O: [+ w3 W<servlet>

! T5 o* D( v6 g; ?, w- R<servlet-name>dwr-invoker</servlet-name>
4 A. t; g; F! J
<servlet-class>
# v  q7 H3 h' O2 g5 A1 _
org.directwebremoting.servlet.DwrServlet
* i9 ~0 \! k5 I, `" p2 v
& E! s1 j! A: D; n/ h$ q* h0 s7 x' W</servlet-class>
0 @/ m) W0 b5 T: D
<init-param>

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

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

% Y1 y4 ]8 ?' l$ E! V; O7 `</init-param>

1 q9 l( `2 U  M5 |5 E</servlet>
3 W7 ]# n0 s0 z0 b
; v# c3 z) U$ D- j( G% Y$ |& Y<servlet-mapping>

: g" w) ^' `' K3 b. K2 u: U; N$ p" s<servlet-name>dwr-invoker</servlet-name>

6 F4 P0 v3 F; C6 V9 s7 ^<url-pattern>/dwr/*</url-pattern>
/ L6 ]+ y: `% {* Z# O. ]2 y
# \5 m! X, Y9 \* P9 P4 L</servlet-mapping>

dwr.xml
- H" Y8 Q0 C$ ^+ ?
<allow>
# N2 Y( P. T1 K% O9 w/ G+ |  R7 z
<create creator=”new” javascript=”kc2″>
# v3 {; \' `! W) Z! F' {3 B
0 {5 T# L5 c9 R<param name=”class” value=”dwr.Service” />

</create>
7 y, L1 P3 @! M+ y& t9 E
( l! Z1 O9 ]. a* {</allow>

. I4 G3 _1 s' L; ?4 k②编写service
! \6 y! t' K9 I1 b
public class Service {
4 \. ~6 [: A! ~  S' B# ]+ ]
, B; b6 L9 Z4 t2 s% cpublic String sayHello(String yourName) {
! J9 ]- c0 A  c; r( y  a+ D+ p/ R
//可以是访问数据库的复杂代码

return “Hello World ” + yourName;
/ h/ c9 ]% N: D
}

}
3 I8 d/ P0 y% N8 D3 g! o& u
5 o+ }/ @1 Z! ?4 d% z% P& L1 ~0 k③测试DWR
. L4 o- [* a! V
将代码放入应用服务器（比如Tomcat），启动。

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

# N6 @5 W- R( ]: S7 g④编写jsp页面
- L, h# P4 D" v
1） 要引用3个dwr的js，其中engine.js必须要，如果需要用到dwr提供的一些方便的工具要引用util.js

2） 然后还要引用dwr自动生成的js，dwr/interface/service.js，注意js名字要和dwr.xml配置的一样
8 w1 k) _( m# m
( L* a0 Z$ n( Z! |1 Z3） js里的service.sayHello和java类的那个有一点区别，多了一个参数，用来得到返回的数据