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

admin

JEE
/ P+ T% J. h8 y; B1 m" U简述JEE
+ Y$ f. Y: H$ Y2 S/ t8 Y- [9 D$ nJEE　： JAVA　 PLATFORM　 ENTERPRISE　 EDITION

JEE是一个规范集；

JEE是一个框架集；
+ \* P' [1 B. q- o9 u$ s
JEE是一个技术集或API集；
: h% e% g' q: Y
9 ]% K. R7 P3 E适用于创建服务器端的大型的软件服务系统
9 ~/ F1 O" T- Z2 a: h/ u$ H  H
7 V: J1 f7 c! L) w* e

C/S B/S 模式
C/S client/server即客户机/服务器模式，客户端也参与程序的运行与计算（富客户端、胖客户端）
' J% ?, i& X' v; _+ s' K: U+ n9 G4 B
3 y& j; F( y; \# z0 p0 G/ SB/S border/server即浏览器/服务器模式，又称为瘦客户端，客户端不参与程序的运行与计算

) b0 M  p# o  ]- @* A( _
. H5 E+ Z7 t: R& p$ L
企业级应用（大规模的应用）的特点
1.生命周期长、稳定、可靠

2.组件往往分布在异构的环境中，能够跨平台

3.维护性、扩展性、重用性
8 B) `0 k) Z6 n( C; v
" D7 B) B+ E& ~( P4.有事务、安全、线程


/ v( U3 [1 h* j3 w
什么是业务逻辑？
依照业务逻辑划分模块，

; S1 A  X; T: U2 P( l* l所谓判定业务　就是具有以下特征：

+ R4 z' s7 N9 u& S1.业务流程

0 ]2 }! j; L% |! a+ t4 f. d. C4 p2.业务判断
8 ]! r1 a' |6 ^7 ~) n
9 m0 N" j% E$ c, B2 X3.功能组合


: _! _) p+ L3 B* v8 ^
平台（角色）的划分
) j5 _! S% m4 K" {( n! [1.平台供应商。提供满足API集实现的厂商（BEA weblogic IBM webshphere）
' x2 K' s8 B! S* U% P" ?
0 C3 z# u' m! L2.组件供应商
& i7 U# n, ^% w; |
; `+ s' `0 m0 {3.组件装配人员

( m9 I6 s0 ]( v6 K, a% ]# ~3 h7 v4.部署人员
0 @, L, t  n8 o
. ~5 @+ {* @1 l/ t" N& H5.系统管理人员

; g: n1 |# t! S- B) d6.工具供应商 提供开发组件所使用的工具（Jbuilder、eclipse）
$ P" g1 ~; j4 o* S9 C
2 A6 P7 A0 t0 x: z4 S
6 v) U# ~' r) |
java技术分布（设计架构 模块内部设计）
( u) @% c; J6 i0 C+ N+ n( F. P) n  U2 Z1.表现层 Servlet、 Jsp、 JavaBean、 Taglib
6 Z; p/ B( N7 Y. \3 u
* ?4 ?5 T. W1 D, h) `1 p2.逻辑层 EJB(SessionBean)

3.数据层 （　JDBC 　EJB（EntityBean））

4.服务 JTA（JAVA事务架构） JTS（JAVA事务服务） JAAS（JAVA授权与验证服务）
+ {& t( W( \' _- d
5.分布式通讯 RMI（IIOP）+JNDI 、JAXP（JAVA 的 XML 架构）
- c" s3 ]. f* E& _- t8 U
JAVAMAIL（邮件服务）、JMS（消息服务）、IDLC、JCA（JAVA连接器框架 （成））
; z: ^) F! `; q7 P+ L

9 G" t$ G( [- ?9 t. ^
JEE的体系结构： 是一种组件的体系结构
) V" N1 P4 U9 @5 q& g( o1.组件 ： 能够完成一定功能的封状体（独立的功能的集合）

5 ?9 u, y/ L0 x不能单独运行，必须运行在容器上
1 J: e! M& }9 a* z1 D
$ s9 [. e, \9 d6 r+ \( u5 u" f# E分为两类：web组件、ejb组件
3 b8 v5 E' T) C
2.容器 ： 提供组件的运行环境，并对组件进行管理（一段程序）

8 R! `6 G' R) L6 u管理组件的生命周期

  I" J3 P, X7 P# T5 h不能单独运行，必须运行在服务器上
5 d5 [7 [( x: {- n8 O) l
程序（组件）通过上下文来调用容器（context）
+ {, Y! Q4 Q5 C
组件通过web.xml向容器描述自己，使容器能够认识组件
" j/ V  p9 ^- O+ Y* o
容器通过回调方法来调用组件

0 p2 R* e' z- l0 v  T: \2 z8 M6 V分为两类：web容器、ejb容器
+ P) j! C1 p8 a' w4 o
3.服务器 ： 提供容器的运行环境，提供大量的JEE基础服务
$ ^% X: C6 v, n* o5 U6 ]7 h
. u3 h) I3 s+ @# b4 _web服务器（只提供web服务）
) x# ^) S3 N6 ^+ L1 K+ h+ P
! v, ~, `1 T; z+ o" a7 R+ O% P6 c2 @jee服务器（提供web、jee服务）

7 m1 X$ N% O4 b  y8 D) A% ~  K/ f

* e- s' t3 [* Y' R: M# M( @7 f2 u什么是回调方法
# C) `" v0 D* N( _4 ^2 P9 }# _由容器自动调用的方法，就叫回调方法。
! U8 H, ?! X/ v0 }0 @; a

9 u8 N4 o, ?: M1 t  s* ?
  K: A& J& ~# h  e) o5 DＲＭＩ远程方法的调用机制
例如：Ａ主机有Ｂ（）方法，Ｃ主机有Ｄ（）方法，Ａ　想调用Ｃ主机的Ｄ方法


4 w+ m7 ^3 i) e
' Y4 X: D7 ?  J) C, p& g. h  b1 j6 [0 q, v

# k" F, S8 O7 i' y学习方法
1.规范（熟记） 2.熟悉API 3.多练 4.多想

admin

Servlet
) ]% E  t2 A0 N& B$ q0 D

•     描述war包、jar包、ear包的结构
  ) N$ s( l8 N0 {; \) s* V- |; I
  
  8 u6 E2 d# a. \% v9 ^

war-                            web文档压缩包

—WEB-INF

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

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

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

jar-                             java文件压缩包

—META-INF

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

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

–META-INF

—Application.xml 配置文件

–*.war

–*.jar

& C, h  S3 o5 Q3 y

• 什么是servlet？servlet主要做什么？
  9 j2 c. A$ N" ?; B
  0 G) Z8 m1 N3 J1 K4 b
  2 h3 _/ Q  R7 ~& X8 H- g

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

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

6 l4 {; T; ?( Y; N' T* c

• servlet 与cgi相比的优点？servlet的缺点
  
  - x# u# [" W+ W" L: e
  5 ^; x+ U! W- P- }& b

优点：

性能（线程比进程更快）

可伸缩

Java强健且面向对象

Java平台独立

缺点：

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

& F2 x" G) ^) [8 R4 {

• 常用的servlet包的名称是？
  
  
  ( r- h! D( M0 s

javax.servlet

javax.servlet.http

% K+ `/ T/ O- v' ]

• 描述servlet接口的层次结构？
  
  - }% |: x/ Y+ J: S" C/ M+ F1 A
  / p- C1 Q& j/ B" v  U8 Z9 f, `

Servlet

–GenericServlet

–HttpServlet

–自己的servlet

ServletRequest

–HttpServletRequest

ServletResponse

–HttpServletResponse

• 对比get方法和post方法？
  
  
  ; @5 J  L, \: N: F' O

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

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

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

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

5 R, t+ T1 z0 b  |- E# t: p

• 归类描述HttpServletRequest接口都完成那些功能
  
  
  ) J7 E* O3 \; C# }# D
  • 读取HTTP头标
    6 V5 v; I- p3 a+ P! C4 O4 O, b
  • 读取cookie
    
  • 读取路径信息
    
  • 标识HTTP会话。
    6 ]6 L& L2 r; i) b/ V$ o
    

• 归类描述HttpServletResponse接口都完成那些功能
  
  ( \+ e0 M& b/ P  {1 ?
  ' H' ]* l) v# `$ Q
  • 设置HTTP头标
    
  • 设置cookie
    
  • 设定响应的content类型
    
  • 输出返回数据
    
    

• 描述service方法所完成的基本功能？默认是在那里实现的？
  7 H1 y, A/ r+ M/ s
  2 h0 l+ i/ R: H) r
  " L) m& C6 V& \- e

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

实现：默认在HttpServlet类中实现

• 如何开发自己的Servlet？描述应该做的步骤和每步需要完成的工作
  
  " i5 N* O* b) l; \* q
  8 d  y/ L& X/ v; y% G

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

' h8 [  o! _5 A

• 为何servlet需要部署描述？
  
  
  # O" Y1 I* A6 [

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

• Servlet基本的描述应该是？请写出来
  9 w1 q, A8 S: ?4 d
  
  ; ^- f9 Q6 K# k7 w. }% c$ g6 a' u+ R

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

0 G3 N3 [- k0 _' y6 V& ?3 x

• 如何在html中使用servlet
  5 b2 [& U/ n5 e6 p) A
  7 E6 @5 q& M; D" r, w8 d( T
  

FORM标记

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

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

语法：

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

{HTML form tags and other HTML content}

</FORM>

• 如何接受request中的参数
  
  String userName = request.getParameter(“userName”)方法
  3 P' T: |! u! u( y4 H4 F' {
  2 i, Y$ s4 P( W' e% R' J; c7 R

• 如何接受request中header的值
  9 s# p% ]. Y6 `& Z" J! o& a
  
  

request.getHeader(name);

request.getIntHeader(name);

request.getDateHeader(name);

request.getHeaderNames();

• 如何输出html
  
  ; l4 E1 E4 R- c, n
  3 P0 m  f; B: c3 K

PrintWriter pw = response.getWriter();

pw.write(“<html>”);

pw.write(“Hello”);

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

5 F8 l7 `) d1 u( F2 h

• 如何设置输出的contentType
  
  * Y5 h9 w1 V$ M' P
  

response.setContentType(“text/html”)

• 描述servlet的生命周期？
  + @% V- \( X" S- w
  ! P" d- `; K3 f" S: x  p9 k8 Q
  

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

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

• 描述init,service,destroy方法的功能和特点
  ' w" k% X" T. m9 g
  : U8 U$ Z3 o) l- A3 M
  

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

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

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

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

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

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

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

5 s$ I$ D/ v3 Q2 |' B

• 什么是回调方法？有什么特点？
  
  - U% u9 C- Q$ }
  

由容器来调用程序的方法

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

• 如何设置初始化servlet的参数？
  
  在<servlet>中添加如下配置
  / V% ]7 J* s, u3 ^+ `" ~
  9 ~# Z0 h! ^3 l* E! K. V

<init-param>

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

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

</init-param>

7 F7 L; f% L  m8 ~7 e* K

• 如何获取servlet初始化的参数
  
  7 P! I4 S) U! i' ~( `9 O0 d7 A& u
  % Q& H5 D- m- L' s1 N& F- m/ L% g7 u  A, @

public void init() {

greetingText = getInitParameter(“greetingText”);

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

}

• ServletConfig接口默认实在那里实现的
  # j" \% y) |( X# V9 c# v
  5 l/ J! A9 w, n8 Q* Z, t
  * F& p8 F6 @7 `& V" Z9 A

GenericServlet类实现ServletConfig接口

• 什么是ServletContext？有什么作用？
  & b# L" l2 K/ e: A( R1 J2 J
  
  ' V  {& V8 ~& F; L, y2 U

Servlet上下文

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

1 T4 r2 r$ z7 L

• 如何访问ServletContext接口？是在那里实现的？
  
  
  

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

GenericServlet类实现了ServletContext接口。

" A# @' L/ a' u( Y& a

• ServletContext接口的功能包括？分别用代码示例
  # }( W0 B. b# m
  . }3 j  \8 o/ Z0 v7 o! |
  $ D2 J5 ?7 q! R8 h$ Z+ e, ?9 H

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

2 w/ _0 ]. ~, R4 _- ?

• 如何设置ServletContext的参数？
  
  
  " F7 e  P7 I7 w: A0 r) t- `6 t

