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

admin

JEE
简述JEE
# r- M/ r/ {( i! SJEE　： JAVA　 PLATFORM　 ENTERPRISE　 EDITION
8 n0 B- \( c& y$ U" k" H6 v$ t* _
JEE是一个规范集；
" F! `6 y4 K% p0 r, a" i
JEE是一个框架集；
5 J5 h' `& v! V& d1 M# ?1 X: J3 \; Y# O
3 x* ~8 Z) V" B. eJEE是一个技术集或API集；

适用于创建服务器端的大型的软件服务系统
. E/ x2 j5 v+ D( I9 w
* o1 U) O, g7 T' T+ u0 g

C/S B/S 模式
# y  I+ Y0 M& Y% W1 VC/S client/server即客户机/服务器模式，客户端也参与程序的运行与计算（富客户端、胖客户端）

7 I4 G/ e( L4 U6 WB/S border/server即浏览器/服务器模式，又称为瘦客户端，客户端不参与程序的运行与计算


. _' O6 }2 F% n
企业级应用（大规模的应用）的特点
  z: u6 `* U: {1.生命周期长、稳定、可靠

" h- Q% R. L9 I0 P$ H2.组件往往分布在异构的环境中，能够跨平台

* L7 c- Q1 g9 }9 O6 h3 X# h3.维护性、扩展性、重用性
! J) }+ x' d" D( G; U
4.有事务、安全、线程

* p2 y/ }! r- u7 I

什么是业务逻辑？
( p2 P5 i4 X9 K( R; W% O依照业务逻辑划分模块，
- N9 P3 Q" N9 ~$ k! ]& D9 U5 q8 y
  y# I$ |; T0 h' a* `; D所谓判定业务　就是具有以下特征：
7 W0 S! J$ G5 ^8 }
4 x! T" |' t& f) ]) t- |1.业务流程

2.业务判断
6 T% T$ v0 k# p8 d3 E& D
3.功能组合

( o% F6 Z# `6 Z% l: d- Q4 I+ o* Z
. o: f* d+ G( l
平台（角色）的划分
1.平台供应商。提供满足API集实现的厂商（BEA weblogic IBM webshphere）

" Z- V# W; h" R. s( Y2.组件供应商

9 ^2 C9 c$ I0 e5 q/ E' J# l3.组件装配人员
% q/ ]- F" q) R0 `
4.部署人员
; ^+ G5 t, z3 n: v8 {
5.系统管理人员

' }# W4 ^# u: |6 f. b! S6.工具供应商 提供开发组件所使用的工具（Jbuilder、eclipse）

6 c: N2 A% ^+ p

java技术分布（设计架构 模块内部设计）
1.表现层 Servlet、 Jsp、 JavaBean、 Taglib
  L% v+ m) g+ q8 {# v/ Z4 s% r. J
2.逻辑层 EJB(SessionBean)

3.数据层 （　JDBC 　EJB（EntityBean））
8 \/ O5 Z, L0 \* [( S2 ~
7 K5 q) i7 z* b! g% R' b$ z4.服务 JTA（JAVA事务架构） JTS（JAVA事务服务） JAAS（JAVA授权与验证服务）
( X# e: {% s- A& ^" t- T/ J
5.分布式通讯 RMI（IIOP）+JNDI 、JAXP（JAVA 的 XML 架构）
/ X( i; \) {+ d, T
JAVAMAIL（邮件服务）、JMS（消息服务）、IDLC、JCA（JAVA连接器框架 （成））
* r4 b) S: i. G, s) x0 W9 H) \# k4 h. d( i

4 R# o# T  p9 I' Y. s6 m
& u2 x' X  w# Y9 I. fJEE的体系结构： 是一种组件的体系结构
7 e. g# i0 \- }, s' `3 Y* U. V) X: H1.组件 ： 能够完成一定功能的封状体（独立的功能的集合）

2 Y3 A# C% N' y" r9 A不能单独运行，必须运行在容器上

* i% C0 ]% g( i5 }) K( A, J# b分为两类：web组件、ejb组件
6 T6 u9 N! X( x& X. a
2.容器 ： 提供组件的运行环境，并对组件进行管理（一段程序）
& [% H$ w1 L* ]& t  Q. E* r# Y
管理组件的生命周期

不能单独运行，必须运行在服务器上

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

组件通过web.xml向容器描述自己，使容器能够认识组件
2 i0 B. E9 V. _" b5 i4 ]6 R
+ S) `9 ]/ H7 K容器通过回调方法来调用组件
8 T3 B' J; X/ w9 i% N
分为两类：web容器、ejb容器

3.服务器 ： 提供容器的运行环境，提供大量的JEE基础服务
  d9 O: w, ~2 A, z
web服务器（只提供web服务）
' e6 A6 c" K& ?. S+ e0 ?
) H) R; B* M6 ^2 Ajee服务器（提供web、jee服务）

) o: O, q$ g) `2 ]5 M# d6 ~+ n
. W+ M! f) k  w
* f& T5 @6 E0 ]6 V% r# y4 x+ f1 D什么是回调方法
6 p9 B- z- F0 l& R' d: x  G由容器自动调用的方法，就叫回调方法。
4 K. w! I% ~; L. {! ?' [0 t


# h8 H/ d  x/ ?' C7 vＲＭＩ远程方法的调用机制
例如：Ａ主机有Ｂ（）方法，Ｃ主机有Ｄ（）方法，Ａ　想调用Ｃ主机的Ｄ方法
. W  I2 I$ i, G1 O
: {) @2 @4 D- r, Q& B3 Z- a


, d9 E$ s# \% j: \5 i+ l( x% n
2 u% y; a- l$ ^5 }4 \2 X学习方法
1.规范（熟记） 2.熟悉API 3.多练 4.多想

admin

Servlet

•     描述war包、jar包、ear包的结构
  / a6 t& F& p. [. L  h& R
  
  

war-                            web文档压缩包

—WEB-INF

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

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

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

) J" \7 z" V" \; t( J$ i& [* e

jar-                             java文件压缩包

—META-INF

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

& S" p0 v- ]+ m% F& S- z

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

–META-INF

—Application.xml 配置文件

–*.war

–*.jar

• 什么是servlet？servlet主要做什么？
  
  8 \7 M! h) r0 E
  

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

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

& D& \, S5 E, W6 F" v1 v

• servlet 与cgi相比的优点？servlet的缺点
  $ B9 o2 j# v3 z& ^8 v7 q: A6 z+ t1 y
  ( [5 I% U! ?$ h2 ?* D2 A. U
  + V% I& V+ I3 x( s8 `6 b& D

优点：

性能（线程比进程更快）

可伸缩

Java强健且面向对象

Java平台独立

缺点：

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

• 常用的servlet包的名称是？
  
  
  

javax.servlet

javax.servlet.http

• 描述servlet接口的层次结构？
  
  
  0 V8 Y# h( |/ J2 z: P: z  V

Servlet

–GenericServlet

–HttpServlet

–自己的servlet

ServletRequest

–HttpServletRequest

ServletResponse

–HttpServletResponse

• 对比get方法和post方法？
  # \  w! n% H3 {. u4 t
  9 w, h. f3 j; Z, y- P
  4 t* O7 ]; f/ U7 X6 U6 i8 ~; F

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

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

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

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

• 归类描述HttpServletRequest接口都完成那些功能
  / A3 P- O6 {9 u
  " v: ?& y2 |5 r+ @8 w: \
  5 W' z$ b# i& {+ ?2 n
  • 读取HTTP头标
    % V5 e4 r( T4 I8 C" h$ p6 T. Y3 r
  • 读取cookie
    8 `9 j; A! J& J2 s" t. ~
  • 读取路径信息
    . }" u7 U/ r5 K1 J' e
  • 标识HTTP会话。
    
    

- h+ ^( k* Z" x! j4 J

• 归类描述HttpServletResponse接口都完成那些功能
  
  
  
  • 设置HTTP头标
    
  • 设置cookie
    
  • 设定响应的content类型
    " K$ {5 E0 v5 v0 O7 N! [" z
  • 输出返回数据
    ! U% L2 }. ^3 n0 f
    $ P7 s9 i$ ?- _% t

  f1 ]3 C. S( c$ V4 F

• 描述service方法所完成的基本功能？默认是在那里实现的？
  ) t9 \* c. a5 C) w9 s
  
  ' }; P9 Y" D  T7 ^1 a2 u( l% M

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

实现：默认在HttpServlet类中实现

• 如何开发自己的Servlet？描述应该做的步骤和每步需要完成的工作
  
  ( R( R# h; e( ^( r
  ; g- O+ W8 ?+ z8 H

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需要部署描述？
  
  
  . D9 ?6 T2 R8 x( k

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

- r' H; i3 s4 @+ |8 G6 s' N0 |# _

• Servlet基本的描述应该是？请写出来
  
  3 j; W  B0 T/ G" F
  

+ A& ]( N# b2 \$ P3 F4 H- S

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

; `2 g, F: R) X1 c( [$ x5 [; J5 f- c

• 如何在html中使用servlet
  
  
  

FORM标记

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

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

语法：

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

{HTML form tags and other HTML content}

</FORM>

• 如何接受request中的参数
  / S: y( I* E/ `7 r
  String userName = request.getParameter(“userName”)方法
  1 T* O$ r0 O1 M1 p+ P+ s+ R
  

• 如何接受request中header的值
  . n! t3 A7 i" M/ J8 X9 L4 }
  9 c4 r. ~! Z! e
  

request.getHeader(name);

request.getIntHeader(name);

request.getDateHeader(name);

request.getHeaderNames();

• 如何输出html
  # w7 ]  O" B2 {/ l" w/ _
  7 }% r3 `- |) \8 F
  2 O: y6 Z; f1 a4 I! i

PrintWriter pw = response.getWriter();

pw.write(“<html>”);

pw.write(“Hello”);

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

1 |7 h* E$ m: Q9 a4 r& U& G! W

• 如何设置输出的contentType
  
  
  

response.setContentType(“text/html”)

• 描述servlet的生命周期？
  
  5 Y  }- Q6 n* x% k
  % z  ?+ _% }5 V' @0 l

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

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

7 k# v( g& d+ |5 N8 d& @

• 描述init,service,destroy方法的功能和特点
  . p) n; E0 |6 z7 C: I+ c: K/ q' v$ D
  
  9 |5 O4 ?6 s6 K* Z1 h; C. Z5 [

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

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

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

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

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

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

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

• 什么是回调方法？有什么特点？
  7 T) h* c  `% m. ?; z
  
  3 T( m7 @" t- k: b6 S/ ~

由容器来调用程序的方法

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

& B- Z- L, h' T; ~+ s1 F5 }

• 如何设置初始化servlet的参数？
  2 {* F# S8 f9 Z' X% j  K
  在<servlet>中添加如下配置
  
  & F1 W" `3 C% u% n- s6 U5 `% Z

<init-param>

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

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

</init-param>

• 如何获取servlet初始化的参数
  
  
  ) b5 ^$ n: x/ Y

public void init() {

greetingText = getInitParameter(“greetingText”);

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

}

• ServletConfig接口默认实在那里实现的
  
  1 \9 Q2 A( Z7 K! n
  

GenericServlet类实现ServletConfig接口

• 什么是ServletContext？有什么作用？
  7 Q% v, r  A& _; _% T0 K
  
  % {3 R1 a6 U, Y, y8 `

Servlet上下文

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

# K2 S' ~+ _2 j. ~1 y: ~- O/ O; g

• 如何访问ServletContext接口？是在那里实现的？
  6 ~2 W. x! \8 a6 M0 ]& H. F
  ( L5 o- o: c+ a+ Q+ N0 t& g5 o0 o* ^
  

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

GenericServlet类实现了ServletContext接口。

• ServletContext接口的功能包括？分别用代码示例
  ' x/ R7 M7 k+ h) l/ V
  0 q/ G3 V# O. J& C5 i% E& d
  

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

: I$ l4 q# ?$ k! J4 l

• 如何设置ServletContext的参数？
  
  0 |$ p5 {! P' e
  

<context-param>

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

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

</context-param>

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

ServletContext context = this.getServletContext();

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

' {% v& Z& f/ T- g, t

• 描述Web应用的生命周期？
  
  
  

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

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

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

• 如何用代码实现监控Web应用的生命周期？
  : F6 _0 e% [: q1 {) n2 }
  % ~9 _; |1 d: K+ b
  
  

public class Test implements ServletContextListener{

public void contextDestroyed(ServletContextEvent arg0) {

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

}

public void contextInitialized(ServletContextEvent arg0) {

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

}

}

3 J" S  E, l9 c. S+ I7 h2 D. |

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 o9 j4 J* A- H& W$ `+ i
  0 B- C% [5 x- t1 P, O3 y( y& }
  

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

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

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

% g& f" Q0 M0 R- A

• 描述记录异常日志的方法，都位于那些接口？
  ' f; ?6 S; S" S8 b+ I9 _
  ( _/ K& i5 d) D) h
  0 Q! p' w' e8 z4 M( k$ T+ e

GenericServlet：

log(message:String)

log(message:String, Throwable:excp)

ServletContext：

log(message:String)

        log(message:String, excp:Throwable)

' H$ E5 x! z- x6 y/ Q( {

• 什么是会话？
  ) ~; [$ D/ l( e4 D
  
  

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

• 如何获得会话？
  + W! E) ]4 M3 f3 s" Y
  % f( `+ @8 U# `. Y
  HttpSession session = request.getSesseion( );
  
  ! |9 H, h6 c! ~7 S

  I/ k* |* Z/ k: c( U+ @6 u

• 会话Api的基本功能？
  2 o+ q% n6 t2 H8 D1 o1 W4 u
  0 \3 l4 E, K2 G2 @
  & B! |5 o, S- W* i7 ]; Z1 z

getID() :String
1 o, ]3 W2 }0 Q# G$ _; Q9 q% [

    isNew() :boolean

    getAttribute(name):Object
) k, y; E! o# z, q

    setAttribute(name,value)

    removeAttribute(name)

• 如何销毁会话？
  
  
  

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

<session-config>

         <session-timeout>10</session-timeout>
9 ?. E, p* ~! \$ K. v, Y# T+ [

     </session-config>

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

invalidate()

     getCreationTime() :long
- n* a# x0 p; W  c/ H( q4 x

    getLastAccessedTime() :long

    getMaxInactiveInterval() :int

     setMaxInactiveInterval(int)

• 描述会话保持状态的基本原理
  
  
  5 ^2 X2 q. Y' w1 D5 @2 P- Y* l4 X$ @1 g

$ l( U. c2 S4 z, O0 j5 K5 `. N

    client server
" g1 T8 n$ f- V7 {9 m$ H9 U

* S0 \0 L, F1 r

request
9 J0 n, r8 H' ^

response (sessionid)

request (cookies)
/ s# w8 @9 t: @3 B- B$ g# f. C1 a

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

# W% y+ @1 ~  y

• 请描述session和cookie的异同之处
  4 P2 q, s1 N# {: r- G3 u$ z/ R
  % [) V1 q. k" A$ ?
  

- N1 ?2 r" _0 c: z0 ~% [

• 如何读写cookie，代码示例
  
  7 L$ h$ H; Y8 V: `2 g2 B" B
  

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

response.addCookie(c);

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

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

            String key =cookies.getName();

String value = cookies.getValue();

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

     }

• 什么是URL重写，如何实现，代码示例
  
  7 G+ L9 K" Z8 s: v$ i
  , d5 X2 @: ]0 F: r

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

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

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

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

+ H$ F$ l5 U9 ?7 s# k; b' i* A$ @
" M# e; r2 b! D1 N; M: h

• 描述web应用的4种认证技术
  
  5 m# H  r+ E8 K, {: B5 g/ P( l% Q
  ' I( I/ ^; t# }5 R% K) u

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

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

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

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

, m) d; [7 q. o$ r3 {! ^) ?4 A: |

• 什么是授权，什么是验证？
  5 l" {9 R: U" m( Z* K8 k( l
  
  

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

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

/ _7 _, B8 J0 O9 x! l# X9 `

• 什么是HTTPS
  9 z1 w- m4 g& u+ u2 L$ y4 c0 Z
  
  

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

9 ]' W/ @" ]1 |9 b( U" R7 R' i4 {" q

• 什么是审计？
  
  % `2 z/ L$ X  k0 \9 b! A0 f
  

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

• 如何实现声明性授权
  * L, ]# k9 t# z  b+ B# \
  
  

1、标识web资源集

2、标识角色

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

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

在 web.xml里配

• 描述servlet并发问题？
  % c- Z1 X' [( u
  . f; H* l' n- m; D
  

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

3 ]: K+ A- n5 ^6 p0 A

• 描述Web应用中的六种属性范围
  . r+ Y* B9 M& u5 z
  
  

局部变量（页面范围）

实例变量

类变量

请求属性（请求范围）

会话属性（会话范围）

上下文属性（应用范围）

: g0 ]2 R9 Q4 i% I, k% l9 s# D) P

• 指出上述六种哪些是线程安全的
  
  9 _" k0 _0 m% c" j  S& P( a
  

局部变量和请求属性

• 什么是STM？如何实现？
  
  
  . g# Y# ]# f2 f+ p( E) [

SingleThreadModel接口

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

* y% M) r4 T( S3 [" }* ~

• 如何实现并发管理？
  4 X7 w* P' S* ~5 H4 E- }7 A
  
  ! ]2 }9 }& @2 f2 R# z- [

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

使用synchronized语法控制并发

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

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

) w, {: f% B$ f6 g; Y% W0 j

admin

Jsp
) ^& {+ [6 q: B4 S什么是Jsp?
Java Server Page    结合java和html在服务端动态生成web页面的技术
/ z0 \' _6 B  z8 H
. o" W# F, Y* O8 u" G" f- J% I
7 V' i: Q/ x5 H0 u2 P; H' B
描述Jsp页面的运行过程？
第一步：
& T* }2 R% G( J4 F; J
请求进入Web容器，将JSP页面翻译成Servlet代码
: n" z7 E5 q+ B2 h% [8 g
第二步：
3 k+ W0 F: u' ~- Q  k
* `* m; }7 X2 x8 t# T编译Servlet代码，并将编译过的类文件装入Web容器（JVM）环境
5 C2 W8 D# Y) q% N' L* g
第三步：
4 j  N9 c- a3 O1 Q
Web容器为JSP页面创建一个Servlet类实例，并执行jspInit方法
* q* y( p, v8 a! `. j
: i# Z) H( |5 |. u) d第四步：

Web容器为该JSP页面调用Servlet实例的_jspService方法；将结果发送给用户


$ `% C! Q" f% f3 g
描述Jsp页面的五类脚本元素的功能、写法、并示例
8 z. k6 O6 T# S" _注释 <%– –%>

% m. ?; ?, R8 [  m8 T0 R<HTML>

$ @- C( F/ o0 d& A2 g/ D<%– scripting element –%>

6 l, R, j. D( E3 p</HTML>

1 u) a2 W9 c: b- p2 ]: X; b指令标记 <%@ %> 指令标记影响JSP页面的翻译阶段
5 g6 K7 m  l+ ~0 Z0 w' Q
<%@ page session=”false” %>
. Q: o6 d2 K  V
6 o) m1 Q6 q6 g# j声明标记 <%! %> 声明标记允许JSP页面开发人员包含类级声明
3 F9 J  z; \) j3 a
<%! public static final String DEFAULT_NAME = “World”; %>

    脚本标记 <% %> 脚本标记允许JSP页面开发人员在_jspService方法中包含任意的Java代码
9 e& ~$ y$ |/ y& v( Z# h1 i$ Y4 w
" J7 \/ q3 V( t4 _4 J    <% int i = 0; %>

表达式标记 <%= %> 表达式标记封装Java运行时的表达式，其值被送至HTTP响应流 <B>Ten is <%= (2 * 5) %></B>
9 t& T8 ]; a  A
) H7 G% p  J  M  d
+ E$ v3 g& ^! h7 H$ y
" [! V, {4 p/ l0 Z描述Jsp页面中的注释种类和写法
* H+ c; l: \: h5 W4 \$ i' e! GHTML注释
' X/ X1 A7 ~- C: w" X
<!– HTML注释显示在响应中 –>

JSP页面注释
" P  e8 S" F) E+ D
8 I6 l  e- T) c/ v<%– JSP注释只在JSP代码中可见，不显示在servlet代码或响应中。–%>
  t7 G* w, R5 w. I- _
Java注释