<context-param>

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

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

</context-param>

• 如何获取ServletContext设置的参数值？
  
  ) g2 P4 U! Y0 e* }! w' R
  9 R# y& M7 u; c7 W! n2 @1 k* r

ServletContext context = this.getServletContext();

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

• 描述Web应用的生命周期？
  2 i& C- O, J; y8 R$ \# o
  
  - D9 g5 L7 P: o: [

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

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

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

' i; N; N) i. v/ J

• 如何用代码实现监控Web应用的生命周期？
  
  : {' `8 u6 p! M' [+ u* s
  
  

public class Test implements ServletContextListener{

public void contextDestroyed(ServletContextEvent arg0) {

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

}

public void contextInitialized(ServletContextEvent arg0) {

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

}

}

web.xml文件中的配置：

<listener>

<listener-class>

com.csy.Test

</listener-class>

</listener>

• web应用中如下错误码示什么意思：400，401，404，500
  # M8 W; z/ s! R' |# T# O4 C
  ; }5 \% t/ h# j) w
  400 Bad Request//错误请求
  401 Unauthorized//未被认可
  404 Not Found//没有创建
  500 Internal Server Error//服务器内部错误
  
    |! ]& @. K4 F9 _9 B5 z

• 描述Web应用中用声明方式来进行错误处理的两种方法
  
  
  4 Y& O8 Y3 _; m" B

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

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

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

• 描述记录异常日志的方法，都位于那些接口？
  1 L* E. R9 e( V. W6 c
  1 ~, j- T1 o2 B
  

GenericServlet：

log(message:String)

log(message:String, Throwable:excp)

ServletContext：

log(message:String)

        log(message:String, excp:Throwable)

8 L5 ], \, f0 y/ B

• 什么是会话？
  
  ) z* @" r( Z0 n: G9 U& d
  - ]# @( Y3 p+ P% E

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

' z  S9 O9 c) c

• 如何获得会话？
  
  " I# `0 b+ a" e# n' i4 s- F8 _
  HttpSession session = request.getSesseion( );
  
  

0 P8 `* h" P  u. t3 i

• 会话Api的基本功能？
  
  5 S- G2 I2 D" R1 S3 z3 J, {
  % L, ~2 ?1 a$ v$ A$ }  C' N

getID() :String
; n, \8 l; h) {( {7 j

    isNew() :boolean

    getAttribute(name):Object
; [( p$ n, x% i2 z; h1 X0 _

    setAttribute(name,value)

    removeAttribute(name)

• 如何销毁会话？
  . p; m0 O0 @( e; ?
  ( ~5 H. f; b6 r) b+ D: q# a
  ' c! a9 H7 K9 q, t, ~2 v8 N3 k

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

<session-config>
+ u& n& S1 S: l$ [7 c" G1 g

         <session-timeout>10</session-timeout>
" T) S  L" K5 F$ @6 y4 y. ]

     </session-config>

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

invalidate()
4 d9 e! _, s- u& U& ^7 `8 }  d$ ^( N

     getCreationTime() :long

    getLastAccessedTime() :long

    getMaxInactiveInterval() :int
2 R: L' v; c' Z0 G* N9 a/ f

     setMaxInactiveInterval(int)

: o& e2 O$ g$ o" j1 x

• 描述会话保持状态的基本原理
  
  ; G5 d0 S9 n% I+ r5 u
  

8 t  H7 [/ X6 f8 t* c+ F5 r: z

    client server
5 E; ^5 q) B8 u; j

request
; Q1 I; [- y* b% Y

response (sessionid)

request (cookies)
% N1 D! W/ b8 b3 D5 \

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

• 请描述session和cookie的异同之处
    m# C' {! o, \. X0 j' c
  " D" f+ f6 R8 d
  

  f8 J4 H; I! Y5 @/ |
: m) Y1 t/ V2 w" T6 C4 R  q

• 如何读写cookie，代码示例
  2 `! ]% R9 j7 R7 k: F( y
  2 G1 ]" |$ f! I! Z7 {" w6 Y
  

写：    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();
% a, O/ \: }! G

System.out.println(“cook”+i+“:key=”+key+“,value=”+value);
; T7 y' X8 }9 C. d& W1 c) W' x1 n  e

     }

• 什么是URL重写，如何实现，代码示例
  
  
  

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

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

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

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

; w8 i8 a& P* c

• 描述web应用的4种认证技术
  
  : N7 Q$ B2 n  \0 M6 y
    y) D# K1 c% M" ^* E

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

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

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

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

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

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

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

• 什么是HTTPS
  
  
  ! Y6 z0 |+ L  q

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

• 什么是审计？
  ! w# Y0 H( Z$ g: T: K: b, V8 B
  
  

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

" P; l$ d+ ]( y

• 如何实现声明性授权
  0 T; {% _7 o/ J( d+ [; ?/ d
  4 ?+ r5 f/ l; S# |5 I
  

1、标识web资源集

2、标识角色

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

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

在 web.xml里配

• 描述servlet并发问题？
  3 H1 A" i' [2 _) d. x
  
  / u" y! D) v, b; T+ a

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

• 描述Web应用中的六种属性范围
  
  ; v4 v) h9 D& m- e$ H! G$ ^, o6 W% E
  - e8 q' r  `! N. c- o5 U  X: P% {

局部变量（页面范围）

实例变量

类变量

请求属性（请求范围）

会话属性（会话范围）

上下文属性（应用范围）

• 指出上述六种哪些是线程安全的
  
  7 o" Y5 A# @$ Q+ ?
  

局部变量和请求属性

( M1 e  t  }+ _- x

• 什么是STM？如何实现？
  
  & A5 q; v9 }  x3 o" ]; L3 I
  

SingleThreadModel接口

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

2 {" y% y, t* I: r& h

• 如何实现并发管理？
  1 ~! a3 P* o9 c9 |5 n
  ; b1 N) a8 ?2 }" y
    M5 `* {( o2 x: n/ ?

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

使用synchronized语法控制并发

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

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

admin

Jsp
什么是Jsp?
Java Server Page    结合java和html在服务端动态生成web页面的技术
9 K; {: w% ~: R# k! C; J3 I


描述Jsp页面的运行过程？
第一步：
9 t8 X) {4 K$ I% j8 x
  e* ~7 k  n  V, _( h8 X请求进入Web容器，将JSP页面翻译成Servlet代码
0 n* t. P4 d2 A+ I2 e! w5 i
第二步：

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

# v7 ?* u3 x! ?' E2 |第三步：

( y1 V! \6 r/ Y, @Web容器为JSP页面创建一个Servlet类实例，并执行jspInit方法

第四步：

Web容器为该JSP页面调用Servlet实例的_jspService方法；将结果发送给用户
8 E4 ~3 P  s: ^5 ^- B% u1 O! W8 [0 i
5 M' ^+ L( q0 V  C0 Q. F

" u% i2 D2 G1 E' L- z描述Jsp页面的五类脚本元素的功能、写法、并示例
# @  y( b. w8 n3 G& z* Z注释 <%– –%>
1 x# n; l- e; [% j9 {& k4 s
, Z1 x9 R- I& _& T8 x6 z. g$ r<HTML>

* f! v. B1 R' u! t* V& f& T6 k<%– scripting element –%>

</HTML>

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

+ P' Y* P2 j; V4 B  u- G6 Q2 w<%@ page session=”false” %>

# r* S/ T* O3 A3 Q) i# g声明标记 <%! %> 声明标记允许JSP页面开发人员包含类级声明
5 `  q) o; p/ D6 |8 F- @
<%! public static final String DEFAULT_NAME = “World”; %>

5 p3 w  e; m5 ^3 c  ]* }    脚本标记 <% %> 脚本标记允许JSP页面开发人员在_jspService方法中包含任意的Java代码

    <% int i = 0; %>
, p0 v/ M3 \8 v! d2 ?/ u# g
" k* v1 _- p6 d& p( I7 b* i表达式标记 <%= %> 表达式标记封装Java运行时的表达式，其值被送至HTTP响应流 <B>Ten is <%= (2 * 5) %></B>



% h9 s9 J6 h2 C; b& h! K描述Jsp页面中的注释种类和写法
HTML注释

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

0 B0 f8 E# W" ~# nJSP页面注释

<%– JSP注释只在JSP代码中可见，不显示在servlet代码或响应中。–%>
% b+ j+ i, e2 X# Y
" f( e* x) l* ]( I0 ~0 z5 Q% AJava注释

# K% o, k6 [' w( @/ G7 u, X<%
& A# b/ ^8 E7 R% D0 u! f. x" \) [
( ?" t- a: R, Z" B, {' l/* Java注释显示在servlet代码中，不显示在响应中

% R. {% y4 [8 w$ M" W. D*/
7 s4 t6 N  v, J) _7 e- Z. K
%>
( ]8 \, c3 S$ Q4 \) S

- A, Y: E9 f, N+ Y" J1 b
描述Jsp页面的指令标记的功能、写法、并示例
指令标记影响JSP页面的翻译阶段
" Y# t% W& ]" e& u; y4 u
<%@ page session=”false” %>
1 S/ o+ P9 }4 C, Y: K) Q* B- p" A9 a
3 Y' H: G  l! h: F, i7 a9 S<%@ include file=”incl/copyright.html” %>
; O" Q$ {& q3 s' \# D
<%@ taglib %>
4 j/ X: u4 n( J, Z
$ K4 m8 J7 A# x6 p8 j( {
# x# H  K- |; F) A' J4 I  W7 ]
描述Jsp页面的声明标记的功能、写法、并示例
$ ?$ o/ w8 H# t. b/ E# u7 Y$ F声明标记允许JSP页面开发人员包含类级声明

- `2 W, A; W4 ~" L, M写法：
2 a5 ?8 X6 j9 e8 s* F
<%! JavaClassDeclaration %>

例：
, C3 _( a7 W6 ^3 S3 `
! D5 Y+ S8 X* R/ |% C# D0 [" i<%! public static final String DEFAULT_NAME = “World”; %>
! @1 s9 H' F" x3 g& m
& `6 F3 ]! H  D/ w3 @$ I! Y<%! public String getName(HttpServletRequest request) {

; Q( x. y( ~5 O. A2 a, d2 treturn request.getParameter(“name”);
4 J& i, M& I0 k- E; x
- \6 \1 {6 v- n( u+ L: N}

%>

) [' m$ N) A. u<%! int counter = 0; %>
$ @: C0 W9 n  g" I  \


6 r3 m- s$ t, S描述Jsp页面翻译成Servlet的规则
jsp中的注释标记被翻译成Servlet类中的注释

jsp中的指令标记被翻译成Servlet类中的import语句等
) e& M5 H- p! O- n$ o
jsp中的声明标记被翻译成Servlet类中的属性
: {1 F, e, S* F! w8 y: _$ d% o" J
( k9 b+ X' E1 h) a( @0 sjsp中的脚本标记被转移到Servlet类中service方法中的代码

jsp中的表达式标记被翻译成Serlvet类中的write()或者print()方法括号中的代码

( y8 \  n" x2 w  i

描述Jsp页面的九个预定义变量的功能、用法、并示例
- @3 b& j  t; J- ]) F( prequest 与请求相关的HttpServletRequest对象
) t. w  I+ D% h& E0 r' G0 g
response 与送回浏览器的响应相关的HttpServletResponse对象

out 与响应的输出流相关的JspWriter对象
3 C0 Z+ [+ |$ v  E7 _  }) b4 m' E
, t0 I* p3 a( D  e# s    session 与给定用户请求会话相关的HttpSession对象，该变量只在JSP页面参
; r6 S( H: F+ p
* H; ?6 R  {  |9 o# g# H与一个HTTP会话时有意义
. N0 b! r+ p9 Q5 a! x5 ]* \9 f
/ `( _& D9 H- W: h    application 用于Web应用的ServletContext对象

7 H. F) k% U! f3 r. aconfig 与该JSP页面的servlet相关的ServletConfig对象
! p+ r. X- G# O2 l0 L
pageContext 该对象封装了一个JSP页面请求的环境

! G7 ^. y1 n# w2 L) O. wpage 该变量与Java编程语言中的this变量等价

2 c' k' @) W4 _; A7 Q    exception 由其它JSP页面抛出的Throwable对象，该变量只在”JSP错误页面”中可用
9 e6 D& v# g& T$ m. E( L- Z
4 \1 F9 O2 R' @  u
7 C3 |, K, g/ I0 Z/ l, l
/ E6 G; `$ W- H* z; a$ Upage指令的功能，写法、并示例，并描述它的如下属性的功能和用法：import、session、buffer、errorPage、isErrorPage、ContentType、pageEncoding
( }5 W3 e6 ]" W: E$ Dimport import 定义了一组servlet类定义必须导入的类和包，值是一个由
* g! q! ^( @% `1 N# x7 L
逗号分隔的完全类名或包的列表。
! H# `+ |" w2 U1 W: W
session session 定义JSP页面是否参与HTTP会话，值可以为true（缺省）

7 i5 m+ d6 m/ b+ @0 A/ l或false。
" q" A6 k8 [( _8 r5 |
buffer buffer 定义用于输出流（JspWriter对象）的缓冲区大小，值可以为

& `/ d6 e7 P& {+ O" `( F) Cnone或Nkb，缺省为8KB或更大。

' x# f& o2 {, u# `# EerrorPage 用来指定由另一个jsp页面来处理所有该页面抛出的异常

& {+ E) x/ q$ L; yisErrorPage 定义JSP页面为其它JSP页面errorPage属性的目标，值为true或
1 z- h5 P3 e% w; ~% }; ?
false（缺省）。

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

pageEncoding 定义输出流的字符编码，缺省为ISO-8859-1

0 r4 i% G( [' U1 W& Q5 E6 V8 P

# o' y) ?! h/ X$ u* O+ ^2 {% C描述MVC各部分的功能？MVC的优点？MVC的缺点？
4 R: Y# a; {& QMVC各部分的功能：

, }9 Q6 Q3 ]" n. H1 W' tModel（模型表示企业数据和业务逻辑）
3 M$ D2 L  L* G& s4 h1 W- v) V
封装应用状态

响应状态查询
# M9 j, u0 U  X6 e% T
" N: Z2 W% }. c0 L) Q  K- A暴露应用的功能

0 T  t8 F* K7 P7 J* GController（控制器接受用户的输入并调用模型和视图去完成用户的需求）
/ C% ?( o1 b! e" O4 M" S& W6 N
6 D2 ?/ x( J! J2 n  k. c6 h验证HTTP请求的数据

/ _, ^4 T  z+ Q4 k将用户数据与模型的更新相映射

选择用于响应的视图

" Y0 q0 c, `) o/ a# _# fView（视图是用户看到并与之交互的界面）

) i* u2 d, Z) b$ o4 I产生HTML响应
$ n2 h  P  Y5 h1 O" O
请求模型的更新
; I- p8 v; D6 z) U! C: `
, B# a; z& \" ?& R: S提供HTML form用于用户请求

$ z) ]8 ]; }, {/ E+ FMVC的优点：

1 e0 N4 S, n7 R% K* x        低耦合性：视图层和业务层分离

0 w/ N% x: ^& ~: @高重用性和可适用性
) c* y4 s. n  C; x! @. K' x3 o, s
较低的生命周期成本

7 p/ _; y% e2 I: {5 ?# l快速的部署
" _9 e2 w8 v( W6 a
可维护性

有利于软件工程化管理
* b7 x  [( b% R8 z  ~" g1 j6 Z* m
5 P" |- V8 r! a/ U提高软件的健壮性

MVC的缺点：

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

" ~# O6 {8 h' g' i
! @; E5 s4 p' n) S- F( _( C: k
什么是Model 1结构，以及结构中各部分的功能
; g4 G6 V& Y% R. R- q% [结构：jsp+javabean

2 X  @, d8 q' aModel1中使用jsp来处理web应用中的视图控制部分
) F3 ]7 \2 K  e. B' l4 U) a
Javabean收集参数


& f1 r( k( l% p
' o) s  b! Q0 [# f1 B! f什么是JavaBean?
用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。
- G5 l5 h0 Q, v  w  K9 K2 t" z
0 y- u2 E. [1 r, K3 q3 l, ~
( j+ |. e3 o) y7 r$ x: h
JavaBean的规则？
- {4 K- a3 N3 e6 a& D2 `, P5 P使用get和set方法定义属性
+ L# E" ]: }5 _6 v! R' H$ }: |
一个无参构造方法
, v/ j) w  l$ j4 k) Z2 \
无public实例变量( 所有属性私有化)
9 S* {3 X# z3 _( v* I3 h
# D7 P  B4 Q" e4 I  `0 B
/ Z  a) a2 w- N
1 I( B' w0 e& r, a  S什么是jsp标准动作？包含那些？分别都是什么功能？如何使用？
! n% h$ J) u) |% g" g) fJSP页面中使用类似于XML的标记表示运行时的动作

7 J9 u) {/ g, Qjsp:useBean
! L- Q; H2 Y% S8 F9 [9 N
jsp:setProperty
8 O) }" s* p- t2 N- s" N9 l1 Q/ M
jsp:getProperty
8 t1 z* ]- Q& w+ ^! I
- p$ L! w6 N5 }7 b9 ]jsp:param

  C& p4 K! i6 p& e: o7 pjsp:include
/ i8 |8 j: A' ^$ q2 T8 \7 q, w% ^, a
jsp:forward
: n+ Z* D" s. C7 ^. s


用代码示例如下标准动作的使用：useBean、getProperty、setProperty
/ u2 u' `* o! _" ^( r<jsp:useBean

3 r8 {, P- R% G1 v7 Eid=”myForms”
& S, @- e' B& ?- Z0 d8 ]/ H# Z
class=”com.base.mystruts.forms.MyActionForm” scope=”session” />
. W; ]; \" \& Q. v
& k( q/ F% t+ s$ V7 f" I    <jsp:setProperty name=”myForms” property=”name” />

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



- {* u% T7 M9 X6 U: m4 R& I描述说明Bean的四种scope
page

request

# g( T' C  a* L% j% vsession

# z; o3 o/ V3 I( kapplication
- g. x6 g2 n8 `) F, G3 \1 v2 V
9 ?2 r# Q, y" @: ?  K

% r- X( t$ O) ~  N描述说明页面上的字段和Bean中属性的对应规则
id 指javabean的变量名
) h: V8 z+ I7 R4 g
class指javabean类的全路径

  `! u* q1 `2 I( Uscope指javabean的应用范围
& e; _" a# W! o8 K) a% A: P) n3 x
name指所用到的javabean的变量名

    property指javabean中的属性

* }4 c1 |% x- X
% S/ }% y9 X) o  B( U, ~  c! e
/ P/ _6 z; U- M7 X4 y0 U" |描述useBean动作的处理过程
2 A$ Z- `2 p0 I: x7 s/ U$ H使用id声明变量
8 m( Z9 \% h4 c" b
试图在指定的范围内查找对象
2 _2 d2 S8 H4 B2 d( b; w& z
如果没找到

! n5 N% M: {+ v; H, \2 ^$ N创建一个类的实例

' W+ R3 Z: g2 B执行useBean标记体初始化对象

- O; L2 k4 c& U7 P. `2 Q/ v如果找到
- d2 m% L& g9 @) R
     将对象转换为类指定的类型

4 b" E6 y, l4 j! n5 I/ T* g
1 J  ]3 I) a! v/ x9 e
" s' [/ U$ H: ?4 V; g描述forward动作的功能
" @7 j/ h/ X6 o3 _使用脚本代码处理请求时，可用jsp:forward 动作产生一个不同的视图，
, F: p! j6 g" R
使用同一个request：
0 @% I$ w" Q" P& c
- F5 ?/ x  t# ]* j& D/ C

什么是Model 2结构，以及结构中各部分的功能
, n* U& x0 L3 I: tjsp+model+servlet

Model 2架构使用MVC模式，JSP页面充当视图，Servlet充当控制器
& v( B% c9 p# ?; I: D6 ~
2 G/ f# f0 ]$ yServlet控制器：
9 \: m* b8 F! F- l
验证HTML form数据

* L! M+ S, O# \调用模型中的业务服务
  P' D: s/ G; {) C- Z6 w
! k8 q4 ?) w' f5 G/ ?* X# ?1 c存储请求（或会话）范围内的域对象
. Y! j. u/ ]  e- R
$ s$ W$ S. F6 w5 G# O选择下一个用户的视图
7 n+ T$ c6 \' x2 L
& y+ Y. p+ X) i' [" |( yJSP页面视图：
( t% j+ ~; m5 v% G9 s0 R
使用用户界面（在HTML中）
5 n' M! X+ p4 `9 I7 A
8 P/ w5 a# O  l. |9 Y  {        访问域对象


+ c- K/ _6 }4 t) v
如何获得分发器？分发器的功能？
/ \7 A1 t7 {% q9 d+ N上下文对象中的分发器：

ServletContext context = this.getServletContext();
9 E2 v1 D" t6 w5 C4 T; v
RequestDispatcher servlet = context.getNamedDispatcher(“MyServlet”);

servlet.forward(request, response);

) h( H* W, e6 @; E7 P# _请求对象中的分发器：

. O/ M8 p0 u# A- J9 {4 P, [RequestDispatcher view = request.getRequestDispatcher(“tools/nails.jsp”);
3 ~, R* T/ J6 s; X5 A( U1 Y5 u9 }
view.forward(request, response);
) s2 s/ u& V2 ]. O
0 i: Z' G3 h; o  `可以将请求转发到另一个jsp页面，并保持请求的传递性
; n* f. o" e3 {& A- {: Z; i
' A' Z/ z& j: ^- I; Y0 {

Jsp中页面跳转的两种方式？
; f2 V5 s4 _7 ]9 Z& e使用分发器跳转页面
RequestDispatcher dispatcher = request.getRequestDispatcher(“url”);
4 |! q) f( A0 b7 Q& R5 ^# _
% H8 c# n) `% ~" F, H" `$ j8 Ldispatcher.forword(request);

2 ~7 K: b$ ?% x* V& y    特点：保持请求的传递（上一次请求中的数据，在下一个请求中仍然可以得到）；

        转发的页面只能是同一个Web应用程序的其他Web组件
6 k. E/ }6 _0 _: f
使用重定向跳转页面
response.sendRedirect(“url”);

4 ]/ @, S3 Z$ s2 h: v# p+ [( b6 G    特点：产生全新的请求，（上一次请求中的数据，在下一个请求中不能得到）；