<%
3 o+ R: {4 X: ], m) {
/* Java注释显示在servlet代码中，不显示在响应中

*/
: _$ J* n2 Y1 R" V+ x7 Q9 `
. O$ G% L( t, J& Y' M%>
% f9 m& k& y" `
1 K. v( S/ C/ ~+ [6 ]

) B  }* r( d3 a描述Jsp页面的指令标记的功能、写法、并示例
3 ]/ _. }& D/ E- @指令标记影响JSP页面的翻译阶段
, X+ {' R+ _0 F) d8 v' ^- [
<%@ page session=”false” %>

# x- p) m- L; o5 }/ P9 g: o4 J<%@ include file=”incl/copyright.html” %>
& `6 ?$ E- p4 b2 F: d
<%@ taglib %>
! G. w5 Q7 N4 I, v) g6 c- S; F


% q( s, T# g4 p; f0 g: Z描述Jsp页面的声明标记的功能、写法、并示例
声明标记允许JSP页面开发人员包含类级声明
  O3 Q7 L$ `+ |" n+ I
写法：

<%! JavaClassDeclaration %>
2 f3 _6 v, w+ R9 s
例：

9 I9 t9 N+ f8 u, _4 ?/ d<%! public static final String DEFAULT_NAME = “World”; %>
, F0 G# ~  g' e" R5 E! v. F
* `4 {! s3 T+ D0 _1 n5 ^4 J4 Y" K<%! public String getName(HttpServletRequest request) {

return request.getParameter(“name”);

}
5 B# k3 Y$ Z- ^+ U; k5 n
%>

<%! int counter = 0; %>
) C" E/ [' J2 J* m1 v) U' ~! H
, g: r) q0 }6 j6 C5 x0 v/ M* ^7 p

! i1 J$ ]: i$ Y" l描述Jsp页面翻译成Servlet的规则
" M+ Q$ j9 B& `/ z& w* k% ]- Pjsp中的注释标记被翻译成Servlet类中的注释
6 c& G: H. S3 F3 }  L; n! ^
+ F% q8 i7 Z( @jsp中的指令标记被翻译成Servlet类中的import语句等

jsp中的声明标记被翻译成Servlet类中的属性

7 v+ H1 z5 f* q9 o9 c4 k) A' Y" Gjsp中的脚本标记被转移到Servlet类中service方法中的代码
, ]' _& Q5 t1 y" U) @
0 U6 Y: ^+ |- d0 g3 `7 L' gjsp中的表达式标记被翻译成Serlvet类中的write()或者print()方法括号中的代码
5 J! ^4 B. _! `0 {


描述Jsp页面的九个预定义变量的功能、用法、并示例
request 与请求相关的HttpServletRequest对象

response 与送回浏览器的响应相关的HttpServletResponse对象
; e/ ^) @- j7 p; d
( \0 d$ [* r! T' lout 与响应的输出流相关的JspWriter对象

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

与一个HTTP会话时有意义
! j4 n1 O3 x# V, e! M! c! d( D- {: \
$ P$ J( V1 B0 k* [* v    application 用于Web应用的ServletContext对象

% T% T: J5 P9 f3 t9 E+ i, Dconfig 与该JSP页面的servlet相关的ServletConfig对象
9 w5 r9 s* V$ d% U# r  m& Y, n$ J
- A; D: z, T) |9 Z, i& g$ N- Q  TpageContext 该对象封装了一个JSP页面请求的环境

( |; b  U2 G$ w1 D2 g! Jpage 该变量与Java编程语言中的this变量等价

4 w% Y0 `  z& N, S. L    exception 由其它JSP页面抛出的Throwable对象，该变量只在”JSP错误页面”中可用

' L( U# L, V: }* Z8 J- t
) V/ w) L( C7 t( c* p0 M( I8 C4 s
page指令的功能，写法、并示例，并描述它的如下属性的功能和用法：import、session、buffer、errorPage、isErrorPage、ContentType、pageEncoding
import import 定义了一组servlet类定义必须导入的类和包，值是一个由
: X* B8 V+ m9 s6 d3 y: T0 S
7 j1 l9 `8 ^1 B* T/ }! }$ Y逗号分隔的完全类名或包的列表。

session session 定义JSP页面是否参与HTTP会话，值可以为true（缺省）
4 R1 q: K. a4 F9 B
或false。
& C/ }. \+ b+ B$ d
buffer buffer 定义用于输出流（JspWriter对象）的缓冲区大小，值可以为

none或Nkb，缺省为8KB或更大。
" X8 R# n' E( M
errorPage 用来指定由另一个jsp页面来处理所有该页面抛出的异常
7 o/ d+ B4 i, N. f- m$ c
isErrorPage 定义JSP页面为其它JSP页面errorPage属性的目标，值为true或

false（缺省）。

4 o  A+ X" f0 k- l: g  E, {3 UContentType 定义输出流的MIME类型，缺省为text/html。
% Q+ Q- P& F) \% Y* t; ]
pageEncoding 定义输出流的字符编码，缺省为ISO-8859-1
, y+ s; [% O: ]. W/ Q3 {8 {
* b4 U1 [; a3 f5 [5 J& y

描述MVC各部分的功能？MVC的优点？MVC的缺点？
2 q+ U" i8 p  j- N7 v% IMVC各部分的功能：

+ ?8 _( H; X; _9 K/ q% B) {# d% T9 vModel（模型表示企业数据和业务逻辑）
/ N, T8 J2 S9 Y& R
封装应用状态

响应状态查询
" t- N: c4 C' c
6 Y& Y  J  u/ F3 C3 k暴露应用的功能

Controller（控制器接受用户的输入并调用模型和视图去完成用户的需求）
8 v5 p* V5 L9 j/ `" o$ n
验证HTTP请求的数据

将用户数据与模型的更新相映射
' y. E- |& w3 J7 m6 E/ U" E& _
选择用于响应的视图
( D: r: i! x* u7 J
! x, w- F7 Z. t$ W3 d3 A$ `9 A6 n" vView（视图是用户看到并与之交互的界面）
/ V& o7 E4 z8 z% E$ ^) o/ Z
产生HTML响应
9 Q( Y& I3 u5 x" R) R
7 P8 W' V8 ?, k/ o# R请求模型的更新
4 V+ ?! |" h% |4 o. l9 T  S
提供HTML form用于用户请求

MVC的优点：

        低耦合性：视图层和业务层分离
. i! ~. C) o) m/ _. U/ n4 a
6 J& N+ P+ s4 Q" Q# n0 }" A1 L, c高重用性和可适用性

较低的生命周期成本

快速的部署

可维护性

有利于软件工程化管理

提高软件的健壮性
: `: ^$ ^1 ^; b+ c8 t( V
5 k, x( r5 S: t' }MVC的缺点：

        工作量大，增加工作的复杂性，MVC不适合小型甚至中等规模的应用程序



什么是Model 1结构，以及结构中各部分的功能
3 e; F# e& Q4 n! G结构：jsp+javabean
/ u% y& u) K. I9 w! f( m/ K
Model1中使用jsp来处理web应用中的视图控制部分
4 c% b. s) W% K  [
# o& y0 t/ e" t" DJavabean收集参数



% n% [8 t# j5 o( W2 u) [* j什么是JavaBean?
用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。


6 x! U0 a% p1 s" S
7 J- Z# n+ w' JJavaBean的规则？
使用get和set方法定义属性

一个无参构造方法
+ r) l7 l& s! {( g# F* v, |
. P1 b+ W- ]5 y% ^无public实例变量( 所有属性私有化)
+ q& ~: |# B; x


什么是jsp标准动作？包含那些？分别都是什么功能？如何使用？
7 N" l5 d6 r0 {; l6 o( |JSP页面中使用类似于XML的标记表示运行时的动作

jsp:useBean
/ E! _( o0 r6 M2 t/ o( Z' H
7 i# i6 X% X" ^7 Jjsp:setProperty
0 l9 p1 Q- R: \1 h
' H5 ~8 r' [% ]  Sjsp:getProperty
" i0 \" \; W3 ~4 y' Q. y
jsp:param

1 ]  O% C3 p% Q" d. ]0 q2 ljsp:include

# a( ^9 a/ V' o" D  _+ I! ?0 v2 t3 q1 p/ tjsp:forward
5 B( P4 j% z0 f" ?


用代码示例如下标准动作的使用：useBean、getProperty、setProperty
3 p% g  P* ~9 ], Z/ T: R$ e<jsp:useBean

# a: h8 i! Q( tid=”myForms”
, y* F" g7 L! P* E& N* N# z& [. p
0 L# R! K. @6 }, P: pclass=”com.base.mystruts.forms.MyActionForm” scope=”session” />

    <jsp:setProperty name=”myForms” property=”name” />
4 i* E6 D' u8 N1 b% V0 z( u) u
<jsp:getProperty name=”myForms” property=”id” />

$ W2 B( O  N! U4 x. o$ F0 G
% l4 F/ l0 {% F
描述说明Bean的四种scope
# D# _9 b& {" l6 T" N  ^& Lpage
/ h& g2 w: T3 s8 \0 B
request

session
1 c' n6 f5 e# A
application
! Q6 O  f/ c2 `! e: ^
% o5 e2 Q/ s8 |  Z# P7 g

& [! E3 E. Z/ Q6 Y. i) P描述说明页面上的字段和Bean中属性的对应规则
id 指javabean的变量名

4 ^3 U% A. l! Dclass指javabean类的全路径

scope指javabean的应用范围

name指所用到的javabean的变量名

7 U( s, ^) C3 y    property指javabean中的属性

7 W7 V" h! ~- }- T

$ t" c4 a4 @7 [; t& w* w描述useBean动作的处理过程
使用id声明变量
, [+ D$ t( e: G  _+ Z- R) w0 P8 u
试图在指定的范围内查找对象
) w: B8 L8 O# B0 F" H
4 z6 ?0 |: ~4 c' |1 \如果没找到

4 k& I' x+ `" p: L% \0 s# [创建一个类的实例
, c0 o+ @: I, w# u, L6 p- p
8 [; J$ {* M  W1 A) N$ X# B! p执行useBean标记体初始化对象
+ o2 U) }0 _- n* `& N0 u. \" ?
如果找到
, t; N# ~+ R& A0 k
7 i; X& p. e) M- M     将对象转换为类指定的类型

0 a/ N1 y3 y8 m. j

7 h, @4 F) N: j描述forward动作的功能
使用脚本代码处理请求时，可用jsp:forward 动作产生一个不同的视图，

. |/ \2 }8 x( i+ i使用同一个request：



) G. U# a9 _% ~  ?什么是Model 2结构，以及结构中各部分的功能
jsp+model+servlet
% H+ s& x( h# n/ a! J& A
! H1 L5 U' W% k8 S' LModel 2架构使用MVC模式，JSP页面充当视图，Servlet充当控制器

Servlet控制器：

验证HTML form数据

* X3 O2 T+ ]4 t& p调用模型中的业务服务

; X% d. o3 z! b% ~" B$ l存储请求（或会话）范围内的域对象
" p# w) q# J4 E% {4 l
' N2 S8 Y3 I% l, G- d0 @# c选择下一个用户的视图
2 e1 q; k# p; C  q3 U( P, o' H
JSP页面视图：

) k/ z( \, P1 W! L' k使用用户界面（在HTML中）

        访问域对象
0 v- z5 {& |! L


/ y3 O. I8 }! K; V6 Q. C如何获得分发器？分发器的功能？
上下文对象中的分发器：
) x. ~+ S& V3 A# A9 d) T% u( \) ?
ServletContext context = this.getServletContext();

RequestDispatcher servlet = context.getNamedDispatcher(“MyServlet”);

# h9 s' O, v8 H4 q. ~+ Wservlet.forward(request, response);
! M0 j5 n* o/ I# X" Z4 J
请求对象中的分发器：

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

view.forward(request, response);
* y8 j8 Z6 v8 A$ z  D4 R: `
6 g. Q' L5 ^9 ~2 c8 z4 {  f可以将请求转发到另一个jsp页面，并保持请求的传递性
. i; E8 w# g, ]8 O
5 p2 B/ ]/ I4 O! R: W8 s/ V: L9 B
1 x  z% ~( w7 |! \+ e
0 G; L  Y3 j( U5 o/ i' S. |Jsp中页面跳转的两种方式？
: I  t" r7 x; w+ D使用分发器跳转页面
RequestDispatcher dispatcher = request.getRequestDispatcher(“url”);
% y" z0 Q) S- U) g# k0 I4 n" w+ j2 O% J
% |' _4 I! H- c: R/ T9 k2 _4 Vdispatcher.forword(request);

1 p; j+ d9 ?% e9 y    特点：保持请求的传递（上一次请求中的数据，在下一个请求中仍然可以得到）；

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

3 n  U! u9 ~& Z7 A使用重定向跳转页面
response.sendRedirect(“url”);

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

  ^& C$ A7 d9 Q5 F/ M        重新定向的页面可以是任意的URL
) N, b! y! o) e' I. U
  R9 k. w5 `! Q+ [8 l

描述Jsp中引入另外页面的两种方法，并比较两种方法的特点？
<%@ include file=””%> 在编译期间把另一个页面完全嵌入这个页面,可以说是一个页面
; M" \0 g2 R* }( ]: u, X
在这里可以共享变量
3 A) K; d; U' O
1 n3 K  O( f5 Z, w! N) s: P% w; w<jsp:include page=””> 动态的再运行期间把另一个页面加入这个页面,可以说是两个
/ ]# s) a* {& n$ T( g
0 w0 c; G8 h$ k5 V" U1 }页面，不可以共享变量
! Q: E4 j7 B! I5 H! I" q# ~


什么是自定义标记
自定义标记库是一个Web组件，
) W0 t/ f9 {' N
. F" K/ H) t# z/ N包括：

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

所有相关的标记处理器类(*.jar)
' e; ?8 A/ F1 L( a% e9 a5 W
7 q, a$ B+ M) t% \! I; ~

描述使用自定义标记的步骤，以及每步详细的工作
9 o' _" c3 l- l使用自定义标记前，要拿到.tld和.jar两类文件

把.jar文件放到WEB-INF的lib里面。
把.tld文件放到WEB-INF根目录下。
在web.xml中配置。
2 u. u5 |0 R# A) K0 M<taglib>
# M, e$ B" [, v* k/ i6 r0 V3 e
$ |8 \( C& D. \( Y: a<taglib-uri>http://java.sun.com/jsp/jstl/core</taglib-uri>

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

( g5 Y$ S% n& c) [4 o9 J1 ~# k3 ~+ \</taglib>

在页面中引用。
: c8 @- G" A' Q<%@ taglib uri=“http://java.sun.com/jsp/jstl/core” prefix=“s”%>

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

prefix是前缀，用来区分是哪一个taglib
+ c1 K5 c* [& V6 e$ a" Y& N: ?
( O$ C" Q4 E  A1 ~) ^0 X使用标记
% E- [6 L+ T* v/ h  `9 y格式：<prefix:tag名称 属性>
8 F. I0 K. c# q, M- L# k
% M- \+ B/ e$ \) o" ^% i<s:forEach >