3 x( p  x( m0 p0 @' y; Z' J        重新定向的页面可以是任意的URL
6 d. c" j$ @# R( R
- J3 y$ `1 ^- D1 n! ]
2 A' k6 c) G9 N& J
描述Jsp中引入另外页面的两种方法，并比较两种方法的特点？
<%@ include file=””%> 在编译期间把另一个页面完全嵌入这个页面,可以说是一个页面
. s; ]% h5 A7 R  z
! ]: j7 H& I3 b$ p# O: z5 A. I在这里可以共享变量
% P: _  R# l% a1 _* x
<jsp:include page=””> 动态的再运行期间把另一个页面加入这个页面,可以说是两个

: s5 [0 p, c1 ?& ~) m0 s. d页面，不可以共享变量

8 t6 a, s$ s9 \9 T3 r

什么是自定义标记
. J+ U/ _, B, [, A1 E5 C0 F4 N自定义标记库是一个Web组件，

包括：

$ H+ C! q$ F5 g/ t& K* O一个标记库描述符文件（*.tld）
& t9 A& ^' N* `$ x
所有相关的标记处理器类(*.jar)


1 F8 Z$ i0 m+ d0 ]! B# T5 f
! j1 u* E4 h( S  j0 h& }描述使用自定义标记的步骤，以及每步详细的工作
使用自定义标记前，要拿到.tld和.jar两类文件
' q6 |( \4 F: s( u2 Y; F3 `/ [' b8 h
3 P! {* S, @5 b& J9 N/ ^1 \把.jar文件放到WEB-INF的lib里面。
6 B) g( x' I9 @, l9 M把.tld文件放到WEB-INF根目录下。
6 K5 U7 P" R; y: {  B3 W& \# j# e在web.xml中配置。
<taglib>
( `; i" [" f4 P1 |/ x* \& [
<taglib-uri>http://java.sun.com/jsp/jstl/core</taglib-uri>

* u- A# w; K0 C% K. C( x     <taglib-location>/WEB-INF/c.tld</taglib-location>

</taglib>
% [# Q8 ]& w* O; f, s/ k
在页面中引用。
4 u) I% Z! i% q0 P* @<%@ taglib uri=“http://java.sun.com/jsp/jstl/core” prefix=“s”%>

+ d* ~% D6 {3 g5 buri必须与web.xml中的uri对应
! [; f" o0 j" j+ h0 g% e
0 ~# p0 O3 d) _  I+ S1 \; _' ?/ Vprefix是前缀，用来区分是哪一个taglib
! V; `) j( ^. T  S( o) a% J1 j) |+ z
% [$ W" C! q1 q$ m8 A使用标记
格式：<prefix:tag名称 属性>
1 X  S' L! t# m! s( g
<s:forEach >

admin

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

配置server.xml文件

1.oracle
6 j" n0 l, D8 m8 U* }; J3 `
$ ?, @4 H2 b, x+ m9 C" Z; m<Resource name=”jdbc/company” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”
/ E% ~3 C% Y% P3 i# v
9 c7 X9 C# }6 J2 K7 {3 @- s                        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”

7 }8 F9 l: n" g* z' A( burl=”jdbcracle:thin127.0.0.1:1521rcl”

4 c: x( K# k2 w9 T9 q$ }driverClassName=”oracle.jdbc.driver.OracleDriver”
4 s' A$ m0 T7 l
6 b& T# ^  ?4 b) s& Yusername=”aa”
) K9 v" z- z' |' d3 E; J7 g
password=”aa”

: r! n6 C9 ?6 a0 O" r0 q* G( ~maxActive=”50″

- @# Z- r  n- Y1 ImaxIdle=”10″
1 G6 y* F4 T! a! ~& w* J/ j
) t1 v& }8 c# X+ _& tmaxWait=”-1″
! _0 M& |! P, y* U0 A; t1 t. W
/>

2 l5 y2 i0 ^# S9 y  u( C4 `: [% K2.sqlserver
" y0 i# A0 T) w9 n4 X7 I6 k
( ~3 l1 B/ K& N<Resource name=”jdbc/webpage” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”
4 B8 \5 G2 P5 ~! F0 a( }6 p
        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”

* G" b1 g$ |) N( wurl=”jdbc:jtds:sqlserver://localhost:1433;SelectMethod=cursor;
. P+ ^8 c" v* d' T3 |4 j
DatabaseName=webpagetest”
* j5 f* Q: `4 V& n
4 L! k/ B- ^8 S2 M7 m) CdriverClassName=”net.sourceforge.jtds.jdbc.Driver”

. F: S! q' F9 x, h6 w. iusername=”aa”
, {$ v: B( o. s
password=”aa”

( j" P" O; G* r7 n/ HmaxActive=”50″
& {, i/ P) a+ J% d. \( w7 F* w7 o
maxIdle=”10″

5 v2 U# \% R  k& kmaxWait=”-1″
- h, I5 r! b' j% c" |& k" S" [
+ V% ?/ F+ F& a8 R+ P/>

  S% p* v3 @5 P) e6 D+ T8 _' d2、配置自己的web应用的xml文件
3 C  f# R( _# H) D5 R, b1 n. M- O
2 G6 |1 h/ k& V7 \6 z; x

<Context path=”/eb03web” docBase=”F:/workweb/eb03web”
& r+ t! J0 Y' I4 D
; R  ]2 m! f. U; p  }privileged=”true” antiResourceLocking=”false” antiJARLocking=”false”>

<ResourceLink global=”jdbc/company” name=”jdbc/company” type=”javax.sql.DataSource”/>

</Context>
" R0 p* o; R! c4 C6 @2 L
7 `8 e) l9 \) }$ f

3、配置web.xml文件

与服务器建立连接
2 M" a6 i' [/ ]7 ^/ P3 V) }( P, C
( C9 D6 W8 Y$ X! G<resource-ref>
1 b; H. ^7 N2 p- m2 o
- f; p+ t  r- q, D<res-ref-name>jdbc/company</res-ref-name>

<res-type>javax.sql.DataSource</res-type>

. J. s& q+ ?8 |- c: `5 o8 e7 {<res-auth>Container</res-auth>

</resource-ref>

4、在应用程序中不直接与数据库连接，通过DataSource连接池建立连接
. r5 a' }+ m! h8 q. {" _
//1.在程序单独用时设置系统的属性，在tomcat下可以不用配置，
5 n4 i* x: N. D
; D" Q7 W/ s2 d) ]" D) kSystem.setProperty(Context.PROVIDER_URL,””);

) j: L1 ~# R, YSystem.setProperty(Context.INITIAL_CONTEXT_FACTORY,””);

8 w+ a  U2 q# k8 N5 u4 c) X8 i2 Q& |//2.创建一个上下文对象

4 H$ E: h" s4 D( V0 s$ b6 CInitialContext context = new InitialContext();

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

! c- I+ z2 ]$ c4 |, {- T9 O+ NDataSource ds = (DataSource)context.lookUp(“java:comp/env/jdbc/company”);

( A5 h9 m; N5 C9 t1 H//4.通过数据源建立连接
) |" y- ^; M6 A0 B/ |  C+ U
ds.getConnection();

admin

ORM对象关系型数据库映射
(Object Relation Mapping)
& l, l, A& Z3 Y$ \6 o& t
1 r4 ]( B, S0 U8 n5 y5 _- l3 R, _* w一、映射的特点

1.一个对象可以对应多个表
; Z/ U* O' Q9 h1 I
2.一个表可以对应多个对象

7 W: j2 q+ l1 b7 [4 o3.对象和表的关系不用完全对应

4.对象的属性的名称和表字段的名称可以不同
7 {: Q0 w( ?# m8 {4 F  n
# D" ~. \% ^! ^. L  @! `) Y0 F5.类型可以不同，但数据类型之间可以转换
+ c5 a* ^5 \: s/ V7 `" y
4 S( h! O+ E# V3 O% m- t* \; w6.对象中必须有主键，数据库的表对主键无所谓

& X1 O* D7 D, f4 ]9 z, H% l7.数据库中有主外键关系时，对象中可以有，也可以没有

( u" K  i- {. T' J4 Z/ c

: w% q6 o8 U+ M* `7 h) p二 、有一个映射的描述文件————>xml
4 s0 p9 J( Q% H4 [$ \2 ]
三 、怎样实现描述文件————>一段程序
- o& B& |" v, v3 [' X: G3 ]
对象 映射（mapping） 数据库
" n7 O1 s* x$ N5 |
  c: N; R8 M  T& v6 O* L; ~( Ruser
) Q. ?6 c+ j9 ]2 C" E2 P
id=11
, S6 u! f# {9 r/ h3 E  H3 M
7 C3 ~7 Y. K% U  [$ C+ Fname=”张三”———— > (1) —————> tbl_user(id,name,age,tel,address)
! ~1 L; C  h3 N; b4 N! b6 j
age=25 <————(2) <————

" J: x2 C) ]+ d. g; V6 ^
* }9 p2 Z* I1 L5 ^, b; N
8 a/ c1 D& E& }9 p+ S" g& ?  T(1)从对象映射到数据库

1.JDBC

2.根据描述文件来动态拼接sql

) ]7 D( j- D2 Q8 c5 y  h! O2 S, P. @! C3.执行，添加到数据库中

; [- R( {% k9 S6 m6 b  ?  s9 Z

(2)从数据库中映射到对象
, K" y; l% L& v+ Q, W
1.JDBC

2.拼接查询sql

3.ResultSet

4.Model


- I# k" T. P. s( C" ?' ]
# ^% N/ x0 Q8 b: U! y+ \3 u' g3 ohibernate
开发流程：
/ `' B1 i, M2 Y8 h
2 K. g/ `1 x- _0 H是什么？
% G9 {4 T* P3 m7 shibernate是一种基于orm 的轻量级的框架
. W1 Y; @) p! i) H4 A; n9 {
8 G: a; Z0 j* ?& p
+ k9 j9 |( C. i3 K
1 ]. v3 Y) t" P. {' ~0 v有什么？
3 p( D5 i8 \: k, p. h( l' ~: {1. session 保持连接状态（依赖事务和连接池）

. g( g2 f* t7 R' A  K* \: G* }2. Transaction事务
4 |' S2 y0 P  D; F; b: |7 G
% L+ a3 }. H+ B. p3.
Connection Provider 连接池



; Q/ b. M. |( w6 m, I能干什么？
1.orm

2.提供操作数据库的接口，简化数据持久化的编程任务
/ k7 P4 \9 p$ A. A7 [

8 @2 I0 ~4 F8 P! o* @
- `, T- c2 `4 L7 [# \  [0 A怎么做？
6 u$ S" i5 R$ I5 `" b9 P1.搭建hibernate的运行环境，将hibernate的包和hibernate所需要的包拷贝到lib 文件夹下
+ W: X7 s9 c+ D" b
& z! D5 Y: e6 s3 c2.O（vo）

; C9 x, [3 u1 I+ J/ _" q3.R （关系型数据库中的表）
# l% ~: T5 D1 S/ H+ b
4.配置文件
- U. p9 n" W! K* m2 R  t
4.1 cfg.xml 放在classes根目录下，默认名字为hibernate.cfg.xml
6 J8 }% J5 q/ K  {" M
a.与数据库的连接

6 E! y( Y" ?0 B. a: `: M: I5 S9 jb.可选配置

c.映射资源的注册

4.2 hbm.xml文件 名字与类名相同 并且与类放在一起
5 i4 S" \0 d6 V" A$ ?# Q
a. 对象与数据库表之间的映射

b. 对象的属性与数据库表的字段之间的映射
# I# K2 z; ^, O/ g5 d' s$ m
c.组件之间的映射
4 i$ [  i9 x- ?  s/ z; U1 S+ K
, V; \2 t' @5 c1 Ld.对象与对象之间的关系映射
6 ~% k* c, T  I- @
5、客户端

3 U  U9 P8 O" V: I. P+ d1 C1.得到SessionFactory

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

3.打开事务

4.操作数据库
" {+ t) m$ k/ Y9 v8 c5 O3 R
5.事务提交
3 E. D' q8 J/ m
/ e1 U3 b' X9 l1 a, T0 X" _6.关闭连接

运行流程：
  m0 t" L  f( p0 B
整体流程
2 ~# Q  `: B) d4 Q1.通过configuration来读cfg.xml文件

2.得到SessionFactory 工厂（根据数据库的连接来创建sessionfactory）
! N% t1 W+ q7 V# @" A" ~
$ ], ^; n5 \4 J5 G+ w) R3.通过SessionFactory 工厂来创建Session实例

: V  u) R1 S* G, F( d! D4.打开事务

# w$ }4 o* M# u$ I4 J2 g0 {5.通过session的api操作数据库
6 L' S0 q8 C$ W9 n" ~4 `
6 {- y# c8 _5 c7 l2 n: _2 d$ }6.事务提交

+ L8 C$ A: Z  D" t3 P7.关闭连接

2 `( p) R+ X& C0 ?7 D2 {6 B" j
! a6 Y( b3 i, L7 D: r+ z# Q" O
save
. P5 W* N0 w3 X& W& O8 e1.to—>po

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

3.根据hbm.xml文件和model来动态的拼sql
& o8 T0 B8 n4 Z5 H
4.客户端提交或者刷新内存

& y& a( H0 o. s2 Z4 C4 k& C5.执行sql，值放到数据库



update、delete
. p/ f3 m$ [; D1.根据model 的id在内存hibernate的缓存中查找该对象

9 G( h( k; C6 t7 F1 I如果内存中没有就到数据库中查找来保证对象的存在

+ y  f8 ~" z: B( X$ f7 ]! L+ ]0 u2.根据model和cfg.xml文件中映射文件的注册来找到hbm.xml文件
7 v5 B: E$ ?) A6 ]' U1 t
" }9 v& J* t% z9 `* `2 R3.根据model和hbm.xml 文件来动态拼sql
' q' U3 q- R8 D, z" R5 T. g; L$ G! g$ X
- b  M! u" R, g: I" ]! r: t4.客户端提交或者刷新内存

$ t( ]* b+ g6 W8 e5.执行sql


8 i1 C, S3 q  u% @1 E& n  o  U
Query
+ M) Y  p1 ?( X' ]- |+ bload
& i1 g  R. O# l5 l3 K- m3 p2 B6 L# D
5 O* X* Q- a. U1.根据model的类型来找到hbm.xml文件
' c$ H6 m* U8 _
! q* ~8 C: t; S! F) h7 P8 c4 N2.判断id对应的对象在缓存中是否存在，如果存在，就直接使用，如果不存在就进行下一步。
* M  R& C8 {2 P+ N. W% i8 T# _
; O0 V0 F8 ?( f! _8 e3.用id做为查询条件来动态拼sql

2 ?, g; K/ F& L$ e) T7 D4.执行sql 查询（先在内存中查找，如果没有找到（会抛出例外），就去数据库中查找）
( W  D2 z8 q5 D2 |7 t4 E. P
5.返回一个model类型的对象
2 B* J* k, A. f. B+ d9 ~  f
get

    1.根据model的类型来找到hbm.xml文件

2.用id做为查询条件来动态拼sql

8 f) S6 ~! q8 m* ~( a+ M: T# S3.执行sql 直接在数据库中查找，如果没有查到就会返回null

query

$ d& t/ E* q4 M! D1.分析hql语句，得到model的类型
2 s+ v' Q- H& r' N
2.根据moedel和cfg.xml文件中映射文件的注册找到hbm.xml文件
, D, J0 X& b) U0 b
3.根据model和hbm.xml文件来动态拼sql
8 _- B# X# [% Y4 `$ ~9 M
! U: T  W9 p2 a& L/ `4.执行sql查询数据库
' {( G* L/ d- ]8 b
5.返回一个resultset
5 \; X& ?& Q" I5 v
; `0 g& C- H8 h! H6.循环resultset的值，放到model中在放到集合（List）中


( }0 v3 T$ c$ a# Y* i1 K
7 Z2 i+ K  {2 W- {6 P& O- E谈谈hibernate缓存机制

缓存其实很直观的理解为放到内存或者硬盘上的一块区域，缓存就是一个缓冲的作用，有很多时候，我们的数据需要经常访问，如果放到数据库中，不是不可，只是效率上低，如果有了中间产物来代替数据库，就省很多事情了。打个比方，去买酱油，不一定一定要去酱油的生产工厂去买。代码中需要数据的时候，可以先到缓存中查找，如果存在，就直接拿数据，不存在就去数据库中取，也省了很多事。
( n, S( ~" ]% W9 u6 b) ^
  G6 x) V+ E6 P5 v
. F3 s5 N& {0 E3 T2 D% o6 U' H
3 l, S$ @9 T% y# J  ~& }: Nhibernate使用的是二级缓存，有两个级别，分别是Session，SessionFactroy级别，一级缓存是Session级别的缓存，Hiberante来管理的，这个我们一般不用管，二级缓存是SessionFactory级别的，可以进行配置和更改，加载卸载，就是我们平时用的hibernate配置文件中的配置SessionFactory的属性。

( \7 F$ a/ b' g3 g7 z; s+ C

% j* X2 z" r% `$ u2 p对一级缓存中的session事务进行数据的预存取，数据在各个session的上下文中存在（单例），当session关闭时，就是session.close( )，整个所有session范围内的数据全部清空；二级缓存默认的情况下是不开启的，如果开启，数据库汇总的所有数据都先copy到二级缓存中，这里要注意的是，一级缓存是每个线程下创建的session缓存区域，可以是多个，二级缓存只有一个区域 ，画个图比较容易理解。
3 l8 k8 y$ i7 P+ K4 d' x8 W1 a  R4 T
) O6 L2 ~1 a) c) _( K! X4 N1 K
9 x$ j( ]! s2 t* }! i
" g1 T. A# }2 X, Z! W| 一级session缓存| | 一级session缓存| |一级session缓存| |一级session缓存|

  v3 O) {8 w/ t3 E! P& L6 R| | | |
2 f6 X4 A/ g0 n/ T6 Q
. l$ ?# T/ k" f0 G| | | |
  e& ~( c) O: Q: P, V
—————————————————————————————————
5 _7 A6 ?5 P/ L2 X6 ^6 r- M* N2 \
# M' S; ^( U; i% ]sessionFactroy级别的二级缓存

( @7 w6 \! O. r! Q9 t- l/ r$ _——————————————————————————————————————-

1 Y: X1 J  f  d7 H|

|

0 g( d; g/ s5 h. W|

& z. C3 F' _' i4 N$ f/ U9 e——————————————————————————————————————
% e1 b2 A& X! d7 S- b& C
  o3 t* h5 P; m) q( `5 nDB

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

admin

Spring

• 是什么？
  
  1 I4 C1 _4 z( n; k

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

• 有什么？
  ; ]+ z+ q) h. P% `5 r
  

" L3 w5 G! ]2 `- O7 |1 h$ ^

每个包的功能：

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

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

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

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

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

AOP ：面向切面编成

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

; J; c" x; ^6 C

• 能干什么？
  
  

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

• 怎么用？
  " u- V/ j; k  }% b/ ]$ M: z) {
  
  • 搭建web工程，引入spring的jar包
    
  • 在web.xml中添加如下配置
    + G. a  g/ ?" W! I, O; S
    5 {0 m: k4 k6 e# m5 U; n
  
  
  

            contextConfigLocation

            classpath*:applicationContext*.xml
4 u* E7 U9 @- P

   

        

            struts2
" {6 ^! X$ w. S/ ~  U

            

                org.apache.struts2.dispatcher.FilterDispatcher

            
+ b+ J$ V5 A3 l

        

        

            struts2

            /*
  B4 s# c+ z; v( p. \

            

                org.springframework.web.context.ContextLoaderListener

            

        

• 部署
  
  

& [4 S8 L; C! k2 N
. [; a+ `) Y# Q# A- H# d" W
+ Y1 g+ T: v7 w% _; n* V& d

• 容器和bean
  ! H1 @" z) e5 _% ~& n, R

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

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

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

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

% j, }3 U5 g1 I# a

• IOC控制反转
  " E: \5 `+ ]) ?- A) _& j7 [
  
  
  % r  J5 P8 L+ U0 n5 O4 S3 u
  
  从前的应用程序想要得到A的实例他会直接主动的去拿，当用了sping后，应用程序由主动的去取变成被动的等待，由spring来控制应用程序所需要的对象
  
  
  • IOC的优点
    
  1.可以通过IOC来获得实例
  2.可以通过DI来获取注入的资源
  • 配置IOC的原则
    
    • 一定是可变的资源才采用依赖注入
    • 一定是层间的接口或者是模块之间的相互调用才采用依赖注入
      

• DI依赖注入
  0 Z) j- y1 J3 d" a2 w

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

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

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

例如：

在配置文件中

/ t7 }  ]* ~& f% x% F8 N
8 Y# b( t7 V+ F/ x

在应用程序中

Public DBDAO dao ;

Public void setDao(DBDAO dao){

This.dao = dao;

}

3．构造器注入

4．ref 表示参照其它的bean

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

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

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

6.lookup注入

7.singleton

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

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

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

8.DI的优点：

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

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

• Aop面向切面编程
  5 c3 K' J7 I* [6 d( B- O4 M
  

1.AOP面向切面编程 一些较好的模式或者是示例—-范式
4 S" r* N8 L  {! w

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

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

3.AOP 的概念
8 n& U) i! t4 P1 h" i# L/ X' O

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

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

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

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

5.引入 ：扩展的功能

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

7.aop代理 ：实现机制

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

4.AOP的事件机制
  q) a: u3 D  C0 s! w+ D

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

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

3.找到切入点

4.确定连接点

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

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

+ d% r! E, D) q# \7 |



  X  q: C  K% ~" v5 ]
2 @" x" T3 B3 ]0 s/ q; [  Y
5 `3 `5 p* `3 h0 g. G

5. AspectJ

5.1.在xml中配置比较烦琐
! }5 G0 n9 |7 M* \( }( r' S

所有的入口必须从一个代理（ProxyFactoryBean）开始
4 ~' [& s" O, @/ ?# o  m

         

. y0 G8 E3 @$ v& k# b/ @- |0 f
( g, Q; j$ H! V! |& I         
' t* l5 V: n* D8 H

        
! F; G0 M9 b" H8 b; A; C, z

        

expression=“execution(* com.javakc.aop.MyTarget.t*())”/>

        

        

   

  O/ B8 h0 ~! e
% J- R3 x' j+ }% T7 m* O: t

5.3.使用注解的方法相对简单
; [. R: c7 D' b, b- P

@AspectJ的基本语法
( j4 [% J- n$ d" ~$ C5 F2 A! s

1.@Aspect声明一个切面，将一系列的共同的功能定义成一个切面
$ y: K$ x$ H; ?, m& p

直接在类上定义@Aspect
7 c" _2 E1 d$ w; v

2.@Pointcut声明切入点
( a/ ~% ]5 [/ I- r8 Y

2.1、用一个专门的类来定义pointcut，类中的方法名就是该pointcut的名字
# C% s/ ^4 g) z& Z

2.2、可以使用匿名的pointcut

2.3、执行切点的几种方法
3 {' m+ I3 p* x1 E

2.3.1 execute（public * 包结构.*.*.（..）） 可以指定到具体的方法
! z1 O+ z2 W" e4 A" b1 u( _3 Q" \

2.3.2 within 指定到包，不能指定到类
7 w0 f1 Q1 v# T3 d" A

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

2.3.3 this 指定到实现接口的所有的实现类
: }3 d5 K  V$ o- f1 d

2.3.4 target 指定具体的实现类
1 K/ R  W( D: O

5.4.advice的五种类型的示例

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

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

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

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

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

得到目标对象的方法的返回值，来作为参数，进行下一步的处理,参数没有顺序，按参数的名字进行匹配
- [$ i* r; x# c8 _' p% t

完成追加的功能

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
3 x% f) r6 G# O9 R

(1).@AfterReturning(“com.javakc.spring.schemaaop.TestPointcut.t4()”)
, l" T0 O$ H9 w7 B: e% x1 q

(2).
6 i& u, e& y3 Y/ z# m

     2.直接引用匿名的pointcut
# ?8 j$ I9 }# w2 q7 U  }" w# ^0 _

     (1).@AfterReturning(“execution(
5 [5 B' [7 ]! H4 X4 n  F

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

     (2).@AfterReturning(pointcut=

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

args(str)”, returning=”retVal”)
6 `& z( y! l4 {4 \! V) Q; O

@AfterReturning (pointcut=”com.javakc.spring.schemaaop.TestPointcut.t4() && args(str)”,returning=”retVal”)
( A! p0 `& i9 |4 U

public void testAfterReturning(String str,Object retVal){
2 `5 W) a4 @0 |* K' T

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

    }

5.4.2.@Aronud
% l2 Z7 ?6 N; `2 E

     注解@Around环绕追加功能；
- L3 S% L5 f* `2 Y2 V

     在执行目标对象的方法的前、后追加功能；
3 h5 i$ |4 q9 v' N! j5 N3 r" Q

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

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

目标对象的方法

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

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

     (2).@Around(“com.javakc.spring.schemaaop.TestPointcut.t2()
( a& P/ r% `. |: t. n

&& args(str)”)

2.直接引用匿名的pointcut
, s7 q+ E/ k: p* _5 r* ]& B* Q

     (1).@Around(“execution(
) }" I' }9 ?/ U  c  w" p, E

* com.javakc.spring.schemaaop.Api.test1())”)
2 V# F# Z( N8 Z" z; n2 [/ C7 f

     (2).@Around(“execution(
6 L8 y$ A( U) ~2 j6 J

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

// @Around(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
# A0 e- F3 A2 J) c) r6 O2 R

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

public void testAround(ProceedingJoinPoint prj,String str) throws Throwable{
( F! ~$ @$ a6 Y9 F% F  H+ x

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

        Object obj = prj.proceed();

        System.out.println(“around1==========after1pointcut==>”+str);
0 r* g0 f/ e$ d, q( o# e; A3 Q3 A* y5 n

    }

5.4.3.@Before
# @% [/ u% D0 p: J. w2 q

注解@Before在执行目标对象的方法前追加相应的功能
) s* [, P$ I9 m4 n

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
# ~( g; ~- v1 T3 j

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

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

注意args后的名称与参数名相同
' I! {9 M& \7 s% N, l( `" K4 g( S7 ~

2.直接引用匿名的pointcut

(1).@Before(“execution(* com.javakc.spring.schemaaop.Api.test1())”)
2 a) `( o2 B9 [: H

(2).@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
3 d% h+ D5 z8 ]

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

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

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

public void testBeforeParam(String str){

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

}

5.4.4.@After

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

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
, V2 Y. W& ^4 e6 K, R7 S

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

     2.直接引用匿名的pointcut
& m# Z: W* p- ?& ?

     (1).@After(“execution(* com.javakc.spring.schemaaop.Api.test1())”)
! B# K7 w* w, l5 l0 v" v4 O2 p

@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
# q; u5 {+ Q% Q

    public void testAfter(){
1 @5 E5 x. c: f- U2 a, [) |9 F

    System.out.println(“after1== >pointcut”);
- |! f* D7 M9 P" H: ]) N

    }

5.4.5.@AfterThorwing
9 M! {& u; R4 o  G& v

• 描述一下spring中BeanFactory和ApplicationContext的差别
  4 F  H9 B5 S& |5 G1 z0 [4 e! o4 b
  , `1 i! {; z! B) c# [5 e2 ?

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

! _; G2 s( a2 q5 B

• 谈谈spring对DAO的支持
  
  

Spring提供的DAO(数据访问对象)支持主要的目的是便于以标准的方式使用不同的数据访问技术。
5 P2 }: L+ ]4 K$ y

简化 DAO 组件的开发。
' Y3 R2 {2 e2 v9 SSpring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法，用来简化代码开发。

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

面向接口编程及 DAO 模式的使用，提高了系统组件之间的解耦，降低了系统重构的成本。
5 _( H# u3 }( I$ d$ M! I. a

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

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

• 谈谈spring对hibernate的支持
  9 y4 j% w( |/ G
  - r+ s, ~# M( l4 r8 N

在所有的 ORM 框架中， Sping 对 Hibernate 的支持最好。如 SessionFactory 的注入、HibernateTemplate 的简化操作及 DAO 支持等。另外， Spring 还提供了统一的异常体系及声明式事务管理等。
, ?8 E* d7 Q' b# }  ?) {

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

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

9 M! a* s* j3 }  A( m1 s/ o

        class=“org.apache.commons.dbcp.BasicDataSource”>
+ H- n+ i, `/ i5 G: g$ Y* F

        
. p5 s# W4 b( a6 @

            oracle.jdbc.driver.OracleDriver

        

        

            jdbcracle:thinlocalhost:1521rcl
2 Y  S9 B5 w% L4 |' j

        

        
# e$ ^. Y0 I" ]

            javakc2
0 X4 |7 A4 s  F1 w* ^

        

        
0 m; R# z4 x: m5 N: U

            javakc2
+ R8 N4 g9 h1 Y

        

   

6 G& S- i' m! O3 J

   

        class=“org.springframework.orm.hibernate3.LocalSessionFactoryBean”>
  j5 t  \" q9 L

        
' ~6 N7 `$ x$ Q3 i. K: I4 E

        

            

                com/javakc/spring/h3/UserModel.hbm.xml
0 n2 G: ~4 R8 E

            
$ h" F% n+ r" {# b2 d2 N

        
- ]" {7 ~. v: h* Z9 Q

        

            
, N/ [9 G8 F/ K: d) D6 @( u

                hibernate.dialect=org.hibernate.dialect.OracleDialect
% _6 E8 m; O: M1 m/ h% ]

            

        

   
/ A& Q+ C5 n7 `# a# r1 `

   

        

   

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

   

        class=“org.springframework.jndi.JndiObjectFactoryBean”>
& q9 \% e5 o4 b( N, _* D/ P

        

            java:comp/env/jdbc/myds
% Z0 b# {" z; K8 A

        

   

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

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

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

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

   
) f6 F: m3 n2 a: w& A( H* X$ h

        

   
, q3 l! t* v, x& H  W2 H

! d4 @4 \2 e& f$ m7 E, _

   

        

            

        
$ q$ |# o$ X1 c$ }

   
) l5 Z6 B+ ?' f* c8 {

   
9 t7 B4 e5 d% g0 N3 }& \

        
, G, g0 L3 L$ b5 s7 M

        

   

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

Spring2.0之前事务的写法 , g9 F% Y7 B8 j* T1 w2 R7 O) R         class=”org.springframework.transaction.interceptor.TransactionProxyFactoryBean” 9 H9 \6 c  a  U: `9 G) k2 t8 m' g         abstract=”true”> 7 M. u& n5 t( U$ N0 V8 X + i" b) f1 C- q3 w& M! V  f, y# T                PROPAGATION_REQUIRED,readOnly 2 L+ _& ]- b: k6 V0 r 7 M% Q4 ~9 @7 J% @" I& I3 f                PROPAGATION_REQUIRED # V* k" O7 v7 K $ o5 t* d! o( h$ m2 h

% L3 Z; u* V: ~' D  T# j

• 谈谈Spring对事务的支持
  / A1 ~, |& s; T  p9 ^% N
  5 H# R0 j0 j9 ]5 H2 F

  i3 `& O4 r2 `. P0 i! `5 n# G1、声明式事务管理：

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

2.做法：

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

2.2

2.3 注入数据源

+ k+ b9 j# `! T- J8 b

  V% \3 X/ e  E2 l& R) U) _9 U0 G
; ^+ v$ u% _1 C  l: r# S

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

9 K, _9 D8 O5 m( l* o

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

0 U# }: G1 T- T* p
, y+ v7 I, ]3 E9 D
' ^6 z' a9 g+ y* O- M

2.6 定义切入点

) q! w$ z; z- N1 S4 n/ f- t


" s- i4 l. @3 ]2 {+ \* z

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

1.注解@Transcational

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

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

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

' Z0 @! f1 `0 D3 T+ N

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

, e' _" @5 x' y+ r- N7 y1 M

8 L$ o" W2 p; S, s1 C' x

如何在Spring中使用JTA的事务：
& }1 U. i$ G* R" M8 V1 I7 f( X

, A- _* P! b9 u8 _8 Q

admin

事务
9 K: X  o9 O" B+ T. `) j8 zACID
, w5 o8 k" N$ m5 J4 C: q（1）原子性（A）：一系列的操作具有不可分割性，要么成功，要么失败
4 Q2 G8 L' T3 s8 T4 {
（2）一致性 ：操作的前后满足同样的规则，保持平衡。

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

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

2 Y4 \5 `. \% U: j) Y
+ }. W6 b) K1 C+ `. b; n
0 r6 Z3 ^0 G9 I+ r9 b0 G/ `事务模型
（1）经典事务模型又叫平面事务模型（JDBC） 事务不允许嵌套
9 r( W! [, G; S7 H2 D/ F  Z6 L
- t0 }7 r/ r  A) t; I8 L6 y6 c" m（2）嵌套事务模型
( R0 R+ _  n+ N
  L) |9 F: L# ?+ W3 N. T2 ]
  [, L4 A0 C$ `3 V( A
0 L' T3 _+ R  ?% x( i事务的两种方式
（1）声明式
( L$ Y+ n7 x) {8 e( o- ~4 \
) x" j8 X9 z4 ?, a$ y5 b, l在配置文件中设置以下6项

（１）.required
9 p2 L- W/ o: z$ U- N
# Q" o7 L4 `; ~$ f  B+ X! ?: A如果客户端没有事务　在bean中新起一个事务
6 Y9 v4 n* |+ D1 ^2 L8 @# s0 I
如果客户端有事务bean 中就加进去
/ |$ y3 L# x# S3 |
3 N. u& X: T6 {$ n' B. n3 j) z$ W(2)、 requiresNew
& M) J9 ~* R$ B7 e1 m. |4 e7 E* h
5 _2 i/ g9 w+ i1 i# t不管客户端有没有事务服务器段都新起一个事务
8 H& C8 h6 v! {0 h0 R  w
' U. L% o  P9 n7 k& t# t" q& B如果客户端有事务就将事务挂起

- g" r! S" D1 {  B5 q& r(3)、supports
% S& V6 m/ B! V) r& D
# p# p6 w& a) W4 }6 m# V如果客户端没有事务服务端也没有事务
% s, O2 i2 u. r7 ]* `4 R: g
如果客户端有事务服务端就加一个事务

(4)、mandatcry

如果客户端没有事务服务端就会报错
3 t* G- I$ F2 R4 n- Q  ?  O( Q
如果客户端有事务服务端就加事务

' a+ E2 X" \) o- a6 n9 a% I+ o(5)、notSupported
) `2 N: }! I1 i/ H7 `. u4 z. S
5 V2 H& ~. `( k1 I1 Z, u% }不管客户端有没有事务服务端都没有事务

' S# T; }9 Y' P4 D1 F) `: V6 _, }如果客户端有事务服务端就挂起
; A1 A/ a1 i8 n; {% Q
1 p' I# Y8 x) p( o0 M6 R(6)、never
+ v* k; X5 u3 M' y. {2 F
/ G6 L$ w+ Z) B1 F不管客户端有没有事务服务端都没有事务
2 z9 p7 N; b6 L( i6 v
如果客户端有事务就报错

, j; p  k1 n# L( [- p) B（2）编程式事务
6 [$ I: u1 U- P# J  @8 F% J( }
Javax.transaction.UserTranscation
' d  b* k- Y; W, _/ l9 n
JTA 事务可以精确到事务的开始和结束



事务的隔离性
% w4 {1 A/ r2 p" ^Read-uncommited
1 n- @( M! c: z+ K- g% ]+ I
读取未提交的数据（基本上没有锁）脏读，存在不当读取的问题。

Read-commited
4 u* h. ], K. B0 u7 ^& v+ _9 u
读取已提交的数据（行级锁）

无法读取已经写入，但没有被提交的数据。
9 {6 A+ M; j5 R; h9 y) Z
Repeatable_read
8 a9 F7 J# g# q4 G% T( }
) A3 p) h+ |" [1 y7 T读取的数据不允许修改或删除

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

Serializable
+ l7 R6 y% |; s# v
幻影读（表级锁）
4 _. v; L& [1 h9 m3 l

( g0 l3 a9 {% P/ g
struts
开发流程

- _$ Y9 _; Z$ J4 j. \; G% }1、创建表单
0 o5 ~  I8 A) b9 {
* S5 A# o; q4 h; Q# e2、从表单中获得输入

& `4 `9 O% F5 O& I5 P3、处理输入（业务逻辑）
" q2 U+ H/ W' I) y
/ {  J7 o) x8 P! Z: Y4、根据动态输入改变输入流

要完成上述四步，我们需要创建
- C3 |# z0 q% U3 T5 N. m, v( W
: @; \$ T# E% D( U9 o! j1、一个ActionForm
1 F3 Z9 o! }4 C' B8 q
2、一个action

# K' Y# K9 ]: d3、一个配置文件struts-config.xml
8 D6 r0 `" {: r+ [/ l! `; u
4、创建页面

创建ActionForm
$ b1 w) D7 `5 }' ~5 s
1、写一个类继承ActionForm
2 |9 U$ m/ d6 ^+ R
9 }6 a5 e( s  z) p+ F- f2、私有的属性

3 ]' j$ M5 b- l; o2 e9 {) ~3、相应的get、set方法
+ p7 ?+ s. P  G! C9 u4 z
; c6 S! L/ H+ g8 n  M' f) ^4、重写tostring、equals、hashcode三个方法

7 v# J6 x2 e+ H创建action
  m( e9 j9 U- ^; E0 `- o
, ~" ^' ~/ b  s! S" S8 R7 x8 X* w1、写一个类继承Action
) e2 z  M: \" `/ o, b, _
2、实现一个公有的方法（回调方法）
; L0 n6 P, B/ W
( Q' V; _0 i' c, }" R  Kpublic ActionForward execute(ActionMapping mapping,

ActionForm form,
) `, R% \/ Z6 w. ^6 Q$ D# \' l
$ D" `6 @0 v" G) H( t$ x& e5 UHttpServletRequest request,
3 r3 i. ^( o  r- {  u% [) Q
HttpServletResponse response)

{

//1.收集参数

MyActionForm myForm = (MyActionForm)form;
1 |" Y" x6 \8 F2 y" m
//2.组织参数


7 d4 l2 I! |, Q4 @$ u  q4 z8 j/ M% F
! W$ C* F8 \" i, B3 @: d$ e//3.调用逻辑层
7 P- Q7 z/ T" [- C
: \: _1 m/ f( }1 v+ t; Hboolean flag = true;
& W4 Y: Y) W+ b1 ~" y: l
//4.根据返回值来跳转到相应的页面
  n# r+ }6 l) Y! H7 ?
: o$ ~, c, k8 y: r0 h  NActionForward af = new ActionForward();
0 i  M) A( B# I! D% a
. ]; }3 W- x  D9 f! |* y  m. R) C* Jif(flag){

" O8 J' D0 _* c6 waf = mapping.findForward(“1″);
& e/ i- c3 t, ^* c: X
}else{

7 _: _0 P* R6 t+ Q( ]5 w: ~+ \af = mapping.findForward(“2″);

8 v6 C- a, o2 D/ |) Q" I}

# t  ~% n1 o# h/ c6 W. ?. j$ Mreturn af;
+ p- u: F3 r5 T) L1 _" a1 `
: P( I3 r1 f1 \}

. k( H) F, b9 ^  v$ P1 P6 B* e) F4 k配置struts-config.xml文件
9 G9 `& f& ^4 C. B9 h
- I! B; O/ [; S. `0 u4 z1.<form-beans>
& G* I5 `; {7 [" K9 ^  o; E
<form-bean name=”myActionForm” type=”全路径.MyActionForm”/>

1 X. x- c/ I" }! l" z- Y7 M<form-bean />

</form-beans>

" T7 g" c& K2 K5 z+ V3 }: w2.<action-mappings>

<action path=”/sll”
6 U. X4 E# k- t- h5 k
name=”myActionForm”

6 h0 s' N5 h9 _+ ]% R. Rtype=”全路径.MyAction”

' p- E; U& {0 N# Bscope=”session”

input=”错误返回的页面”>
' m0 |1 Q, X: i" `
$ Y4 Q: d" B8 X3 C<forward name=”1″ path=”/1.jsp”>
6 p* n) Z9 n5 d# ?. Y- R
<forward name=”2″ path=”/2.jsp”>
3 H# o1 E5 u& N- e# j, E* Y- S
  o0 N) e! v' i$ H</action>

</action-mappings>
' q( f7 S' C1 C6 l! R5 Y4 V
步骤:
7 H4 C$ j- S' H! i/ G
7 f9 @; a2 u: ?2 y* W' D1.创建一个空的web应用

5 I. e+ i) D$ X! p" C" g2.将struts的包放到lib文件夹下
3 m3 _4 @7 c) @: A! S4 E
3.将.tld文件文件和struts-config.xml、web.xml放到WEB-INF的跟目录下
) K7 p9 ?) `' L. e% d( ~
4.配置struts-config.xml文件和web.xml文件
/ Z7 w! @. Z7 x6 [; r: _
5.在页面引入tag文件uri
- c# x' X( e; D8 X3 U4 M
* Y4 G8 D5 d& L" P# `/ L3 u2 z: KSTRUTS运行机制
/ K$ V" B# g* K, K
1、界面点击产生请求
3 }2 Z  {- p  Y2 a0 d
2、容器接到请求

) `4 x8 N" i% W% k3、匹配web.xml文件中的*.do来调用ActionServlet
3 T6 ?8 i9 i* z0 q
4、ActionServlet的处理
' N4 A4 C8 c) t# G* Y4 }9 I4 m
& s1 z3 v" ^. v" g# z4.1 读struts-congfig.xml文件形成ActionMapping

4.2 通过path 来匹配Action类，通过Action的name属性来匹配ActionForm类
6 M' P* y+ R9 Q0 m8 Y
4.3 通过反射机制来给Form添数据

4.4 由ActionServlet转调Action的execute方法

4.5 得到execute方法的返回值，跳转页面
% T* O/ d, R: l5 D- x: w
$ Q( G$ x9 P( I% e6 a4.5.1 RequestDispatcher

2 l" q, e$ P3 v( Z4.5.2 response.sendRedirect(“list.jsp”);

* i; p5 c: W# f

1 J% U' E& x; ~, V- s; V  Y0 w$ Z进入execute方法

1 收集参数

- x( o+ Y3 O5 u! _' X2 组织参数
, ?+ O% d- \, [" c* b
0 @8 X7 l5 N1 c5 F( m3 m. H  E6 l3 调用，逻辑层

4 返回值

( n) p* E2 |2 h  S! j4 `2 M+ J4.1 选择下一个页面 （ActionForward）

; n' o' L. G4 D4.2 把值传给下一个页面

) M# [* Z2 O/ |. n
2 a# U$ {7 M. Y0 M8 K1 U4 Y# u
比较struts和struts2的不同
' \6 l: E) x  x$ \- C2 G
8 n6 a9 c2 @0 h) Y9 ]Struts

" w: I( y) R* e8 _2 [Struts2
; \2 ^) d. t- i% z
' N4 ^" T' v( ?  `' b组成        五个部分：ActionServlet，ActionMapping，AtcionForward，ActionForm，Action        十个部分：AcionContext，FilterDispatcher，ActionMapper，ActionProxy，Configuration Manager，Action Invocation，Interceptot，Action，Result，Taglib
! W$ j; O8 H7 Lurl        .do        .action
/ x. I* r+ l9 _& p. ]分发控制        AtcionServlet        FilterDispatcher
收集参数        利用JavaBean技术，将数据封装到ActionForm的子类中；
一个Action对应一个ActionForm的子类
: B  B% x0 G& J3 u' F& d
9 q9 s0 m' ]2 t0 z+ m, `使用拦截器将数据封装到值栈中。
使用域模型，一个Action对应多个值栈中的Model
7 J) i. _5 B* Q: F
" b6 H2 M, F/ w6 Q5 T% r% }读取配置文件        ActionMapping        Configuration Manager
拦截器        无拦截器        执行Action前后有拦截器
返回页面        将字符串封装到AtcionForward，进行跳转页面        Action中直接返回字符串，通过Result跳转页面
页面跳转方式        两种：dispatch，redirect        三种：dispatch，redirect，chain
1 Z6 r7 ]6 y/ V" k0 `* {7 D8 U  d值栈        无值栈，Action通过在request范围内设置属性，向jsp页面传递数据        有值栈，Action和jsp页面通过值栈传递数据，jsp页面通过OGNL取得值栈中的数据
( @% _1 P: g3 s配置文件        struts-config.xml        struts.xml
/ L$ c+ }3 b' m( F中文问题        不能解决（需要使用filter）        可以解决中文问题：
1 N" \& q: y2 }' Q) o  u1、在jsp页面添加Meta；

" t; m+ R$ \  B2 @/ Z2、修改struts.properties中的设置。

admin

其他开发工具和技术
* Z5 i0 C8 o( v4 bAnt
Ant是基于java的批处理工具
, Q6 u9 X# j: t
一、配置ant的运行环境
3 }# v% r4 k5 h% u$ j
1.将ant的bin目录添加到path中

. j/ q# R6 \: M; X# H" S2.配置JAVA_HOME

3.配置ANT_HOME

( a( q+ P" i8 K" Z9 B+ |二、配制build.xml文件，该文件放在应用程序的根目录下
- a3 T: k5 z  D4 r" O" Q8 U
编译java文件

" Z0 |' {- o, q. M执行java文件
1 E0 h) j" O% ^9 n: z) u
copy

删除
7 O) G! q  f) L
9 Z0 y7 P8 l) k8 x; j1 [1 d' P打jar包
8 X! d2 ]( ]1 X' i* s: ~
8 R  U' K* U# r1 ~  ], G2 J. x) m根据注解生成配置文件

5 R& p5 K7 N5 s7 R; x- OXdoclet
通过注释生成一系列文件的工具（txt、xml、java、html等）
5 f7 }* P% O( s
/ o, X2 F! c6 U, M: o9 |xdoclet本质是摸板技术+字符串的替换

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

" k% |% Z; a, j2 X: ~. }6 S4 x1.1 在类的上面 写与表的对应
: b: R" }1 N0 n9 h9 O
1.2 将每一个属性的注释都写到get方法的上面
8 O+ p  b  i2 m5 g3 s
2.在ant中引入相应的task来驱动xdoclet
# P1 \. t  W( D# @4 v0 B
3 o8 L9 O3 H) ^, a

$ x% p/ N8 v% q6 O# V2 `log4j日志管理
, c; V9 G/ Q) b/ v8 ^* O1、是什么？

, H- L  J  @" Z在开发期间用来测试、对整个日志信息进行管理的工具
* D, [( r  Z+ R' `
2、功能

+ G, L) P" D( Z1.控制输出的目的地

' _! r# U3 O0 C# b2. 控制输出的格式
8 K: a7 G, y! h/ v) @8 Y% I" G) d
3. 控制输出的级别

- ?% f) P/ j( R3、日志的级别

" n) P$ M0 d) H$ F5 z, l! c4 _$ n1. debug 调试
' i% }& e" {* O2 t$ C8 K% P1 H" J, r0 X
2. info 给用户的提示信息
3 k! l+ w! J1 F6 T8 G
3. warn 给用户的警告信息
+ j# Z  X. S( X3 `- p, l5 \! H& P
$ v" L! ]. i& o/ V8 m' l' N* t8 l4.error 给程序员用来调试

, F8 U1 N3 U- @+ `3 P) ?: M! [0 wDebug—-〉info—-〉warn——–〉error

4、配置
9 h. w- r+ c+ O, O) N
1.配置级别

8 o4 U$ c) l) \" z2.输入源 （控制台和文件）
0 `0 n  s) f- i& e7 Q) @! g2 C: x
3.可以进行分包控制
$ A, f$ M- e8 H
* ]$ b4 [7 J4 G, tLog4f.logger.包结构 = 级别
, p- S3 @6 f: N
* `, p% ?/ J: _4 h) S5、使用

Logger log=Logger.getLogger(Test.class);
7 n) D0 ]2 |/ U2 ]; ~) S! w
    public
& S( ?/ y; a% E% K( U  tvoid t3(){

        log.debug(“this is debug”);

! `# L& n0 Y* o# S7 y/ w        log.info(“this is info”);
/ n9 p8 \9 T. M' @3 a' m4 e1 _
        log.warn(“this is warn “);

        log.error(“this is error”);
2 f$ j/ Q; `* F& r/ F
    }
( o: z1 Y/ f; u: b1 z$ a
Junit
5 ]9 k* R: d- ?- ^1.是什么？

单元测试的框架
2 }( W" R' f" Z$ W3 E1 E' r+ T
. p) @5 k2 |: X* K) I% C2.怎么做？

写一个类继承TestCase
3 ^% j, k1 A" q' K6 d# m- P
! w* E  I  E; u6 x9 U" x9 x测试的方法一般都以test开头并且没有参数
, f; }. P$ T6 {( Y( h. }
在测试方法前执行的方法public void setUp( )
5 X! o8 y6 _: i; ?1 w
在测试方法后执行的方法public void tearDown( )

% n- o+ ^* V" H- U6 _5 i4 R( Xerror和故障的区别
5 w- ]. |! o( I0 H" Y
, m3 c* ]! U) W; oerror ：代码有问题

故障 ：逻辑有问题与祈望的值不相符合
) d) O& M' s, {( q3 Y3 D, |
: _* l# p7 G: G  O, u生命周期

5 N5 e# |; b+ f1 q7 S' o测试—〉SetUp（）—〉testXX（）—〉tearDown（）—〉结束；
$ I6 Y* R- y# U+ {; x  {
: r! ]1 X! U* {7 H3 D- gTestCase套件

public class MyTest{

        Public static Test suite(){

TestSuite suite = new TestSuite();
, _( U* L1 Y0 ]) C7 a* g
2 Z: u  P/ j8 ~& j5 X  e* V5 [3 ssuite.addTestCase(Test1.class);
" ~* Z8 i. h6 u5 ~5 V+ K" m& o6 j; {
. V' |' `( N* J* J/ s6 ^. nsuite.addTestCase(Test2.class);

% T9 c, C2 U- J0 R}
8 ]% \6 T2 z) c- s& t" a# g) N
}



7 g9 s( T: D; S% t+ J! H" a: t7 j1 R, UAjax
是什么？
2 v& [  p5 s9 MAJAX即“Asynchronous JavaScript and XML”（异步JavaScript和XML)。是一种创建交互式网页应用的网页开发技术。
: g# ~4 n+ T" ?  h7 f
无刷新页面。
" Z* P2 t6 z' U; u) J/ `
; @3 q9 y, f+ x! B% U有什么？
AJAX是多种技术的综合，包括JavaScript、XHTML和CSS、DOM、XML 和 XSLT、XMLHttpRequest。

9 L- h5 M9 H, z0 I; W. Z+ ~' V" S能干什么？
使用XHTML+CSS标准化呈现；
使用DOM进行动态显示及交互；
' L: O: E% r! l$ s使用 XML 和 XSLT 进行数据交换及相关操作；
使用 XMLHttpRequest 进行异步数据查询、检索；
( A7 _1 r7 d2 d& M. M7 R# j使用JavaScript绑定和处理有所得数据；
' a( `1 @7 D9 L" j. r1 D
( \1 a. c- o; h: g5 M8 }6 t1 e传统的web应用允许用户填写表单(form)，当提交表单时就向web服务器发送一个请求。服务器接收并处理传来的表单，然後返回一个新的网页。这个做法浪费了许多带宽，因为在前後两个页面中的大部分HTML代码往往是相同的。由于每次应用的交互都需要向服务器发送请求，应用的响应时间就依赖于服务器的响应时间。这导致了用户界面的响应比本地应用慢得多。

, ?* z9 W7 E$ B) R与此不同，AJAX应用可以仅向服务器发送并取回必需的数据，它使用SOAP或其它一些基于XML的web service接口，并在客户端采用JavaScript处理来自服务器的响应。因为在服务器和浏览器之间交换的数据大量减少，结果我们就能看到响应更快的应用。同时很多的处理工作可以在发出请求的客户端机器上完成，所以Web服务器的处理时间也减少了。
2 D/ I- C& T3 U* f; |* Z% ~
( u; p8 m6 p- y6 ?8 v使用Ajax的最大优点，就是能在不更新整个页面的前提下维护数据。这使得Web应用程序更为迅捷地回应用户动作，并避免了在网络上发送那些没有改变过的信息。
' L& }' o/ X7 r
, ?' N. P% n" C对应用Ajax最主要的批评就是：
1 它破坏了浏览器后退按钮的正常行为，就是用户点击后退按钮后不能看到之前的数据；
2 一些手持设备（如手机、PDA等）现在还不能很好的支持Ajax；
0 H5 M4 v3 S( m& V7 t' r5 o! E3 用JavaScript作的Ajax引擎，JavaScript的兼容性和DeBug都是让人头痛的事；
, ?2 i. n5 ]) y4 Ajax的无刷新重载，由于页面的变化没有刷新重载那么明显，所以容易给用户带来困扰――用户不太清楚现在的数据是新的还是已经更新过的；现有的解决有：在相关位置提示、数据更新的区域设计得比较明显、数据更新后给用户提示等;

# B" ?0 i: @$ l, R( E5 T4 A  X2 I怎么做？
<script language=”javascript”>

var req;

function add(){

//1:创建用于传输的对象
/ ]$ t" W4 r: [. i3 ~* i; Q7 I0 F
0 D8 _1 P3 f# Q, g, z$ E/ W% v) dreq=new ActiveXObject(“Microsoft.XMLHTTP”);

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

req.onreadystatechange=manage;

//2:准备传输的内容
& P0 c& r- K: N% o- A
3 X! R) Z) D) q, M3 T; ?$ m4 tvar str=”test1111″;

//3:发出请求
+ w8 ~1 e! _6 e; S; l' s7 N
req.open(“GET” ,”/others/ajax/test/t2.jsp?str=”+str);
0 ]" |5 b5 W6 s4 ?) T/ H" \: V  b
4 G: R9 q' m7 [1 Lreq.send(null);
. `4 l3 @. Y% O! u: E( z1 T6 X
}

' d: N7 q* R0 ?6 R* |//4:接受返回并处理
1 `0 @- c7 l( e' k- p2 T
function manage(){

if(req.readyState==4){
3 b9 c' Q% v1 x# X5 d, @
alert(“r==”+req.responseText);

  ]% a, ~$ y% V* o& E4 `3 z}

# N+ D% [- G! S8 Q}
  f2 o* e" L) l4 b
* _& ^$ e1 R5 _% N) p1 a</script>

readyState的取值如下：
7 v- R; s% E% m+ c+ v& [4 a3 m6 `
　　0 (未初始化)
" u! s$ P# W  w3 g/ [& a
　　1 (正在装载)

　　2 (装载完毕)

  u7 }4 t/ O. |" |! p7 ]　　3 (交互中)
& {& {5 E6 t4 d" a# {
$ ]! X: G, }3 V, d　　4 (完成)
/ s5 N0 E. Y4 T/ E! B$ b

. o, V: t6 E) v7 q& h# b
' n/ U' B/ i& z9 ^7 i8 h# {原理
8 |+ }. X2 t# J! I! q$ r! \1 E' HAjax的原理简单来说通过XmlHttpRequest对象来向服务器发异步请求，从服务器获得数据，可以是xml格式，也可以是一个字符串，然后用javascript来操作DOM而更新页面。

& q. t1 ~4 v, A$ z6 aDwr
2 E- L( e$ U0 j0 I7 z8 t! n$ M  z是什么？
8 _4 @* @) T0 u9 w3 a; Z9 A9 p+ {DWR（Direct Web Remoting）是一个开源的类库，可以帮助开发人员开发包含AJAX技术的页面。它可以允许在页面中使用运行在WEB服务器上的JAVA函数,被调用的JAVA函数就像是在页面中JavaScript方法一样。
" g" X& O; h. h1 w
有什么？
& ~3 D1 f+ |" v* l, _它包含两个主要的部分：允许JavaScript从WEB服务器上一个遵循了AJAX原则的Servlet中获取数据；另外一方面提供了一个JavaScript库可以帮助web开发人员轻松地利用获取的数据来动态改变网页的内容。



能干什么？
4 W' ]" I% R; V  s( `动态地把java类生成为JavaScript，感觉调用就像发生在浏览器端，实际上代码调用发生在服务器端，Dwr负责数据的传递和转换。这种从Java到JavaScript的远程调用功能的方式使DWR用起来有种非常像RMI或者SOAP的常规RPC机制。
6 x! D3 S  H: L5 F
4 M7 d" p1 B; o9 N

怎么做？
① 编写配置文件

web.xml
- P3 X0 Z2 R0 f( j
<servlet>
# P# S7 V. j  c2 r
8 _  d3 r( ~- B. z<servlet-name>dwr-invoker</servlet-name>

<servlet-class>

  @0 c7 T2 B5 m6 Y$ _( m2 _  v* jorg.directwebremoting.servlet.DwrServlet

9 w" U% p6 H/ K/ c7 N</servlet-class>

/ c) `" W1 C; x0 Q<init-param>
% ], P+ b) e8 v9 x" t
: V# k7 I) Z0 g: J4 b) n<param-name>debug</param-name>
4 L1 t* r& a4 d* b8 ]
5 e! b( W9 ~9 Q<param-value>true</param-value>
: r9 g1 e# G1 H3 Q$ K& n
</init-param>

: W, T5 {  d9 D1 x1 A' E$ {: P5 l</servlet>

<servlet-mapping>
$ k, e$ I! R3 {' i8 E
<servlet-name>dwr-invoker</servlet-name>

<url-pattern>/dwr/*</url-pattern>
  q) F5 Z- O1 Y( q7 w
! E- z- @! O8 g  C: _# T3 m( B</servlet-mapping>

dwr.xml
1 o" b0 `! `( w6 q
<allow>

<create creator=”new” javascript=”kc2″>
4 e  U  k" Z! m3 H8 X9 ~% H' e3 Z& M
<param name=”class” value=”dwr.Service” />

</create>
( C9 Q0 U6 I1 W
3 X3 U. _! B! ^+ d' X</allow>

②编写service
/ k0 P6 Z7 \1 h
1 P# ^# S( R* O% X" |public class Service {

public String sayHello(String yourName) {
) `4 C0 ?  g" w# ?
" @% a! f4 x+ Y) k2 S//可以是访问数据库的复杂代码
& s, j$ s% N' k9 P: {
return “Hello World ” + yourName;
' E9 T6 R8 d( E
, L& ]6 S0 B9 `}

}
) s' [/ x/ I; F/ ^. {) w
③测试DWR

将代码放入应用服务器（比如Tomcat），启动。
( b$ j3 n) E) u4 k. @
% K/ z* [) G3 F4 X. G7 H  @然后在地址栏输入http://localhost:8080/你的工程/dwr

④编写jsp页面

1） 要引用3个dwr的js，其中engine.js必须要，如果需要用到dwr提供的一些方便的工具要引用util.js
4 T5 a! \7 p  X4 r- o: I, e
8 u5 g0 E" U- V8 ~* w) L& \" K2） 然后还要引用dwr自动生成的js，dwr/interface/service.js，注意js名字要和dwr.xml配置的一样
4 V4 \! ?% x7 c$ ?* O' `0 b. h
3） js里的service.sayHello和java类的那个有一点区别，多了一个参数，用来得到返回的数据