admin

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

配置server.xml文件
0 @' a1 k6 K7 N
1.oracle

<Resource name=”jdbc/company” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”
/ M! D. ~' C' l2 C% v' N9 `! d' \
' l2 L! |9 W0 Z* m" M4 v$ z4 ^) g                        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”

2 v. G5 e. i, h- m: x$ burl=”jdbcracle:thin127.0.0.1:1521rcl”

. {5 [6 o  C+ j* \. Y5 wdriverClassName=”oracle.jdbc.driver.OracleDriver”
% O3 x4 @( S3 h4 J6 c+ I
username=”aa”

password=”aa”

maxActive=”50″
$ [0 `0 I9 S, Y/ g2 e& w8 a
& C$ ^. _  a; q& _* c) zmaxIdle=”10″

. D" r3 E, q0 h1 a1 CmaxWait=”-1″
, k' b. g# L% {* H
' l8 }$ a) ^. F9 b! I/>

2.sqlserver
! m" {5 V* f5 i7 h- T
, Q+ z0 L$ N  |) R; B5 {! y" T* [<Resource name=”jdbc/webpage” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”

! I* E& r. U2 c( J" J0 y        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”
# E; j/ I# E( X& F# x1 I- i
) g. Z) z1 i9 k1 }* Iurl=”jdbc:jtds:sqlserver://localhost:1433;SelectMethod=cursor;

DatabaseName=webpagetest”

" P; E( R  Q  V( t% Y4 T, _driverClassName=”net.sourceforge.jtds.jdbc.Driver”

. a. t8 F+ h9 Y- a/ ~% i: d, P( ^username=”aa”

2 N7 V  W1 X- z  ^1 npassword=”aa”
5 Q$ x$ |5 W# o
, D. P* U; o; |maxActive=”50″

8 c+ f+ B( u; LmaxIdle=”10″

maxWait=”-1″
0 `! x: \2 z; X3 z1 A* h. N; @* Y4 X+ f
5 r# M, L3 A) E* e# Z/>

3 ~5 w1 q' y# u6 n$ k- B% V$ X2、配置自己的web应用的xml文件
* K" N' S% m6 z  V8 v
& y# B; z* g1 t6 x# ^6 S% ~: j. E% `

- q4 x8 `3 I1 y: J: x<Context path=”/eb03web” docBase=”F:/workweb/eb03web”

privileged=”true” antiResourceLocking=”false” antiJARLocking=”false”>

1 J& H" ~+ i) T$ u<ResourceLink global=”jdbc/company” name=”jdbc/company” type=”javax.sql.DataSource”/>
. q) u4 ^" [% Z6 B# K" ]
" u, }$ s& J8 [% \</Context>
& E6 Y! |  V3 }& n' Y
& z2 ]) F) U8 ~+ y; @

) ^% h; N+ T- f3、配置web.xml文件
/ z' d0 U6 ?" |* O( S9 S$ d- L+ [
与服务器建立连接

9 w$ a8 B- t  ]5 N- z0 |$ a<resource-ref>

<res-ref-name>jdbc/company</res-ref-name>
! z7 T6 C) C6 e8 N; o* Q
<res-type>javax.sql.DataSource</res-type>

<res-auth>Container</res-auth>

</resource-ref>

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

5 C1 h! ~4 B0 p" M- }: }//1.在程序单独用时设置系统的属性，在tomcat下可以不用配置，

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

; V! v; H, Z' i" l. |* bSystem.setProperty(Context.INITIAL_CONTEXT_FACTORY,””);

, I2 ~0 M9 V1 L2 y//2.创建一个上下文对象

InitialContext context = new InitialContext();

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

" c9 T! |% R0 w0 p1 c0 x$ [DataSource ds = (DataSource)context.lookUp(“java:comp/env/jdbc/company”);

2 m0 z9 A( k9 ^# I, x7 h//4.通过数据源建立连接

# c. F6 `1 S- B: _" ^1 O) uds.getConnection();

admin

ORM对象关系型数据库映射
(Object Relation Mapping)

' T- b8 E6 m8 S% a一、映射的特点
" E" P$ b! x& Y* j# W
1 t" [1 V2 {/ g0 B1.一个对象可以对应多个表

& `$ M. X* W: Y/ z& {2.一个表可以对应多个对象

5 Q( V$ _- v- K3.对象和表的关系不用完全对应
! Q. J! X; y2 I( W
4.对象的属性的名称和表字段的名称可以不同

; F) X, {/ D! v) q5 c$ r5.类型可以不同，但数据类型之间可以转换
- D8 P3 v, k0 L, g5 e& Q
6.对象中必须有主键，数据库的表对主键无所谓

7.数据库中有主外键关系时，对象中可以有，也可以没有
( S* D' K  O+ s, ~8 B
7 G9 m9 @) t0 g% g8 Y* o9 Q
2 C! r8 {; p7 o; M: h5 F6 c
/ S1 i2 z! _9 E$ ~$ t二 、有一个映射的描述文件————>xml

5 t5 A% D3 _- r7 }: Q  ]三 、怎样实现描述文件————>一段程序
( z) R0 O' t6 u# s
对象 映射（mapping） 数据库
& e+ [5 a# |+ _* M* q
user
8 U0 @" ^6 c$ K3 U" o1 J: s2 p! ~
4 \+ P( b: U- Z$ c2 M1 jid=11
$ c6 D& L5 t( M' Y% l
name=”张三”———— > (1) —————> tbl_user(id,name,age,tel,address)
( X3 L! z5 u& J+ J* t2 {3 ~
age=25 <————(2) <————
: W9 a) J: h. q8 F1 ^( M
8 g4 x4 r8 }$ ~+ `$ e. Y

(1)从对象映射到数据库
+ q6 Q, D7 x# N
; O5 z% @* Z3 i. C5 }1.JDBC

: e, Q, m' E- f6 l' I4 H6 a2.根据描述文件来动态拼接sql

3.执行，添加到数据库中
1 Z1 Q, ?; a" y4 x3 K  ?8 [: M9 f


(2)从数据库中映射到对象

1 U+ f) d& ]- L1 L3 Q, t1.JDBC

) {& N; k) `% g2.拼接查询sql

3.ResultSet

4.Model


! X/ m7 B1 W+ A
3 V% K( h' u+ t6 S& v* Bhibernate
开发流程：

! Z  q, u6 _4 {8 T: @5 s: |是什么？
- H8 }0 y& \+ z' m- Hhibernate是一种基于orm 的轻量级的框架


# K; D% e7 f0 c& j! s7 K
有什么？
1. session 保持连接状态（依赖事务和连接池）

2. Transaction事务
/ Y( l4 s( D5 n4 i
3.
8 `$ A0 ^  Z6 ^Connection Provider 连接池


/ d6 W+ A. h/ @# T- X% i" Z" L
) a+ I- R, J2 O! @$ h能干什么？
- R+ s  @& k6 j6 i0 v  X1.orm
& `. k' H, K+ |: w* s
2.提供操作数据库的接口，简化数据持久化的编程任务
9 M, a$ p3 j) W
' T- D$ ]: {: m  K; N
; Y7 r2 I* v; ?
怎么做？
1.搭建hibernate的运行环境，将hibernate的包和hibernate所需要的包拷贝到lib 文件夹下
' _2 ]# N5 Y8 o9 ~
( }0 b$ J' j+ d7 w' k2 K2.O（vo）
/ e* J) S: u; V! f
3.R （关系型数据库中的表）

4.配置文件

4.1 cfg.xml 放在classes根目录下，默认名字为hibernate.cfg.xml
$ _' d- t; \* ~7 V4 B7 A7 W
' }; F% Z4 y) o- R7 v! [) La.与数据库的连接

6 x% u0 {! q8 x9 R( \9 Rb.可选配置

# j! b1 q, J" o, hc.映射资源的注册
6 v# P) c1 ?% M4 @, `/ R& O3 \
$ j+ H% r& ~9 b5 p6 j4.2 hbm.xml文件 名字与类名相同 并且与类放在一起
8 J1 s7 B2 w/ J9 H
a. 对象与数据库表之间的映射
: \6 B9 v& X$ P5 t. a
b. 对象的属性与数据库表的字段之间的映射
6 }$ R3 a, Y- h; c! L$ `/ G
c.组件之间的映射

+ e! C$ g; ~; Q( y! {d.对象与对象之间的关系映射
5 N2 e" b% S4 L* a4 z
5、客户端
" }- ^( |9 _2 r7 {0 f0 r
1.得到SessionFactory

1 f, V# @# Z/ g" {' r. G2.通过SessionFactory 工厂来创建Session实例

* l# z  S2 g% P) ?, O8 ?) s2 y  F9 W8 K; W3.打开事务

4.操作数据库

$ q& G$ |" i0 v) e+ K$ D5.事务提交

6.关闭连接

运行流程：
  J2 Z) e1 P- _  ~/ `
2 }" [8 |- a+ R0 F5 p整体流程
# g0 `5 r9 j& S& Y6 ~: t1.通过configuration来读cfg.xml文件
0 x# h" }5 n* h7 q  [
2.得到SessionFactory 工厂（根据数据库的连接来创建sessionfactory）
: B5 k& y3 T" E( s+ N  C
4 s* {6 ?8 v2 j0 d. s3.通过SessionFactory 工厂来创建Session实例
5 Y; v# L; G0 [2 U: g' Q+ w
3 ^- U6 }7 z+ f' e# [4.打开事务
& e' X. w9 ?# G+ q& l4 {
5.通过session的api操作数据库
! k4 d* z/ h+ o. c
6.事务提交
* y4 I. G3 O; ]! S7 H8 v5 q
7.关闭连接



save
: Q/ s1 H% c7 I1.to—>po
3 _$ e) q: `5 y2 P: R6 Y) K
6 ~8 N. l8 ?# P* V" L) l; [* {2.根据model和cfg.xml中映射文件的注册来找到hbm.xml文件

" R/ x  Y) G. u3.根据hbm.xml文件和model来动态的拼sql

9 }+ @: y: c6 C4.客户端提交或者刷新内存

! p  Q5 d1 q- L: l( G5.执行sql，值放到数据库
- [9 h/ N1 P  V" d& Q* j5 I- A+ H


update、delete
1.根据model 的id在内存hibernate的缓存中查找该对象
# i6 E$ E: E. L% q: q
; l: b3 A  c& b0 Z- p4 c# U% B& ~如果内存中没有就到数据库中查找来保证对象的存在
9 W1 K9 `  z/ ~
2.根据model和cfg.xml文件中映射文件的注册来找到hbm.xml文件

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

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

5.执行sql

: b! h* I+ m4 l8 q- K
0 a$ F7 k) N- j
: d! ^  j3 o9 t( H4 d2 v6 g. EQuery
load

& m+ x3 [3 k+ Q  W3 \; y6 i- }1.根据model的类型来找到hbm.xml文件

2.判断id对应的对象在缓存中是否存在，如果存在，就直接使用，如果不存在就进行下一步。
* F  A" e5 t) S- J
3.用id做为查询条件来动态拼sql

4.执行sql 查询（先在内存中查找，如果没有找到（会抛出例外），就去数据库中查找）

% _( l9 Y; k0 U* d/ E- F5.返回一个model类型的对象

get
$ ~  ]' E8 q5 M' C4 X/ h& v) b
    1.根据model的类型来找到hbm.xml文件
- H4 U/ F: A& p
/ B: g' l  v, T) ^. Q$ F2 Q+ q. `$ ?2.用id做为查询条件来动态拼sql

3.执行sql 直接在数据库中查找，如果没有查到就会返回null
# q: S& Q6 z9 h, t3 J) H
& H6 Y2 C/ c! P8 I. xquery

$ f$ K. X9 c9 t1 M1.分析hql语句，得到model的类型

2.根据moedel和cfg.xml文件中映射文件的注册找到hbm.xml文件
  |6 d5 d/ Y, G1 s" N9 l- a3 w1 U9 ?
3.根据model和hbm.xml文件来动态拼sql
; i2 z8 e8 m9 m% o  b5 m9 b6 i. W& g
4.执行sql查询数据库

5.返回一个resultset

7 Y8 u! ~) O, A* C- @' J8 K& r6.循环resultset的值，放到model中在放到集合（List）中
# v) M1 ]8 \! d+ X

% a  p& q! E; s: T; o
) A" ]; C+ o9 K/ x. `谈谈hibernate缓存机制
7 U1 c- B8 |0 P* f6 r
缓存其实很直观的理解为放到内存或者硬盘上的一块区域，缓存就是一个缓冲的作用，有很多时候，我们的数据需要经常访问，如果放到数据库中，不是不可，只是效率上低，如果有了中间产物来代替数据库，就省很多事情了。打个比方，去买酱油，不一定一定要去酱油的生产工厂去买。代码中需要数据的时候，可以先到缓存中查找，如果存在，就直接拿数据，不存在就去数据库中取，也省了很多事。

3 D# u8 z' b; a) j$ ~
7 _( a- N! C2 P1 X
/ n3 [! B! @* x4 r. j4 Zhibernate使用的是二级缓存，有两个级别，分别是Session，SessionFactroy级别，一级缓存是Session级别的缓存，Hiberante来管理的，这个我们一般不用管，二级缓存是SessionFactory级别的，可以进行配置和更改，加载卸载，就是我们平时用的hibernate配置文件中的配置SessionFactory的属性。
' Q+ y: T# I3 L1 M
( d9 Q* v9 P" P7 v6 H6 U0 L& ], ]2 Z7 C
9 i& U8 F, U" c
+ r" Q; g( T3 |/ Y: \对一级缓存中的session事务进行数据的预存取，数据在各个session的上下文中存在（单例），当session关闭时，就是session.close( )，整个所有session范围内的数据全部清空；二级缓存默认的情况下是不开启的，如果开启，数据库汇总的所有数据都先copy到二级缓存中，这里要注意的是，一级缓存是每个线程下创建的session缓存区域，可以是多个，二级缓存只有一个区域 ，画个图比较容易理解。



| 一级session缓存| | 一级session缓存| |一级session缓存| |一级session缓存|

| | | |

| | | |
. v; j/ z. K! y$ {
—————————————————————————————————

sessionFactroy级别的二级缓存

——————————————————————————————————————-
1 U* r9 p* m: ]6 [) M, s% [! A3 R
|
3 M6 f4 O/ ?. H+ o8 G: [+ `( Q
|

* J, w, F0 j5 q8 A|
4 b7 x5 L  N. {; q1 e0 k
3 N9 G2 z$ O2 t; S" h9 P" u$ W——————————————————————————————————————

: ^5 V: x+ j, u. A: q, J" V7 G+ nDB

& U, i! a" R" Q7 W: ^3 f—————————————————————————————————————–
% f) S/ u. x4 y1 r
8 K: {2 }/ }& ?6 t1 ]

admin

Spring
) `" K6 e0 C6 C7 ?( _& |

• 是什么？
  2 J. _# @3 X4 V
  ; o% l! Y9 Q7 a0 E' v/ k! V

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

• 有什么？
  
  * \  W' E' }6 I9 D  Z4 @+ c

( @- O* ?( K; p, k) d9 G* W

每个包的功能：

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

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

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

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

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

AOP ：面向切面编成

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

8 \8 S6 c/ }8 P3 |" p* C' z

• 能干什么？
  ! J. n  }$ x& O+ H
  

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

+ k2 U) p6 V- @& u0 i

• 怎么用？
  5 g5 T% m" y3 H* _" G2 G8 }& d
  
  • 搭建web工程，引入spring的jar包
    
  • 在web.xml中添加如下配置
    
    
  
  
  

            contextConfigLocation

            classpath*:applicationContext*.xml
  C  b  M) E: B5 o: k( ?) i/ M

   

        
2 m: r$ k$ m* t3 q; t3 C% X, ~# Y

            struts2
5 N1 W+ Q0 i" v, k, Q) u! F" L( {

            
8 U( N9 e+ n4 i+ _- B* m9 l

                org.apache.struts2.dispatcher.FilterDispatcher
  u1 o6 {9 ^% [1 i

            

        
7 _7 V0 M. q: s3 C, t3 j

        

            struts2

            /*
) w/ P; T5 t, V& `' J+ y

            

                org.springframework.web.context.ContextLoaderListener

            
; l; ~6 Y6 t: o) }

        

• 部署
  8 l2 V4 h. Z" L/ ~
  + r9 p1 b6 i" x3 P- M8 _7 ?

" ]9 ~9 v* W- o$ D" @2 `( ], r2 A  f
" l. L1 ]+ K6 F' ?

• 容器和bean
  0 v' X3 k3 X. c* T  V

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

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

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

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

• IOC控制反转
  # U# q2 a& B! d' W
  % s: f$ f; V; y0 c; l
  
  * P9 A" ]1 G# w  V. d& p
  
  从前的应用程序想要得到A的实例他会直接主动的去拿，当用了sping后，应用程序由主动的去取变成被动的等待，由spring来控制应用程序所需要的对象
  
  5 W/ j7 ^1 d% F* @0 H
  • IOC的优点
    
  1.可以通过IOC来获得实例
  2.可以通过DI来获取注入的资源
  • 配置IOC的原则
    
    • 一定是可变的资源才采用依赖注入
    • 一定是层间的接口或者是模块之间的相互调用才采用依赖注入
      

• DI依赖注入
  - o- S) K4 x9 z. C0 f& D  P* H

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

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

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

例如：

在配置文件中

* x. s, Q  J5 l* x- L" ]( u

! \* x  m( @/ y; j$ {, k

在应用程序中

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

( ]$ s4 r4 D6 n. M

• Aop面向切面编程
  . O0 l6 B7 U  G3 A# c! t+ ~
  8 K3 w3 w7 ]6 q

1.AOP面向切面编程 一些较好的模式或者是示例—-范式
' s, j0 l! ]1 \( ~" e1 G& p

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

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

3.AOP 的概念

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

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

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

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

5.引入 ：扩展的功能

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

7.aop代理 ：实现机制

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

4.AOP的事件机制
+ q' Z/ v: C1 Q9 j

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

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

3.找到切入点

4.确定连接点

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

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

0 w: M1 p) U, f$ F. E, P
, ]8 y7 }+ @! H8 c- v
9 Q- I( R/ n9 ^+ T; J* M  V, x$ E" V

1 q9 o$ E1 O3 l; J5 m2 ~4 F$ W/ b1 Y
+ |( G. t1 L9 j3 p. D( p

5. AspectJ
* D- K" `' W) s0 \

5.1.在xml中配置比较烦琐

所有的入口必须从一个代理（ProxyFactoryBean）开始
( f* b; I' I0 l) ^

         


: j4 j, x3 {7 w$ f9 z: t& w         
8 U% k) b: v8 X2 d# P0 n$ V/ a6 n

        
% R. W, K; l9 m" a& _

        

) A# M! A( {7 X& l4 fexpression=“execution(* com.javakc.aop.MyTarget.t*())”/>
7 K* b0 J. h; F& b# m' R0 F4 q' N

        
2 l8 F% N5 u" j# {! }' i) k

        

   
0 L" M! b% A. F& ?

$ H" `4 Y; P% i

5.3.使用注解的方法相对简单
. t( w7 B; E* h4 f, K5 C

@AspectJ的基本语法
' ?& l9 \  U# `' j: ~

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

直接在类上定义@Aspect

2.@Pointcut声明切入点

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

2.2、可以使用匿名的pointcut

2.3、执行切点的几种方法

2.3.1 execute（public * 包结构.*.*.（..）） 可以指定到具体的方法
( Y4 f( Z! r7 Q0 ^1 R4 r

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

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

2.3.3 this 指定到实现接口的所有的实现类
- R- t" [  L/ {! Q$ ?8 E* ]: w

2.3.4 target 指定具体的实现类

5.4.advice的五种类型的示例

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

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

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

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

pointcut指所要监控的目标对象的方法
9 z/ |, `3 Z6 X' b+ g

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

完成追加的功能

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
( V& F' u" ]& g7 w

(1).@AfterReturning(“com.javakc.spring.schemaaop.TestPointcut.t4()”)
# U. i6 U& h0 F: P

(2).
$ I+ h1 H/ Q2 d/ j) P

     2.直接引用匿名的pointcut
8 E. P% t: `1 @6 u; q

     (1).@AfterReturning(“execution(
# x; N4 C0 Z; |6 i4 u

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

     (2).@AfterReturning(pointcut=

“com.javakc.spring.schemaaop.TestPointcut.t4() &&
7 \1 M, [0 ^2 {8 m

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

@AfterReturning (pointcut=”com.javakc.spring.schemaaop.TestPointcut.t4() && args(str)”,returning=”retVal”)
  b% L0 H- @" \1 Y

public void testAfterReturning(String str,Object retVal){
& i1 ^2 P" H5 R" V1 Q

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

    }

5.4.2.@Aronud

     注解@Around环绕追加功能；

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

     必须有参数；第一个参数的类型必须为ProceedingJoinPoint；
) Y; `7 ?& @* A. z4 T

     通过ProceedingJoinPoint的实例的proceed来调用所监控的
8 Z% z6 m8 B3 K4 p; a3 o! p

目标对象的方法
& ~6 k, H; e0 m6 a! k

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

     (1).@Around(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
  j/ y( s. [+ f

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

&& args(str)”)

2.直接引用匿名的pointcut

     (1).@Around(“execution(

* com.javakc.spring.schemaaop.Api.test1())”)
1 K+ m7 ]6 i% b) Q2 I& ~7 d# @

     (2).@Around(“execution(

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

// @Around(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
# h/ ?. V: @0 a3 m0 ]; z( o

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

public void testAround(ProceedingJoinPoint prj,String str) throws Throwable{
, l5 d8 h. x- `/ c5 m! g

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

        Object obj = prj.proceed();
3 H3 J: j/ V+ k/ H, Q, l% l  D

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

    }
& ~; q. D; f7 S5 o  o/ B7 u

5.4.3.@Before

注解@Before在执行目标对象的方法前追加相应的功能
* d  ]: m& y* T' k1 [6 J* t

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

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

(2).@Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
1 @4 h3 g9 P: s" I# H) a: u5 s

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

2.直接引用匿名的pointcut

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

(2).@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
0 W8 D. e0 e! @5 b7 B" {# O, v

注意args后的名称与参数名相同
! y) F5 q, L1 {% i5 \; ^; x

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

@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
/ \5 ~1 y' p# T; i

public void testBeforeParam(String str){

    System.out.println(“before1=param=>”+str);

}

5.4.4.@After

注解@After在执行目标对象的方法后追加相应的功能
. b+ }$ u. w8 Q8 Z  f  B) Q

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
1 Z. a& g$ J3 q, s" e. y) v* {

     (1).@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
! M+ B5 S' G  g7 N: E$ s" q

     2.直接引用匿名的pointcut
- }3 k: r( j" X2 u

     (1).@After(“execution(* com.javakc.spring.schemaaop.Api.test1())”)
/ F/ e) X6 \2 c; B- W

@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
0 m: h6 s( U: F

    public void testAfter(){

    System.out.println(“after1== >pointcut”);
6 ?/ [/ q  Y0 X$ u

    }
. l  }( Y% _. u

5.4.5.@AfterThorwing

• 描述一下spring中BeanFactory和ApplicationContext的差别
  
  2 a8 L+ b& d4 R2 `$ u

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

& ?+ X; |/ O: i; @6 H7 G# [

• 谈谈spring对DAO的支持
  
  0 V2 B9 E7 `- O! m& t2 n

Spring提供的DAO(数据访问对象)支持主要的目的是便于以标准的方式使用不同的数据访问技术。
* W8 l! z, J* H& w

简化 DAO 组件的开发。
Spring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法，用来简化代码开发。
1 Q; d* X* `& \9 A6 h

IoC 容器的使用，提供了 DAO 组件与业务逻辑组件之间的解耦。所有的 DAO 组件，都由容器负责注入到业务逻辑组件中，其业务组件无须关心 DAO 组件的实现。
) R. P' K' S/ ^: P- w  y1 n

面向接口编程及 DAO 模式的使用，提高了系统组件之间的解耦，降低了系统重构的成本。
( b0 [5 Z4 {$ d4 \* U" G  Q

方便的事务管理: Spring的声明式事务管理力度是方法级。
& X; W: r. h+ Y% H6 G- D

异常包装:Spring能够包装Hibernate异常，把它们从CheckedException变为RuntimeException; 开发者可选择在恰当的层处理数据中不可恢复的异常，从而避免烦琐的 catch/throw 及异常声明。
" u5 }1 E1 l6 D/ [1 s( j9 t) J- e

, Q1 ^! ~- I. x% E6 b

• 谈谈spring对hibernate的支持
  
  7 g3 C1 H8 I1 V7 L) T

在所有的 ORM 框架中， Sping 对 Hibernate 的支持最好。如 SessionFactory 的注入、HibernateTemplate 的简化操作及 DAO 支持等。另外， Spring 还提供了统一的异常体系及声明式事务管理等。
8 ]4 O' ~; f5 Z3 p5 ^5 b

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

1、通用的资源管理: Spring 的 ApplicationContext 能管理 SessionFactory，使得配置值很容易被管理和修改，无须使用Hibernate 的配置文件。详细配置如下：
$ O' X' J* R! @6 I7 k$ e% ]

6 K: G# T6 J7 e. r1 G4 w) `1 P% c# ~

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

        

            oracle.jdbc.driver.OracleDriver

        
. J* H& G, }+ h6 Z; s. s) K7 b

        
+ X7 F3 f  M! l" i) F

            jdbcracle:thinlocalhost:1521rcl

        

        
- q4 c' h. u; p5 ?% s- z  _8 n' G

            javakc2
  s7 M+ @# a$ H" W* d

        

        
& h1 {1 n9 {8 T4 t

            javakc2

        

   

' I0 Z3 e9 v& f+ w. o! |3 B% c

   

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

        
5 V) T* \/ @& M# t5 B' B4 }

        

            

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

            
9 S4 J2 k7 \) F) J5 l

        

        
0 Q) a# E9 i( m: `+ x

            
* v& X/ Z. u; w3 H$ S* W

                hibernate.dialect=org.hibernate.dialect.OracleDialect
6 s/ W* R3 I5 ~+ p

            

        

   

   

        
& @. h, [5 s( ?' ^% m

   

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

   

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

        

            java:comp/env/jdbc/myds

        
- ~1 V3 o+ W' l6 Y2 C& H

   

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

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

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

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

   
/ A/ t0 G) |% T

        

   
- {  W5 f+ q2 x) e% \

   
3 _! ]7 d! U8 `6 [8 F( d

        
* }: V! q) B# y

            
: M/ n+ p0 ]3 ~, I6 o

        
! W7 A% F5 R# P' ~4 F# }1 d" o

   

   

        

        

   

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

' ?6 y; O5 Z& I+ M! O6 {( L

Spring2.0之前事务的写法 7 J" a3 b5 M; }1 Z' O! u% W ' J( V, f& c: J/ I% ]: h        class=”org.springframework.transaction.interceptor.TransactionProxyFactoryBean”   \! R; Z  L$ e1 M        abstract=”true”> % N+ l% k5 W9 C4 m * w! o% M# N1 Z  t4 ^) v                 PROPAGATION_REQUIRED,readOnly                 PROPAGATION_REQUIRED   j2 @2 }# R3 c   }7 C  D9 I/ ?4 K; c: N: ` 4 w1 m, G- R8 b' U% b

• 谈谈Spring对事务的支持
  
  1 w& K+ ?, F; P8 i

1、声明式事务管理：

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

2.做法：

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

2.2

2.3 注入数据源

; a0 I- n2 Z% [

6 |$ v8 Z# {) Y- \- M9 b, J
7 {) F; Z+ N3 ?0 O7 O( ^" k

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

- ^0 ]# R$ Q- n, ]& J! E( X
6 x8 }, t8 |3 M5 X5 w( i& g9 F

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

7 j# }; m, E; H  L- T

2.6 定义切入点

' l4 o0 }/ ?- v! e3 p$ z5 n
5 Z) R; t+ N& L' w: \9 r

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

1.注解@Transcational

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

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

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

* N* [  o+ {8 @8 o+ P

如何在Spring中使用Hibernate的事务：
$ `' X7 g  F* A" i

) r- _7 ]7 l2 p9 D

如何在Spring中使用JTA的事务：
' I& L  P7 K4 s

admin

事务
ACID
（1）原子性（A）：一系列的操作具有不可分割性，要么成功，要么失败

! {( j" S) ]7 k; g# Y6 j. T, J0 z（2）一致性 ：操作的前后满足同样的规则，保持平衡。
9 C. x$ _) {! `0 p
* B  I7 h( x8 X( Q& y（3）隔离性 ：在事务运行的过程中。事务内的数据对外的可见性和可操作性（必需由数据库的支持）

（4）稳定性 ：保证数据在事务的操作的过程中不会遭到破坏，而且是永久性存储的

& w$ i! B/ O' @. j5 p0 }

9 O* j7 ?6 x% ~2 z( d- l事务模型
（1）经典事务模型又叫平面事务模型（JDBC） 事务不允许嵌套

( u8 a) Z4 Z8 Z  X+ L2 B. V' T（2）嵌套事务模型
) M4 X; V3 z0 B) q5 I

2 e) ~4 {9 I' L- q9 y3 U3 S
6 ~! ~* M. ~( `事务的两种方式
（1）声明式
7 o5 y2 O3 i  _
2 e. j; u3 O! r在配置文件中设置以下6项

6 _& a8 a: i* ?* X（１）.required
  L  S$ c/ q$ g. p) P3 z
如果客户端没有事务　在bean中新起一个事务

/ Z( D& R- g% k* ]如果客户端有事务bean 中就加进去
" Z! i4 l8 n! D5 ~  f& p
(2)、 requiresNew

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

( m4 {/ T, P# X' g) K6 U) R如果客户端有事务就将事务挂起

* S) f4 f9 t7 g3 c: j7 M8 D(3)、supports

( O1 _9 m; J# v7 G如果客户端没有事务服务端也没有事务

4 d2 k8 u3 u( v$ H" A3 p# Y如果客户端有事务服务端就加一个事务
& \# H: j$ p/ q% C. @+ p, j+ K% e
2 R0 p2 |+ Z2 D(4)、mandatcry
. V' u! e( y& E. l
& V3 q/ V- g4 ?% l+ p如果客户端没有事务服务端就会报错
! k* U( |8 H5 ]% D7 l* k
7 _% S0 U& C( ~+ c2 D  K如果客户端有事务服务端就加事务
. m5 r8 U6 b: I/ I$ Z! x  x
- ]4 @+ p9 ]/ E8 g2 _& {) Y4 n(5)、notSupported

9 p5 \0 x5 j! r, }8 t) C不管客户端有没有事务服务端都没有事务

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

& d- Y# M! c# V8 L9 Q  F(6)、never
+ K: Q3 `9 z. v! h- R6 }& r% U
不管客户端有没有事务服务端都没有事务
& q  Q, ?# A9 l# t/ Q# q0 a- w
如果客户端有事务就报错

（2）编程式事务
8 W# D  s. t; t6 [" t6 x
8 z" k* Z( h) j* i& B8 p3 FJavax.transaction.UserTranscation

JTA 事务可以精确到事务的开始和结束



事务的隔离性
$ Y/ F. H. ?6 N6 D3 lRead-uncommited
# O5 i1 R( A0 o; l" O
) y( h/ j) I/ T9 r读取未提交的数据（基本上没有锁）脏读，存在不当读取的问题。

- g9 w6 M' R  D/ [$ o" E* V' D$ V  {Read-commited

- q3 e  V- `' D0 i. _( n读取已提交的数据（行级锁）
" i5 `$ d" M6 X' z3 i
无法读取已经写入，但没有被提交的数据。
1 }: B+ x  C; b) A% j  k! V
1 t" Z3 g% e4 q9 kRepeatable_read

2 G  N+ N4 h: q5 k! |5 _* b8 I读取的数据不允许修改或删除

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

Serializable
" j+ I; q$ W& f' _. J" z
幻影读（表级锁）
& p% h; X: O, m) u1 X. Z/ x


; g. ]& y8 V7 Kstruts
开发流程
+ Y0 N5 p8 Q' P0 O8 E
$ Y# M& G* |$ d! f5 Z, C1、创建表单
9 @2 r2 G: X$ A* v4 ?7 B5 Q
, ]+ F4 C. U1 |2、从表单中获得输入

3、处理输入（业务逻辑）

/ _2 z( ]2 l, A4、根据动态输入改变输入流
0 k/ t9 P* ?6 |! g/ J
要完成上述四步，我们需要创建

1、一个ActionForm
2 z8 l; k& b' N3 A) j, p& u( @. C; C
2、一个action

3、一个配置文件struts-config.xml
1 O; m5 |; Z' J9 @3 Y( r. H3 \9 B/ z
4、创建页面
! A; Z5 {# P; j" u# i
创建ActionForm

# G+ \% ~, G  j; N" J1、写一个类继承ActionForm

2、私有的属性

3、相应的get、set方法

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

创建action
$ z. d4 y# A8 }
1、写一个类继承Action

3 O& P0 l+ C. z8 G2、实现一个公有的方法（回调方法）
- I: i: K3 w# e( c- u% G5 k
5 a& o5 O% ?9 g3 v* K2 `public ActionForward execute(ActionMapping mapping,

ActionForm form,

  e3 p( ]% `+ ]! ]2 IHttpServletRequest request,

HttpServletResponse response)
! x- w( s) s# j, c
2 a0 A- }4 y9 u* d7 _9 q, y: m3 ?1 p{
! [* Q( n1 i) J. {1 _
//1.收集参数
/ o7 O3 z4 f" f+ l
8 q4 k) A' Q0 |% N% R! W& pMyActionForm myForm = (MyActionForm)form;

& w% W& q1 ~# P& f6 L+ N% T//2.组织参数
" X( B, T  p& k& D
/ M) Z' Q* v. v' _4 e9 X# }

//3.调用逻辑层
/ b9 Q. H# p9 X; k* E4 @7 N& e
9 y- S4 e5 T" O/ O7 ~boolean flag = true;

//4.根据返回值来跳转到相应的页面
, U- `: E5 s: k; z; p
ActionForward af = new ActionForward();

if(flag){

af = mapping.findForward(“1″);
# H% t' ]2 a: m3 c! r# d9 |6 Y
# R0 q: z* ?9 S1 h}else{

2 _2 x" {$ W  Z$ u/ D) j" }af = mapping.findForward(“2″);

}
. }; Q" n& X8 E, L% J
& X+ L+ W; P0 V2 q- c$ l# q/ J. j6 B; Wreturn af;

1 D; q% w" \9 s# Q4 N}
$ f( K( {6 p9 S0 J$ l0 X
配置struts-config.xml文件
+ L+ A6 E' S( T/ q, N1 g+ Y, Y
1.<form-beans>

<form-bean name=”myActionForm” type=”全路径.MyActionForm”/>
0 X+ B8 s$ T1 B* k6 F6 c; Q
9 e8 S7 ~  ~" a2 ?$ f5 l9 |<form-bean />
% _/ i2 R& Z5 ?7 a1 W& S) }2 F
</form-beans>
5 p3 A( x0 T/ E! x- C
2.<action-mappings>
" d4 d/ Z9 ]7 p. P7 A
<action path=”/sll”
3 b1 Q6 a: X: f! g7 a* y! w
name=”myActionForm”

type=”全路径.MyAction”

scope=”session”

6 W  }& T) y8 F/ J! Z5 D) A' Zinput=”错误返回的页面”>
/ V% ]$ ]4 V) @4 ]1 o' [/ r: n+ O
<forward name=”1″ path=”/1.jsp”>

4 y5 _0 E+ v' m9 H8 G<forward name=”2″ path=”/2.jsp”>
! k$ B& i/ y! X. w4 R& S/ Y2 z
: c' [& p. H. K- q( O* t</action>

! }  C; U2 P5 U: V( f</action-mappings>
* V" y, \( B0 {$ K! K* ^" \, ^5 r
步骤:

9 O. |' l# m8 ^5 c. N  f/ d1.创建一个空的web应用

9 A6 z& V: m- x4 {) U* H$ Z; T2.将struts的包放到lib文件夹下
# O- N8 p1 W% t: p9 }2 `7 e8 ^
% e& M/ j9 p- H. i7 f1 m3.将.tld文件文件和struts-config.xml、web.xml放到WEB-INF的跟目录下

4.配置struts-config.xml文件和web.xml文件
; C4 ]1 M6 `6 |3 ~0 i, b4 [
5.在页面引入tag文件uri
: }) p) r% ~' i9 z
STRUTS运行机制
% `( C* B! n1 j' q; o# }
0 |; m3 A; P2 G, P1、界面点击产生请求
# V7 Z6 o+ L! {, z( f
2、容器接到请求

3、匹配web.xml文件中的*.do来调用ActionServlet
8 ?) o# s- b, q' x
4、ActionServlet的处理
% w4 j9 S- e3 t4 W4 \
; g, E$ D) g2 r4.1 读struts-congfig.xml文件形成ActionMapping
/ \  _7 _: L. G7 m  z
4.2 通过path 来匹配Action类，通过Action的name属性来匹配ActionForm类

4.3 通过反射机制来给Form添数据

4.4 由ActionServlet转调Action的execute方法
0 `" o# o/ Q! c) Z
4.5 得到execute方法的返回值，跳转页面

4.5.1 RequestDispatcher

4.5.2 response.sendRedirect(“list.jsp”);

/ L, p0 g' B4 T- }  g

进入execute方法
$ s1 a3 ~) T2 j* s
1 收集参数

2 组织参数
# d  X$ V! c/ B0 y( C! d' H& `
3 调用，逻辑层

5 Q5 ^% N+ J8 G' U/ q4 返回值

7 S9 O' T9 {( B, j4.1 选择下一个页面 （ActionForward）
; W$ v3 m" L* `8 n- N+ N( m
4.2 把值传给下一个页面

5 M4 F& \! g* K8 g- B+ k0 @. e3 m
: L. P6 D7 Y8 y5 D; t
比较struts和struts2的不同
: j$ \; C2 M  r% w
3 P5 {! q" [1 W, M( mStruts
! h9 M2 h$ l& K1 W, p5 o' T/ a
Struts2
! N$ ~+ k5 }/ w0 C, G: T8 _
组成        五个部分：ActionServlet，ActionMapping，AtcionForward，ActionForm，Action        十个部分：AcionContext，FilterDispatcher，ActionMapper，ActionProxy，Configuration Manager，Action Invocation，Interceptot，Action，Result，Taglib
  g5 k9 C! T5 }) ~url        .do        .action
分发控制        AtcionServlet        FilterDispatcher
! m9 {- B- d( x0 ]# y收集参数        利用JavaBean技术，将数据封装到ActionForm的子类中；
一个Action对应一个ActionForm的子类

使用拦截器将数据封装到值栈中。
# x3 Z# e$ _( S7 b" F使用域模型，一个Action对应多个值栈中的Model
9 Y* P. B  o+ @% E& n# i: K
7 L, Y7 t# a2 {% [1 ^8 i6 ^读取配置文件        ActionMapping        Configuration Manager
拦截器        无拦截器        执行Action前后有拦截器
返回页面        将字符串封装到AtcionForward，进行跳转页面        Action中直接返回字符串，通过Result跳转页面
页面跳转方式        两种：dispatch，redirect        三种：dispatch，redirect，chain
值栈        无值栈，Action通过在request范围内设置属性，向jsp页面传递数据        有值栈，Action和jsp页面通过值栈传递数据，jsp页面通过OGNL取得值栈中的数据
7 J2 Y0 {! K7 T+ V: r3 P8 \配置文件        struts-config.xml        struts.xml
1 S1 t* d" d3 i/ c  j  S/ o中文问题        不能解决（需要使用filter）        可以解决中文问题：
& }3 @6 ]" W) T' E  ]1、在jsp页面添加Meta；
( v1 r: ]- W0 e1 W
2、修改struts.properties中的设置。

admin

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

一、配置ant的运行环境
3 _& a1 o/ B8 ?" Q) ~6 O
1.将ant的bin目录添加到path中
$ C4 n5 E0 g, B
! x/ U" R8 L# K. @$ _" D2.配置JAVA_HOME

3.配置ANT_HOME

8 ]7 \( k8 ~) X8 {& x二、配制build.xml文件，该文件放在应用程序的根目录下

' ~. D+ z2 D3 y0 |$ T编译java文件
3 O* j+ b6 p! N) ?/ x8 Q1 \$ e' p5 ^
执行java文件
% A2 U( l/ S4 N" @
, ~. n& W: I9 n8 f' p& p( H: P* C% icopy

% w8 ?  e2 v. K% r) Z: h删除
' @. x: y# \4 ~  E, p9 O7 w- _
打jar包
, p; M; b7 j& z4 V, R# V; ~; K
" ~! y% B# {  n" i. b3 q, K根据注解生成配置文件

' a. b+ q/ N8 \Xdoclet
通过注释生成一系列文件的工具（txt、xml、java、html等）

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

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

1.1 在类的上面 写与表的对应

( p! A: B) e6 n, U/ t1.2 将每一个属性的注释都写到get方法的上面

2.在ant中引入相应的task来驱动xdoclet



log4j日志管理
1、是什么？

在开发期间用来测试、对整个日志信息进行管理的工具

2、功能
- ^! U* a! u' ?4 F
1.控制输出的目的地
' T3 l( C8 y$ V. O- Z  q! S( L- x
2. 控制输出的格式

3. 控制输出的级别
7 Q) W8 b; j2 T& Y$ y" G3 t+ z
& P2 V' u- V9 ^8 Q7 c# ^3、日志的级别

1. debug 调试

$ _+ l& j$ g, v0 K3 v( G# W2. info 给用户的提示信息

3. warn 给用户的警告信息

0 v: ~- v! q# Q9 ?! J4.error 给程序员用来调试

Debug—-〉info—-〉warn——–〉error
7 h- i; ?% e; `, L( E
4、配置

1.配置级别

2.输入源 （控制台和文件）
6 Z1 c# o6 `9 L2 F0 o
3.可以进行分包控制
3 {7 M0 \6 K3 J* E6 c( V6 `! }
Log4f.logger.包结构 = 级别
, \; y: r+ ~5 d' e$ i* I9 u. m
& o4 N/ ~  x3 q7 g5、使用
: H! E: }3 S% |+ P( R
Logger log=Logger.getLogger(Test.class);

    public
; C$ g# V- I' M0 C9 n' [void t3(){
1 l& E* a2 O: h  l+ Y# V
        log.debug(“this is debug”);

' O( F7 i1 x' f, _# u6 m- n0 u        log.info(“this is info”);
+ D/ c* ?- c0 \  Q6 D
        log.warn(“this is warn “);

- C" z  j4 G3 K4 m0 o        log.error(“this is error”);
% P* b/ O; e, s: g$ l, ^0 f
- J0 ]& t7 `$ g9 d  Q    }
# z# q  l$ L8 D/ m7 c
7 c/ x3 P# g/ H+ ]9 L5 X  ~' b' XJunit
! a$ k  [  A1 y1.是什么？

1 }  P& [5 B$ [0 X0 T7 s+ O单元测试的框架

2.怎么做？
( K* i5 p8 H6 O) w9 I3 ?- N
+ c% Q* ~! K' o7 R6 ]6 o) n写一个类继承TestCase
, k  e% r! M) J6 _% B
测试的方法一般都以test开头并且没有参数
' V1 m( J$ \) E" M& O5 |" L
% x" y$ h! n' i* {在测试方法前执行的方法public void setUp( )
9 u0 n0 ^6 @5 ^' O
2 M4 H' ~7 q" |/ R" R* ~在测试方法后执行的方法public void tearDown( )

% B1 o% L8 I. D+ d( S* Zerror和故障的区别

error ：代码有问题
- l3 v9 f1 P( A0 ]/ W+ b
4 `8 y7 L9 y$ ]4 G+ h故障 ：逻辑有问题与祈望的值不相符合

. D. p# h6 v# q; {$ ]) P1 b" b) m生命周期
. u3 ]6 R7 ~7 l
测试—〉SetUp（）—〉testXX（）—〉tearDown（）—〉结束；
# x8 z" I* I0 x+ ?# ]7 z# \
TestCase套件

7 w0 d$ j& k+ z4 [% {public class MyTest{
) W/ n8 h% B) ]& y
        Public static Test suite(){
8 ~( a% e, Y( H) i; D$ Y' _
TestSuite suite = new TestSuite();

0 `, R3 d: m0 b5 e( Y2 `suite.addTestCase(Test1.class);

) r9 h& ~/ _2 ~6 d4 a, Bsuite.addTestCase(Test2.class);
3 q  d# h7 G- t0 ]5 W1 C
}

6 j7 w  s$ Y' F0 [6 s" Y/ w+ k}
4 [; |- l( b- i3 H0 z
% W  N+ D4 E7 B& n5 u8 S( j' W6 [% r/ q2 l
1 M" W: ?  @4 P+ Y8 F: x% E& e
. \; _  C  Q3 c. XAjax
是什么？
AJAX即“Asynchronous JavaScript and XML”（异步JavaScript和XML)。是一种创建交互式网页应用的网页开发技术。
" ?5 z2 U' u  b1 Y
无刷新页面。

/ H" q  a& v+ `) L有什么？
AJAX是多种技术的综合，包括JavaScript、XHTML和CSS、DOM、XML 和 XSLT、XMLHttpRequest。

4 N2 U) A3 X0 _( S3 z能干什么？
9 Y8 C! W+ ]/ S! e7 L3 H0 d* a使用XHTML+CSS标准化呈现；
使用DOM进行动态显示及交互；
使用 XML 和 XSLT 进行数据交换及相关操作；
使用 XMLHttpRequest 进行异步数据查询、检索；
- V) s+ h# m; B/ k9 V) D7 m( W. |1 R使用JavaScript绑定和处理有所得数据；
, U4 B% R' M# Q9 F8 M- L
传统的web应用允许用户填写表单(form)，当提交表单时就向web服务器发送一个请求。服务器接收并处理传来的表单，然後返回一个新的网页。这个做法浪费了许多带宽，因为在前後两个页面中的大部分HTML代码往往是相同的。由于每次应用的交互都需要向服务器发送请求，应用的响应时间就依赖于服务器的响应时间。这导致了用户界面的响应比本地应用慢得多。
( G' d% P6 Y$ [0 |# x  r: i
与此不同，AJAX应用可以仅向服务器发送并取回必需的数据，它使用SOAP或其它一些基于XML的web service接口，并在客户端采用JavaScript处理来自服务器的响应。因为在服务器和浏览器之间交换的数据大量减少，结果我们就能看到响应更快的应用。同时很多的处理工作可以在发出请求的客户端机器上完成，所以Web服务器的处理时间也减少了。

使用Ajax的最大优点，就是能在不更新整个页面的前提下维护数据。这使得Web应用程序更为迅捷地回应用户动作，并避免了在网络上发送那些没有改变过的信息。
/ q2 {& T8 F0 b8 y
对应用Ajax最主要的批评就是：
3 p' N: `+ ^& Z0 h7 i- D1 它破坏了浏览器后退按钮的正常行为，就是用户点击后退按钮后不能看到之前的数据；
( d2 K3 ~0 T4 [# S4 p! Y2 一些手持设备（如手机、PDA等）现在还不能很好的支持Ajax；
$ N% W( |/ h* q5 f8 k$ z3 用JavaScript作的Ajax引擎，JavaScript的兼容性和DeBug都是让人头痛的事；
4 Ajax的无刷新重载，由于页面的变化没有刷新重载那么明显，所以容易给用户带来困扰――用户不太清楚现在的数据是新的还是已经更新过的；现有的解决有：在相关位置提示、数据更新的区域设计得比较明显、数据更新后给用户提示等;

$ l7 v. b2 r+ l; h, X. B; p怎么做？
5 ?" {$ ?2 ?; h2 ?3 C5 u( B, v$ H<script language=”javascript”>
8 d3 s- o, ~  |9 `
4 F7 P% x9 V8 h! D, x1 r& X1 Fvar req;

function add(){

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

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

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

req.onreadystatechange=manage;
' V7 {1 K, I3 f9 r$ k3 B, o7 O! b
//2:准备传输的内容

var str=”test1111″;
% c* t$ S3 O9 w3 d; N+ o7 j0 ~3 H
1 d1 B( N5 H6 A  B' ^- q//3:发出请求

  P+ l" p  n4 z8 Sreq.open(“GET” ,”/others/ajax/test/t2.jsp?str=”+str);
0 e# |7 [$ e4 v8 ?" h
3 e: x: i' v8 nreq.send(null);

1 i1 w  M6 R, c7 Y+ ?}
: U# I  e7 x; g4 `$ `
//4:接受返回并处理
# |5 R7 G5 O" d; B7 d
" A; p+ q# \. {/ rfunction manage(){
5 Q* S8 I' i7 Y; |% E$ b
+ |6 q1 B- x5 a* ^if(req.readyState==4){

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

6 i! J8 d1 _; i5 T5 w  X% S( }( f}

6 S4 J" k7 A2 L. i# t0 R, R  Y}
: T9 A7 c: q  `* v  [  D* u. q3 F  J
</script>

readyState的取值如下：
& O2 M9 z4 w- J1 z: C) c1 U% A3 m" ~
# C( }$ e2 p! B3 B　　0 (未初始化)
( w8 W9 F* p9 C: T( O, d- m
" P) b/ J" k6 I  Z. L% w. [6 \# v　　1 (正在装载)

　　2 (装载完毕)

. u- L% R' L6 r　　3 (交互中)
# C  f$ ?  |$ s
- q8 ]8 r8 a/ K* h( {. h　　4 (完成)
; c7 K! A5 B, I0 D$ T; H5 A* {2 j
" o3 g: q, J* H4 B$ h
$ b6 E$ t( E9 o7 y- g, B9 T
- w0 n1 }3 s4 b1 Y2 W. A原理
Ajax的原理简单来说通过XmlHttpRequest对象来向服务器发异步请求，从服务器获得数据，可以是xml格式，也可以是一个字符串，然后用javascript来操作DOM而更新页面。

Dwr
是什么？
- |3 n; A3 n. J& l5 |3 fDWR（Direct Web Remoting）是一个开源的类库，可以帮助开发人员开发包含AJAX技术的页面。它可以允许在页面中使用运行在WEB服务器上的JAVA函数,被调用的JAVA函数就像是在页面中JavaScript方法一样。
/ y) z- _0 ~- z2 s" s
7 Q3 p! P/ _! N有什么？
4 \/ c+ O& a& t  t. o/ S( V7 a  f: W它包含两个主要的部分：允许JavaScript从WEB服务器上一个遵循了AJAX原则的Servlet中获取数据；另外一方面提供了一个JavaScript库可以帮助web开发人员轻松地利用获取的数据来动态改变网页的内容。

3 L2 q1 s  Q# m
% h3 s- b0 _6 i/ j  h/ M
. ?7 P% M+ X0 P1 ^+ z2 A/ F能干什么？
+ O+ ?3 J) x/ Y+ f4 q7 t% L6 o动态地把java类生成为JavaScript，感觉调用就像发生在浏览器端，实际上代码调用发生在服务器端，Dwr负责数据的传递和转换。这种从Java到JavaScript的远程调用功能的方式使DWR用起来有种非常像RMI或者SOAP的常规RPC机制。


" k4 o5 L1 O7 x7 y! a
怎么做？
① 编写配置文件

web.xml
* T; {% X& \9 S; z
<servlet>

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

<servlet-class>
8 a1 Y5 f' @2 V' i1 `
org.directwebremoting.servlet.DwrServlet
3 @: R7 }) T7 m/ H. |, R
" f- F8 B. w' V1 I5 H. k0 F</servlet-class>
4 V! W  Y" n$ ^; J' e! U$ ^
<init-param>
4 ~0 N' G) G( F+ P1 _# Y& G( G
( [% k4 I5 ^* w/ n& ?<param-name>debug</param-name>

0 m0 R. w: M: i' |, a0 z: h<param-value>true</param-value>

</init-param>

</servlet>
5 \7 J- Z. o* A* l
<servlet-mapping>

( T/ _, Y: H6 r  m2 v* D" ^<servlet-name>dwr-invoker</servlet-name>
, F0 f: f& \+ W0 U2 \
/ K1 E/ W* g% M<url-pattern>/dwr/*</url-pattern>
/ ]" H3 L$ P9 \- t
0 c* Y: f$ q( D0 v5 a* }; E</servlet-mapping>
/ i% c+ g! w+ W% {
dwr.xml
- W: g/ d, \- q; e, O% k+ H
<allow>
' p" ~( l9 M0 ]4 ?
* v5 d5 J/ P9 x+ A9 l, \8 l<create creator=”new” javascript=”kc2″>
: p, D& D9 X5 J6 {
<param name=”class” value=”dwr.Service” />
$ I- R( I+ K6 w) v! a
, N% K2 T# l  `8 ~' c9 t  m& \</create>

* c' f3 }0 u3 `' S* t</allow>

②编写service
# ?# j' X& P3 B
6 s2 g) m+ A  L, Qpublic class Service {
( p" I  E' w& r1 N
public String sayHello(String yourName) {

8 y7 V) U- u# d6 a( Y; P9 ?//可以是访问数据库的复杂代码

  ~: ?7 A9 [. G4 e( d% S  ?. areturn “Hello World ” + yourName;

& }& U+ O0 U& m7 l. h$ q+ G4 e}
: U4 }& A' s: }' h
- _* j, n8 i' @- t, a+ x}

) k: @' _) Q: ?. T③测试DWR
2 v8 j# I1 H$ Z6 I7 O8 L6 o
将代码放入应用服务器（比如Tomcat），启动。

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

& I# ?( g+ ]7 P$ R④编写jsp页面
" |& J; p2 ?% r9 p* e
& G! s( {- F/ G$ K1 F% D1） 要引用3个dwr的js，其中engine.js必须要，如果需要用到dwr提供的一些方便的工具要引用util.js
( I/ L& ]. ?0 `2 i
/ p' G4 C' Q; p2） 然后还要引用dwr自动生成的js，dwr/interface/service.js，注意js名字要和dwr.xml配置的一样
! `9 v$ Q- z4 P4 \3 V& [0 y: Z
, f8 ~. U: F/ \3 K+ P8 X3） js里的service.sayHello和java类的那个有一点区别，多了一个参数，用来得到返回的数据