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

admin

JEE
: C6 I4 {' s) p5 }简述JEE
# h% b+ S$ x  m% VJEE　： JAVA　 PLATFORM　 ENTERPRISE　 EDITION

7 s8 k# T' l$ y' X8 OJEE是一个规范集；
; b) L; v7 N! A6 \
3 f1 U9 b  T) L! J: ]: qJEE是一个框架集；

9 J' w! j! o9 k# p; d5 x1 E' ~  s8 UJEE是一个技术集或API集；

适用于创建服务器端的大型的软件服务系统
7 T; f* k/ ], d# H/ B
0 z0 R+ [) o: @0 d

3 n2 k7 R$ A9 k' {/ oC/S B/S 模式
$ S* r5 u% x0 h/ |' RC/S client/server即客户机/服务器模式，客户端也参与程序的运行与计算（富客户端、胖客户端）
9 [/ B$ l- |( O% |$ p( B1 H
B/S border/server即浏览器/服务器模式，又称为瘦客户端，客户端不参与程序的运行与计算
: P8 j1 o$ M0 f" L+ n' b+ Z! _3 }
: ]) ?0 @2 t/ j4 R! ~3 P

企业级应用（大规模的应用）的特点
4 o( C  L/ G( q0 a8 c: M1.生命周期长、稳定、可靠
! M& c, O7 l; A4 a% j: J5 F
2.组件往往分布在异构的环境中，能够跨平台

  ~  l& H7 U6 ]9 G0 N3.维护性、扩展性、重用性
& e  G, |" H$ W. ~
4.有事务、安全、线程

) Y) }! ~5 a& B% }, e

4 X3 F$ `" F- I1 k; K  j什么是业务逻辑？
依照业务逻辑划分模块，
4 \5 A# n- {8 x- D  _
所谓判定业务　就是具有以下特征：
7 H. @, n( C4 b, W% o: Q
1.业务流程
+ |$ P$ L# K; ^8 _; h6 I2 k9 j
2.业务判断

3.功能组合

9 g; j/ e/ I- l# B* [& I! Y

7 v9 ]$ ~, W( q& D7 u4 r平台（角色）的划分
1.平台供应商。提供满足API集实现的厂商（BEA weblogic IBM webshphere）
( L! q; L5 Y+ ^, D
2.组件供应商
9 R/ l# s$ z& `/ f7 W
- k/ Y" k- e9 \3 _4 |3.组件装配人员
. R# S) D4 ]: i% @) l
; b% S0 u9 F2 @1 \" `4.部署人员

5.系统管理人员
5 }5 B% f# C' v" D
6.工具供应商 提供开发组件所使用的工具（Jbuilder、eclipse）


, H! M3 n$ B5 {
java技术分布（设计架构 模块内部设计）
1.表现层 Servlet、 Jsp、 JavaBean、 Taglib

7 i/ H& Y1 f' g2.逻辑层 EJB(SessionBean)
/ s. M& S" d/ M. ?8 F/ d9 ~
3.数据层 （　JDBC 　EJB（EntityBean））
/ E+ X+ K4 U- g* `
4.服务 JTA（JAVA事务架构） JTS（JAVA事务服务） JAAS（JAVA授权与验证服务）

7 u) b" ~8 N+ q& u& }5.分布式通讯 RMI（IIOP）+JNDI 、JAXP（JAVA 的 XML 架构）

8 W6 J2 N* d* d2 q- p! T# o( SJAVAMAIL（邮件服务）、JMS（消息服务）、IDLC、JCA（JAVA连接器框架 （成））

( e( `5 p4 Z2 @/ ]  x; ^

JEE的体系结构： 是一种组件的体系结构
1.组件 ： 能够完成一定功能的封状体（独立的功能的集合）

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

分为两类：web组件、ejb组件
9 F7 k0 [* t4 _, b$ `# S
2.容器 ： 提供组件的运行环境，并对组件进行管理（一段程序）
9 s6 N3 o" J9 Y( D5 |7 d
管理组件的生命周期
1 G$ v9 y, [* B
2 ]9 \) {1 s) z4 c不能单独运行，必须运行在服务器上
* _- O% A* T* }, @8 A5 E( a$ k/ X( A
程序（组件）通过上下文来调用容器（context）

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

容器通过回调方法来调用组件

分为两类：web容器、ejb容器

3.服务器 ： 提供容器的运行环境，提供大量的JEE基础服务
4 D4 h# _5 `  @: P
web服务器（只提供web服务）

9 U2 ~( }+ i$ P: gjee服务器（提供web、jee服务）

: b6 U% r$ U; g

什么是回调方法
! M2 b- H2 f( r0 X. l  M/ T0 R+ b$ v由容器自动调用的方法，就叫回调方法。


8 i$ K: N$ b+ K. m
; k9 W9 }- H8 Q7 y+ {  DＲＭＩ远程方法的调用机制
" [, a) V  K- s; I例如：Ａ主机有Ｂ（）方法，Ｃ主机有Ｄ（）方法，Ａ　想调用Ｃ主机的Ｄ方法


7 U( i2 m% a5 h2 ^6 L& t% ]
( c; d' u( o$ c$ d) t$ ~
' W3 \) |, D3 D4 c8 c' V$ Z' I3 @  }7 M" ~
学习方法
5 F- _5 q! ?, g5 K( W! R$ z! ]1.规范（熟记） 2.熟悉API 3.多练 4.多想

admin

Servlet

•     描述war包、jar包、ear包的结构
  
  
  

war-                            web文档压缩包

—WEB-INF

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

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

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

, ~3 z2 y/ U2 `  S5 g

jar-                             java文件压缩包

—META-INF

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

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

–META-INF

—Application.xml 配置文件

–*.war

–*.jar

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

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

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

• servlet 与cgi相比的优点？servlet的缺点
  
  " h6 [) ?- z* c" T; S) D% o# D5 ?
  5 J) D6 G, g, p) P

优点：

性能（线程比进程更快）

可伸缩

Java强健且面向对象

Java平台独立

缺点：

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

: y% p9 l- Z- B2 i

• 常用的servlet包的名称是？
  + v2 }* q) k# V7 Z4 C$ |! ?
  % T  Q$ ~6 E" A! E1 z
  0 U: r; v9 F* H! x

javax.servlet

javax.servlet.http

, H, _( I) r& @6 w+ U9 z

• 描述servlet接口的层次结构？
  " {- ?( F8 l( O- U- D% T7 f
  % T" I. k) g  S1 Z$ c
  " x# H% Y. F, p4 q  {

Servlet

–GenericServlet

–HttpServlet

–自己的servlet

ServletRequest

–HttpServletRequest

ServletResponse

–HttpServletResponse

, Q# Q  a5 ]+ [1 B% I+ s8 S1 R

• 对比get方法和post方法？
  
  + ^8 x1 G1 c! F! Z- k
  . _8 r6 x: h/ S( |3 r- W2 E

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

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

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

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

• 归类描述HttpServletRequest接口都完成那些功能
  % k+ P- x, C0 l; }' v& G) Y: `
  ) u) ~3 i$ r" z9 B
  ; g  d% r. I. ~2 Y+ A$ \2 S) `
  • 读取HTTP头标
    # Z7 Z3 y- k" A4 a
  • 读取cookie
    
  • 读取路径信息
    
  • 标识HTTP会话。
    - B8 W8 S' D) K4 r5 i
    

0 |  y) b* \7 O9 {1 O* [  x

• 归类描述HttpServletResponse接口都完成那些功能
  $ _/ S( |; W8 z6 c0 \# A5 n, E6 l  P
  , e! q+ {8 j3 H& @) t. Q/ g
  + c, x3 G; y8 W6 X
  • 设置HTTP头标
    
  • 设置cookie
    " f! d6 g" ~3 I4 [
  • 设定响应的content类型
    . I" X! M: ~) ^
  • 输出返回数据
    * n/ m2 _, E- n+ _2 G) h6 Z; s! A
    

6 Q7 d* L( t# y% u. f+ R

• 描述service方法所完成的基本功能？默认是在那里实现的？
  * k5 N% A! w7 C. v7 \5 N) k+ C
  
  

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

实现：默认在HttpServlet类中实现

• 如何开发自己的Servlet？描述应该做的步骤和每步需要完成的工作
  
  
  

1.引jar包

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

2.开发servlet类

1)首先继承HttpServlet

2)重写 doGet( ) doPost( )

3.部署

安装web服务器，例如Tomcat

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

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

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

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

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

4.启动服务器

• 为何servlet需要部署描述？
  
  7 V+ i$ A& O0 N& i$ M
  

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

• Servlet基本的描述应该是？请写出来
  & `0 u/ q2 ?3 Q* q$ i
  & y1 A8 O4 I, p7 F
  7 {, L3 U: w# x5 N

<servlet>

<servlet-name>Hello</servlet-name>

<servlet-class>com.javakc.web.action.MyServlet</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name>Hello</servlet-name>

<url-pattern>/greeting</url-pattern>

</servlet-mapping>

• 如何在html中使用servlet
  5 J7 i, J! O) t$ f7 y6 W
  
  & g! Y9 L, m0 S# n5 N! W. Q" @

FORM标记

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

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

语法：

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

{HTML form tags and other HTML content}

</FORM>

: K# Y1 k2 T" M6 d6 o( t& W

• 如何接受request中的参数
  ( _2 k, u' j/ N
  + U. h+ |5 X, G. e* HString userName = request.getParameter(“userName”)方法
  9 A* u: v! @( L5 ~7 }
  8 \- F: V7 G* W0 a: K

• 如何接受request中header的值
  % T0 C- o& q0 P& J/ c' B
  
  

request.getHeader(name);

request.getIntHeader(name);

request.getDateHeader(name);

request.getHeaderNames();

• 如何输出html
  4 Q- a9 u7 X- C5 g
  1 p) _1 k' F0 V: ]9 t
  1 A# B! b! ]  k$ @, E6 s- j9 s

PrintWriter pw = response.getWriter();

pw.write(“<html>”);

pw.write(“Hello”);

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

: N1 k5 D: A3 q, n; T4 m

• 如何设置输出的contentType
  ; M) \4 W7 |( X7 ]2 p( D
  4 x# A( D1 M- O) s, {: A# H1 x5 ]
  

response.setContentType(“text/html”)

4 A, t4 C7 ^% b) T

• 描述servlet的生命周期？
  
  
  

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

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

6 ^# h" q( _5 o) H$ q9 s9 ?+ a

• 描述init,service,destroy方法的功能和特点
  
  
  ) a5 O; u8 G1 ~' S& ~1 r0 @

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

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

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

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

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

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

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

• 什么是回调方法？有什么特点？
  ) G" `5 I' j8 \+ M! a! Q
  . X5 f" I4 {5 B) x: x
  " Y6 `* |2 l2 c: k

由容器来调用程序的方法

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

• 如何设置初始化servlet的参数？
  0 Z4 O# r  S1 {7 a  u
  0 Z; g; Y! \- D' e0 y在<servlet>中添加如下配置
  9 R# i3 p  U: [" }. B5 Z/ W9 N
  # Y+ ?+ Q* v: A7 ~

<init-param>

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

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

</init-param>

• 如何获取servlet初始化的参数
  1 q" p  U5 ?7 z8 d' n
  
  

public void init() {

greetingText = getInitParameter(“greetingText”);

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

}

• ServletConfig接口默认实在那里实现的
  
  ! |: F. M7 z- n$ A# [( O8 T
  

GenericServlet类实现ServletConfig接口

( [/ g5 S7 J* N# p6 g$ L: G9 q0 F

• 什么是ServletContext？有什么作用？
  ! V  M! z; b" q5 f% \$ N" M9 W1 E
  
  8 z$ X: m, E; Q* R& {' P6 Y# k( S

Servlet上下文

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

• 如何访问ServletContext接口？是在那里实现的？
  
  
  8 N" f4 R# ?7 a- T/ s1 j* r$ K

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

GenericServlet类实现了ServletContext接口。

5 O  A; x, g; S

• ServletContext接口的功能包括？分别用代码示例
  - S! i) |: [, P6 c
  
  

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

getInitParameterNames() : Enumeration

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

setAttribute(name:String, value:Object)

getAttributeNames() : Enumeration

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

getResourceAsStream(path) : InputStream

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

log(message:String, Throwable:excp)

+ B% h, Z+ V$ l1 c( Z( \

• 如何设置ServletContext的参数？
  
  6 L6 ~' o1 _9 g) {& D4 T) n
  % B! l, W: W, t  O

<context-param>

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

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

</context-param>

* u9 ]9 \& V& q" d

• 如何获取ServletContext设置的参数值？
  
  ! z2 M, `6 n( @- N; m
  $ V6 Q. D7 Y: \" X; l

ServletContext context = this.getServletContext();

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

5 Q) S5 b$ I/ W( J4 H; J: T

• 描述Web应用的生命周期？
  6 _1 f' |' b5 ~/ @1 [: h
  
  

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

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

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

• 如何用代码实现监控Web应用的生命周期？
  7 i! F( G8 F6 L3 I3 d* D, `
  0 g7 m9 I, J8 b& y
  
  

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>

; r% C1 c2 p& w+ {

• web应用中如下错误码示什么意思：400，401，404，500
    t; ~8 p6 ^7 Z+ W5 U
  
  400 Bad Request//错误请求
  401 Unauthorized//未被认可
  404 Not Found//没有创建
  500 Internal Server Error//服务器内部错误
  
  

  m5 f+ ]) q8 R5 B7 a5 Y( K) W

• 描述Web应用中用声明方式来进行错误处理的两种方法
  
  
  

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

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

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

5 L6 p0 s6 y! E4 ~3 ^! p1 B9 A  R

• 描述记录异常日志的方法，都位于那些接口？
  8 T7 R$ s0 S0 w+ W3 h
  
  

GenericServlet：

log(message:String)

log(message:String, Throwable:excp)

ServletContext：

log(message:String)

        log(message:String, excp:Throwable)

% E$ I& }0 R9 N7 O# y8 k

• 什么是会话？
  ! l) w6 C3 E& m% C8 m; l
  ' O  M! c) [: `# y
  

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

( l2 I' M0 k& K) \

• 如何获得会话？
  ' |- C4 a* k4 t6 }
    Z6 W/ z" g; B- b- C1 _  j& |5 L
  HttpSession session = request.getSesseion( );
  
  

" a) S9 s4 O2 l% i" I# u

• 会话Api的基本功能？
  9 h/ [7 l: [6 y4 @/ z% N( m
  0 B  @7 u5 n$ k0 J
  . U; K7 R8 }5 T; I7 l  F

getID() :String

    isNew() :boolean

    getAttribute(name):Object

    setAttribute(name,value)

    removeAttribute(name)

• 如何销毁会话？
  
  2 ^5 M$ s* r* W2 @) ~( x. Q. o
  

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

<session-config>
# y8 }9 k& ~# e+ W

         <session-timeout>10</session-timeout>
" q& t* q8 e" Y& E% S) s& Q& J0 ^

     </session-config>
# ]' B; F& ^4 f" U

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

invalidate()
) H3 f) v( J4 ?  U; C8 W

     getCreationTime() :long

    getLastAccessedTime() :long
) ~% s; |: b1 F4 M$ E% Q3 T

    getMaxInactiveInterval() :int

     setMaxInactiveInterval(int)

9 v. W. a8 V) B. x" z  R  {' V

• 描述会话保持状态的基本原理
  * o: w+ j' w5 e: s; |( d
  
  

    client server
% n4 V$ _5 d' U# P4 q( z, B

# d- p  F9 Q9 E2 A

request

response (sessionid)

request (cookies)
0 v) T( i' E& A9 N) [+ y

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

+ A' n  @- ?! ]% o

• 请描述session和cookie的异同之处
  
  
  

/ H# N$ R$ q8 }) C+ E( W

• 如何读写cookie，代码示例
  
  : X8 ?/ ?1 V$ J* ^7 d, b) \
  

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

response.addCookie(c);

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

        for ( int i=0; i < cookies.length; i++ ) {
7 F+ ]% o0 S4 O9 y

            String key =cookies.getName();
" g3 f5 @5 S5 ?0 z# f' E/ ^

String value = cookies.getValue();

System.out.println(“cook”+i+“:key=”+key+“,value=”+value);
& r# i+ W, J" w- u4 [" f8 @  T

     }

• 什么是URL重写，如何实现，代码示例
  * D( ~. V1 D7 w/ {+ y+ h8 C/ m
  
  

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

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

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

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

/ G# S$ g7 i0 v/ ]2 w8 a

• 描述web应用的4种认证技术
  9 N. }( a' U8 ~: y4 S7 j6 w
  7 [: O5 |# I' H+ ~7 Y
  $ D5 @1 ?" l0 Z  q

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

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

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

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

& Q, c, A. q# }, Q- V7 q8 `- v

• 什么是授权，什么是验证？
  
  & }8 J* S( x2 I; y+ W
  

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

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

; _- f: P/ V# Y. M! L/ j

• 什么是HTTPS
  
  6 R8 w. i7 B, {
  8 A% ]  A) @. {5 p8 E  N

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

• 什么是审计？
  
  , X) G( |) M1 W: u  F, P. C! X/ z
  

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

' N  i! b1 J2 d5 a' K+ \6 L

• 如何实现声明性授权
  5 Z& ^' x6 n# o# _* H
  
  / U5 h) }8 _0 N; v7 C

1、标识web资源集

2、标识角色

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

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

在 web.xml里配

• 描述servlet并发问题？
  & Z  v: O  |. j5 ?) b
  
  

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

• 描述Web应用中的六种属性范围
  ' N) m1 o$ f" Q* f: x4 N
  
  

局部变量（页面范围）

实例变量

类变量

请求属性（请求范围）

会话属性（会话范围）

上下文属性（应用范围）

8 r& @" ]; K: v4 W; `9 v( B

• 指出上述六种哪些是线程安全的
  
  - M' s. O6 Y4 e! p- v
  ! V3 t/ \4 W6 M! h3 E

局部变量和请求属性

' V* M3 [! u* K; U

• 什么是STM？如何实现？
  - G+ u5 ^* C' a
  
  ' a% }; @0 K3 V

SingleThreadModel接口

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

• 如何实现并发管理？
  
  3 F, G) l% J7 K% a/ x1 `
  

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

使用synchronized语法控制并发

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

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

admin

Jsp
* Z# ]  Y# [/ }; H$ t6 _: c; O什么是Jsp?
Java Server Page    结合java和html在服务端动态生成web页面的技术
' V: X* X$ L1 j, f8 X
/ x8 z' l* t) S; Z6 l/ U

描述Jsp页面的运行过程？
# p* E* s3 a3 O1 f& Y第一步：

请求进入Web容器，将JSP页面翻译成Servlet代码
& L% ~8 f$ S3 Q4 L/ t
3 Z+ f4 I( _" a/ b: f& E. |3 z第二步：
3 E  {' y2 u7 @, v# G
* x& w7 d. o1 {" ~. }编译Servlet代码，并将编译过的类文件装入Web容器（JVM）环境

9 v* j! ?* [3 V$ k) q第三步：
( I% a( h/ [" E, q9 m" E% @# C( [
Web容器为JSP页面创建一个Servlet类实例，并执行jspInit方法

/ t3 o3 w3 f1 n4 S: q7 V第四步：

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


. v0 _  J% X" p) J9 i# x2 u! D' t
+ f' e$ i. ?- Y- O描述Jsp页面的五类脚本元素的功能、写法、并示例
注释 <%– –%>
% O6 T, ^. D9 E
2 H; K2 x8 A2 C, l<HTML>
$ T/ q9 i8 e5 Q" c
<%– scripting element –%>
  I! `3 f- `6 L) Z+ ?
) |1 O; ]7 i; P- ?</HTML>
# m( p4 X" W/ {- E
指令标记 <%@ %> 指令标记影响JSP页面的翻译阶段

% g. [' d6 K. u- c<%@ page session=”false” %>
0 U7 O3 g0 m. L4 G4 |
7 s9 S9 G/ z7 m& |- @* d- T1 C3 _. l声明标记 <%! %> 声明标记允许JSP页面开发人员包含类级声明

5 j! t8 ~) ~0 H7 |' G# ~<%! public static final String DEFAULT_NAME = “World”; %>

    脚本标记 <% %> 脚本标记允许JSP页面开发人员在_jspService方法中包含任意的Java代码
: E% p1 a( o6 F. S6 B1 {3 d
    <% int i = 0; %>
' Z( I2 Y1 P8 T9 ?2 i; `- k
$ |2 C8 C3 Z! R- ]  V2 U! s表达式标记 <%= %> 表达式标记封装Java运行时的表达式，其值被送至HTTP响应流 <B>Ten is <%= (2 * 5) %></B>
( S& k+ D; d: S/ k) C1 T

0 [7 w& c5 u; o
描述Jsp页面中的注释种类和写法
HTML注释

<!– HTML注释显示在响应中 –>
7 Y6 ?, l& Y* v5 ?
1 L: ?1 z7 t" r8 l' nJSP页面注释

<%– JSP注释只在JSP代码中可见，不显示在servlet代码或响应中。–%>

Java注释
/ Y& B+ h$ v- o1 B
<%
, ^0 I# W1 a8 s; T4 J
/* Java注释显示在servlet代码中，不显示在响应中
* |' e& N& R+ k5 n. }0 N+ x) d8 W$ ~
2 m2 }' a; b3 I3 `*/
8 I9 K9 v# D, v* K
5 x. D2 F0 z0 C/ }: F8 `%>
8 a2 \3 j$ t) Q; V8 g
6 {* a, a0 R* u. Z; e; N

描述Jsp页面的指令标记的功能、写法、并示例
( {1 r/ Z0 F. N' s指令标记影响JSP页面的翻译阶段
  `: W% A! t  O, ?( p
9 b) Y( v3 h$ Z<%@ page session=”false” %>
- [& T1 b& m0 F. c
<%@ include file=”incl/copyright.html” %>

<%@ taglib %>
$ m! h0 S* a7 ?3 u  ]
6 c1 }" t) z. h$ \; a
3 \0 J* ?/ T4 h9 k
描述Jsp页面的声明标记的功能、写法、并示例
声明标记允许JSP页面开发人员包含类级声明
6 \; q( ^* N" H8 m4 ~1 _1 ?
7 w6 C  T/ D  i& J, w- O1 O写法：
& i4 M6 ~0 Z5 Z2 }) Y
<%! JavaClassDeclaration %>
( h, V- [  S7 g6 L: c1 n
6 V; s* v; D: ~3 Y例：

<%! public static final String DEFAULT_NAME = “World”; %>

<%! public String getName(HttpServletRequest request) {
1 F. K7 |( v# ~; F" q0 }/ ^4 P
6 ]/ N: w% Q3 m; u/ N# oreturn request.getParameter(“name”);
/ @! ~, k4 R' A2 f$ Y8 R3 c0 D( @
}
+ E- F1 Q7 |9 O4 j5 Z" |# u
%>
6 a* U: K3 \2 R# i, H
<%! int counter = 0; %>
* H. b/ H6 S" c
) |1 T. ?+ i9 O. L
! ~6 _/ m) E* k2 j
描述Jsp页面翻译成Servlet的规则
- q; Q# Z/ F" M  H2 e: v) z. f6 [jsp中的注释标记被翻译成Servlet类中的注释
" G) j7 H! X1 I7 p
# R  `6 r3 q9 q4 {) E) x5 ]jsp中的指令标记被翻译成Servlet类中的import语句等
# u  p2 A$ |6 X9 u/ E4 u
  b" d. g. Y* j. _0 \jsp中的声明标记被翻译成Servlet类中的属性
$ _5 s& L$ L6 @' t, u
jsp中的脚本标记被转移到Servlet类中service方法中的代码
  v! H9 q# s) J1 |  A/ L
' \8 b  y- K9 B6 F- r8 R8 K+ ojsp中的表达式标记被翻译成Serlvet类中的write()或者print()方法括号中的代码
  ]5 ]; ^4 L4 I1 g, A, y/ ^. R

6 W/ C( Q2 i1 r4 ~" i
描述Jsp页面的九个预定义变量的功能、用法、并示例
request 与请求相关的HttpServletRequest对象
5 J' J2 n& Q4 Y0 c% E7 N
response 与送回浏览器的响应相关的HttpServletResponse对象
& L, y: v- m6 L% k9 D
6 O. J) M) n+ U0 lout 与响应的输出流相关的JspWriter对象

    session 与给定用户请求会话相关的HttpSession对象，该变量只在JSP页面参
4 a' X$ ]5 p( i" |, {
0 o6 R; G) T  }  k与一个HTTP会话时有意义
6 w8 z6 H3 E, ^6 o! A
0 H. x+ j( \" G! M+ D4 E( R! g. z0 e    application 用于Web应用的ServletContext对象

( z/ g3 s! k  ?- J% k6 \config 与该JSP页面的servlet相关的ServletConfig对象

) Z& ?- @% M6 c/ D3 dpageContext 该对象封装了一个JSP页面请求的环境
* Z% Z8 {- S5 n/ l' }* C
page 该变量与Java编程语言中的this变量等价

    exception 由其它JSP页面抛出的Throwable对象，该变量只在”JSP错误页面”中可用
6 q) q- U) e0 T. k


page指令的功能，写法、并示例，并描述它的如下属性的功能和用法：import、session、buffer、errorPage、isErrorPage、ContentType、pageEncoding
3 m1 o5 V2 {" h% P/ B# Vimport import 定义了一组servlet类定义必须导入的类和包，值是一个由

1 X& E3 ]' B9 C: R2 _' P逗号分隔的完全类名或包的列表。
+ T; I% J. [2 {* g4 Q: B% w+ n
session session 定义JSP页面是否参与HTTP会话，值可以为true（缺省）

) J$ A$ ?& T  ^* U6 x. D或false。

buffer buffer 定义用于输出流（JspWriter对象）的缓冲区大小，值可以为
; x! c( q6 ?! ~) a* Y% C7 X
none或Nkb，缺省为8KB或更大。
* ~' @+ J: l+ t9 o! L
3 ]$ {* l. U9 ~, q7 IerrorPage 用来指定由另一个jsp页面来处理所有该页面抛出的异常

isErrorPage 定义JSP页面为其它JSP页面errorPage属性的目标，值为true或
% r! z) s- Z3 l# C; T* V
. F5 z" y1 x: x. I, u! k' Kfalse（缺省）。
2 Z9 K6 b5 _# X3 _) K) Z' j& [
ContentType 定义输出流的MIME类型，缺省为text/html。

! T$ i1 E/ I5 E* d. tpageEncoding 定义输出流的字符编码，缺省为ISO-8859-1
* L4 q/ T/ K$ x6 x, ~

) _. o( V' S3 s+ W( W; `3 ]
描述MVC各部分的功能？MVC的优点？MVC的缺点？
! I2 k5 {$ Y7 W2 P( u" P" y& oMVC各部分的功能：

Model（模型表示企业数据和业务逻辑）
7 r7 B- {; Z, v2 ]
7 t5 o( Y: K: y: d! k2 n封装应用状态
8 Y( E1 A' Y# W
响应状态查询
' ?) v$ r1 U6 O! T
暴露应用的功能

Controller（控制器接受用户的输入并调用模型和视图去完成用户的需求）
, l  l7 Q. Q* w0 q8 e% }, \1 r+ Q
验证HTTP请求的数据

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

选择用于响应的视图

View（视图是用户看到并与之交互的界面）
- k, G, g$ h' Y* S# T% K6 ]$ ?
产生HTML响应

! U  _' L: F) [请求模型的更新

提供HTML form用于用户请求

+ ~9 x  Y- Y/ rMVC的优点：

        低耦合性：视图层和业务层分离
$ }! g8 J. \3 e! z
  L, P% G* b. C' a% Z高重用性和可适用性

较低的生命周期成本
* g6 N  O  l/ c( E7 u. m
快速的部署

可维护性

/ p) C: X) m! H) [5 [3 R有利于软件工程化管理
$ w- g0 c6 o; D2 P& P8 x- i
, F! D  y4 ]$ I1 v: U, e6 q/ R提高软件的健壮性

& ]: Y7 Q& D# j: Y7 @& EMVC的缺点：

1 }1 I9 v( B& s( f        工作量大，增加工作的复杂性，MVC不适合小型甚至中等规模的应用程序
3 ^/ R% _1 l+ y- a, l+ J
# n# b7 |, w% }  M8 J  L, G1 L

- R0 b; \& K) s什么是Model 1结构，以及结构中各部分的功能
( @$ p$ _% v4 ]5 g; Z结构：jsp+javabean

Model1中使用jsp来处理web应用中的视图控制部分

Javabean收集参数
% {1 u9 `. G4 X1 `6 ^% l


什么是JavaBean?
用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。
/ G8 Q( z, @5 x# P- @6 S9 c

8 M5 u+ Z% r- Y) ]* j4 f
JavaBean的规则？
1 r' p  e, Z2 `$ {1 J- _使用get和set方法定义属性
% O* _9 ?1 s4 T3 v5 D, k+ x
一个无参构造方法
/ X8 F8 ^0 i( ^0 N9 n" d0 [
无public实例变量( 所有属性私有化)


5 n+ N9 c3 ], f0 T* x$ I
什么是jsp标准动作？包含那些？分别都是什么功能？如何使用？
& o4 z  u4 R8 z: dJSP页面中使用类似于XML的标记表示运行时的动作
4 n, H+ `2 L* E$ y& b
jsp:useBean

- J' Y; s. R0 c5 N. f: a; fjsp:setProperty

7 b# u7 T) v& z( Hjsp:getProperty
& Z0 V) O" O4 h6 w- N7 g. }
1 |" v) j) i" H' ~jsp:param
- D. b) B, b1 {. E# g
jsp:include

. E9 `% ~( ^" P& ^0 c: bjsp:forward

/ U* A3 l& G! @: v$ p
3 }2 N' N$ E& x" g5 e+ \4 I8 F3 l
1 s* K  g% A5 g/ V, n用代码示例如下标准动作的使用：useBean、getProperty、setProperty
2 E" R, ~$ h1 A  ]<jsp:useBean

id=”myForms”

class=”com.base.mystruts.forms.MyActionForm” scope=”session” />

    <jsp:setProperty name=”myForms” property=”name” />
2 }$ Z4 B0 F% S; A5 p
<jsp:getProperty name=”myForms” property=”id” />



描述说明Bean的四种scope
! ?) B% }1 ?# J' k" A* rpage

request
% ^+ T6 j: d0 K2 `: ?4 v. D
: ]1 j1 h" d; `. c3 H6 Zsession
* F* ]# Z, l; `) C/ @  u" [
application
" b# z* W" R8 c3 u
1 e6 J8 B$ T  n( b/ H, i
% `7 z7 S9 o4 m$ q7 f  P% w
描述说明页面上的字段和Bean中属性的对应规则
5 k- y3 ^8 A- _# `! T0 R0 [9 Q; fid 指javabean的变量名

class指javabean类的全路径
, Z* W0 `: N1 B* _. A2 ]- [! U6 q
  J( ~6 U0 M. Z0 u. Cscope指javabean的应用范围
& D' C2 \! n4 U+ {: p
name指所用到的javabean的变量名
' F& r7 I) z0 y' m0 }, j
+ l% A- b! o, N) @2 r; \0 x# K. l    property指javabean中的属性

: m. B% P) i$ F2 P- c& V

# K3 [* O3 e% }8 f1 [描述useBean动作的处理过程
9 r+ ^! o: U9 }使用id声明变量
5 q+ K0 ]$ v! ?
试图在指定的范围内查找对象

  m5 E) z/ ~) a/ v: Z$ ]4 ~如果没找到
# ?! h. Q, G9 O+ Y6 y. a
创建一个类的实例
. @) ^( z& ]' T2 o
" X, \' j" z# B: d执行useBean标记体初始化对象
0 m$ k1 n; R2 [5 X- [# L1 s8 X, U
如果找到
" M  [9 n/ m. \* F, Q
/ |6 d1 }( g5 J# H, q8 i& ^     将对象转换为类指定的类型
4 w7 T1 ~8 W9 ]7 ^+ J
' V& X! l) [3 B. z  B
0 j# N' B$ G8 }& J# T
, X3 n: _  W/ P# i: m描述forward动作的功能
使用脚本代码处理请求时，可用jsp:forward 动作产生一个不同的视图，
7 f4 R$ i; i1 y& G2 u" F9 V  p
8 Z+ z6 K0 g; b! R2 x使用同一个request：



什么是Model 2结构，以及结构中各部分的功能
jsp+model+servlet
# }8 G  k* z+ o- L+ s5 y1 x
Model 2架构使用MVC模式，JSP页面充当视图，Servlet充当控制器
1 M  c( Z/ g4 U) i* C0 t0 K7 ^
Servlet控制器：

验证HTML form数据
9 H9 h! I, q$ |6 @* z. E
调用模型中的业务服务
2 [3 L# X$ e$ u7 Z# t. t  s
存储请求（或会话）范围内的域对象

6 m  W, m. o! Q2 A选择下一个用户的视图

JSP页面视图：

使用用户界面（在HTML中）

4 F1 f6 t. Z# Z3 e        访问域对象

6 b2 F, P0 r  z% V! z! n0 |

如何获得分发器？分发器的功能？
上下文对象中的分发器：
6 p9 z  @8 z2 f7 Z+ {3 F
ServletContext context = this.getServletContext();
. l% ^* }; e. C
RequestDispatcher servlet = context.getNamedDispatcher(“MyServlet”);

servlet.forward(request, response);
; k# w, I8 x( d4 _/ v
& }2 R$ v' W1 F9 c; k请求对象中的分发器：
9 x+ B& P7 P! M3 y0 B
  n! H  J( e8 \3 K8 u7 Q( D& LRequestDispatcher view = request.getRequestDispatcher(“tools/nails.jsp”);

  B1 \( {1 v: Y% T6 n. G1 ]view.forward(request, response);

可以将请求转发到另一个jsp页面，并保持请求的传递性
" v% |0 G# }9 B. [" X
: ]" F3 N  v+ u; R* ~
8 B8 k6 L6 s. M2 d6 ~8 f; d- R
2 ~2 L7 S$ ^! U# z, RJsp中页面跳转的两种方式？
使用分发器跳转页面
1 \5 R8 N3 l. h. O2 tRequestDispatcher dispatcher = request.getRequestDispatcher(“url”);

dispatcher.forword(request);
: v) W0 p/ A4 M  v4 N& F
    特点：保持请求的传递（上一次请求中的数据，在下一个请求中仍然可以得到）；
' Z7 N+ h) @5 d) |! b* u7 r. F- ?
; w' k- X- H5 N9 |        转发的页面只能是同一个Web应用程序的其他Web组件

使用重定向跳转页面
response.sendRedirect(“url”);

    特点：产生全新的请求，（上一次请求中的数据，在下一个请求中不能得到）；
7 b) {! Z, u* E0 v) M/ @
        重新定向的页面可以是任意的URL

8 v1 i( A/ a" W7 b/ U8 |$ u3 Q
/ u! K) L$ r5 m! I( m, G
+ K& @" |: r6 h描述Jsp中引入另外页面的两种方法，并比较两种方法的特点？
! _, C4 J' H5 s$ `+ W. K0 t2 i<%@ include file=””%> 在编译期间把另一个页面完全嵌入这个页面,可以说是一个页面

在这里可以共享变量
! C. W4 U4 [: y, I0 V& P& Z$ A
<jsp:include page=””> 动态的再运行期间把另一个页面加入这个页面,可以说是两个

页面，不可以共享变量
$ N% A; \* x5 m; d2 M$ f
( G8 c. ]- ]; p
) \6 Z/ R) s/ s; n
什么是自定义标记
/ c% Y: z* i0 [2 G' @自定义标记库是一个Web组件，

包括：

8 B& w) g+ n9 H/ j# ~5 Q: p1 J" m6 _一个标记库描述符文件（*.tld）

6 I$ R5 m5 \6 Z6 x所有相关的标记处理器类(*.jar)
5 w3 Z( _/ f" R+ Z
9 u9 b3 p) w* V

# Z; ^/ M; x* s) J, k0 [1 Z描述使用自定义标记的步骤，以及每步详细的工作
1 O7 J1 q7 V) I使用自定义标记前，要拿到.tld和.jar两类文件

把.jar文件放到WEB-INF的lib里面。
把.tld文件放到WEB-INF根目录下。
在web.xml中配置。
<taglib>

4 y6 n5 P7 D9 B( [8 u<taglib-uri>http://java.sun.com/jsp/jstl/core</taglib-uri>
2 i, J4 X) j( K
$ Y( R; u9 w: q7 n& n     <taglib-location>/WEB-INF/c.tld</taglib-location>
8 l* S2 \8 C5 ^: G$ K" p
  r0 R  G. Y& U# V7 G) D: i</taglib>

, I+ P6 [0 v3 [( ^( C在页面中引用。
( l1 D7 m- S) `3 v<%@ taglib uri=“http://java.sun.com/jsp/jstl/core” prefix=“s”%>

6 u$ k0 y, a& ^2 O& L9 n$ }uri必须与web.xml中的uri对应
: i9 v2 p' Q% e/ L
prefix是前缀，用来区分是哪一个taglib
! `5 ]7 A9 S, O. z* o
使用标记
格式：<prefix:tag名称 属性>

' v# G: Y4 X7 ^<s:forEach >

admin

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

配置server.xml文件

1.oracle
( l( N2 Y0 F$ T8 ?
( B8 T8 d( I, T3 v0 v7 t( _/ F<Resource name=”jdbc/company” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”
3 q8 b' j+ b; p# N- J" H' }5 i
                        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”
$ @* E9 d- {- q1 u; F2 n( j  u
url=”jdbcracle:thin127.0.0.1:1521rcl”
# R$ `# ~  A# x5 f/ d
driverClassName=”oracle.jdbc.driver.OracleDriver”

username=”aa”
, h: J; e. C* `; t1 S2 |9 M+ p
password=”aa”
6 r7 R5 y4 Z5 l; h% D4 q
7 p' k4 b' k3 ~" _" Z; \maxActive=”50″

maxIdle=”10″

maxWait=”-1″
6 o, W2 ~: Q6 ^0 [9 u4 z
7 K& H, d7 y, E  ?: J2 `/>

$ ], j2 R9 b* `; u4 G, a% Y2.sqlserver

7 P0 ]! r' L) _" m<Resource name=”jdbc/webpage” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”
9 y1 q6 h7 `$ b8 L
        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”

; ]+ O- k( i+ b" B: c8 yurl=”jdbc:jtds:sqlserver://localhost:1433;SelectMethod=cursor;

DatabaseName=webpagetest”

driverClassName=”net.sourceforge.jtds.jdbc.Driver”
7 t- O2 z6 o  A! U, D
# T! h# m# \# susername=”aa”

# ~' h% |" L- V6 @3 G3 O  e+ }password=”aa”

maxActive=”50″
' c$ V& F1 Z1 a% i1 x# _# g+ w/ [8 @
maxIdle=”10″

maxWait=”-1″
+ h8 s( H) T9 {5 t, R
" z* t' J$ _' C/ R% x4 [/>

. B& A+ w9 F& b  G1 j! T1 Y2、配置自己的web应用的xml文件
% l. Z0 S% W% B" P
. M1 n8 r. G' X7 E
- |+ l1 x5 a) }" }6 d% ^
<Context path=”/eb03web” docBase=”F:/workweb/eb03web”
# @1 E. A2 v- b1 x
privileged=”true” antiResourceLocking=”false” antiJARLocking=”false”>

<ResourceLink global=”jdbc/company” name=”jdbc/company” type=”javax.sql.DataSource”/>
% }* w5 Q* o7 q: y: H: @
</Context>
' `: }2 i$ \' k/ L

) I2 m5 S; s0 e9 D* g4 |' Y5 [
7 m, q1 W; H3 O3、配置web.xml文件
1 _+ ~  K6 U# L% y; {; r4 T+ ]( G" L% F
与服务器建立连接
+ s7 F$ i% H5 x9 f7 B8 h) I5 M
<resource-ref>
( V1 s" g/ O4 ?0 W! H1 G$ C, t  \
<res-ref-name>jdbc/company</res-ref-name>

<res-type>javax.sql.DataSource</res-type>
  Q( H; k9 ^2 V8 U: A( ^
<res-auth>Container</res-auth>
* Y! ~- t  ^, `- r7 J% y% h$ E1 ^
* h' c. g% j$ G5 X</resource-ref>

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

//1.在程序单独用时设置系统的属性，在tomcat下可以不用配置，

# r: u3 |' b) `4 O1 r' K/ oSystem.setProperty(Context.PROVIDER_URL,””);

System.setProperty(Context.INITIAL_CONTEXT_FACTORY,””);
. e/ p; r; n: |8 l8 {3 q; u7 L
9 g6 x9 K0 m0 g; }; s8 A/ O//2.创建一个上下文对象
, N  F* |% T/ d- ^
8 \- G( J7 C1 H0 {7 }9 e" c9 f7 ^. UInitialContext context = new InitialContext();

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

6 h. I  i; e( i, @- x7 VDataSource ds = (DataSource)context.lookUp(“java:comp/env/jdbc/company”);

//4.通过数据源建立连接
, h& w' i) J& J( X
ds.getConnection();

admin

ORM对象关系型数据库映射
% w+ {& X& u; M2 {( A- l(Object Relation Mapping)
1 W1 w0 ]' A" V5 Y* m8 o9 x  e8 ?  y6 s
一、映射的特点

+ m. C- n, B0 O! {4 [0 @# t1.一个对象可以对应多个表

5 a+ `( Q7 \) w+ X' @2.一个表可以对应多个对象
; B- ~& T- a6 T$ [% M# {( ?% e
" W" x! t8 K3 v* L2 R3.对象和表的关系不用完全对应

4.对象的属性的名称和表字段的名称可以不同
; ~1 O$ y/ N9 t0 D. y) v$ w
, m3 B6 J6 m2 \& F. ~) ^5.类型可以不同，但数据类型之间可以转换

7 J5 [6 g/ E& [6.对象中必须有主键，数据库的表对主键无所谓
- X4 j+ l! H. H1 Z
; K5 J9 S" Y* m1 O" U; W7.数据库中有主外键关系时，对象中可以有，也可以没有
# h) k4 t& G2 P5 l! i, m3 h! r
9 }8 C! g6 k: p$ a
/ m- r7 s0 r4 o; |2 N( A; x" I8 |
1 g6 X* K1 a( R二 、有一个映射的描述文件————>xml
% T8 a( o" d/ v" K, {
三 、怎样实现描述文件————>一段程序

% t- Y, r, y2 H; z3 L对象 映射（mapping） 数据库

4 Q5 V/ u4 n: nuser
0 B; U) T" \9 W
id=11

9 k/ r: _( p: d1 p: u% w- c- ^( }name=”张三”———— > (1) —————> tbl_user(id,name,age,tel,address)
0 D* Q- m! R! O/ E4 b
/ Z+ g; V. x$ u  Q& i" @- o; {age=25 <————(2) <————

; l7 z* x$ o% g' O, v7 _0 ]0 o
; a) _/ l) `- s' I9 A4 D
( ~# w0 Z  \2 t! A; ^(1)从对象映射到数据库
$ B; ^, C1 k4 ?/ u0 C
1.JDBC

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

# M  T7 w6 ]. A; M3 i3.执行，添加到数据库中


- q8 J: w1 O- _& K( k9 b
(2)从数据库中映射到对象
: ~4 |% E; b& P/ l* k
' @4 H+ ~8 e/ L, p1.JDBC

3 R0 d/ E1 k! C5 @8 k# v8 F" D1 i2.拼接查询sql
: i4 s1 F, t( T6 S5 O
3.ResultSet
$ h5 o* I( \. S( h/ a4 r% ?# a0 f
/ ^! G4 \( a* K: y8 R4.Model
' r5 P" F+ t* i" N3 L1 A

: ]/ |; X, |8 g7 F. ^. X
hibernate
+ L0 M/ [' v4 I2 c3 e* ?6 c开发流程：

是什么？
/ o/ m! e+ Q, n0 d4 Fhibernate是一种基于orm 的轻量级的框架

/ o' x3 p' @4 T" n# A
  _! u  O& G7 v
有什么？
( K0 b! A, O* u3 S1 V% n* B1. session 保持连接状态（依赖事务和连接池）
* t+ B5 m* q! M) J- d
2. Transaction事务

6 U/ ~' `5 s+ D" l3.
Connection Provider 连接池



能干什么？
1.orm

. e. U$ F7 ?4 U2.提供操作数据库的接口，简化数据持久化的编程任务

. d+ p' }5 l) j$ C2 N
4 F# P% \# H3 G8 O- \: E0 h. w
4 q, C! y4 w: [% }怎么做？
; _5 \5 u( v( r6 ~& E& H  `1.搭建hibernate的运行环境，将hibernate的包和hibernate所需要的包拷贝到lib 文件夹下

2.O（vo）

# G; p# ]. E) a7 d, P/ s% A2 m( m4 ]+ a* h3.R （关系型数据库中的表）
+ D4 L$ s: E6 \  b, B* S8 ^: B
2 |) t  R+ _  @2 y; X- X( s8 b4.配置文件

  ~* o$ ~" t0 I, J' x9 @5 x- u( ~4 `4.1 cfg.xml 放在classes根目录下，默认名字为hibernate.cfg.xml

! t: y4 W) i! n& La.与数据库的连接
7 @( U2 V$ m: Y, @  J9 e; \- p
. A; h- J9 y6 h# o. D$ db.可选配置
2 z. q9 x. R' N2 N1 ^- ?$ f) N$ `8 U' X
c.映射资源的注册
, V  T& Q2 {0 X
4.2 hbm.xml文件 名字与类名相同 并且与类放在一起

a. 对象与数据库表之间的映射
" z2 R, J+ E* T" m
% e9 V7 n" Y2 A5 A3 a. Wb. 对象的属性与数据库表的字段之间的映射
0 Y- r4 S* j7 B' X
5 x2 S. W% Q8 u# G6 kc.组件之间的映射

: t0 j, q7 ]  Y! _( ~) m1 Qd.对象与对象之间的关系映射
. R0 l/ J- Q$ d- J; v# ~# H
0 B: @) K' x, p- {' H$ h+ U- f5、客户端
0 W- Z3 Y# m; U# i0 C- a7 U: C
& K4 y( a+ \  v1.得到SessionFactory

% K9 ?" M- y$ V' R. N: p2.通过SessionFactory 工厂来创建Session实例

3 l. m; H, c: N% G$ d8 P3.打开事务

4.操作数据库
# T3 r+ b$ E' }* M. X7 K
5.事务提交

( L5 D$ }% s0 p% ]+ ]* X1 d6.关闭连接

1 U3 Z; h) @: X运行流程：

6 H) w6 M3 P6 j, V. Y; y# d整体流程
+ S) f2 R$ y% P3 g1.通过configuration来读cfg.xml文件

2.得到SessionFactory 工厂（根据数据库的连接来创建sessionfactory）
! T$ Q) Y. Y7 I) Y3 i4 m) a
3.通过SessionFactory 工厂来创建Session实例
6 C% `# W; _( A0 z0 E( M
4.打开事务
- j  z" B, t9 L( F1 s8 N" G
& O6 `" v2 }1 z( u5.通过session的api操作数据库
; V, K4 l6 y3 P
6.事务提交

7.关闭连接


$ O# N, Q0 J! }7 H" R
save
1.to—>po
  n& f3 }  f& E7 v
2.根据model和cfg.xml中映射文件的注册来找到hbm.xml文件
+ l5 K0 m# v  h/ F/ P
3.根据hbm.xml文件和model来动态的拼sql

4.客户端提交或者刷新内存
+ _2 j$ Y) X8 x  m* P
5.执行sql，值放到数据库
, a# L" v. c4 t; u8 X8 T) v- t
# ~* |3 s8 t( G
4 u! |8 H5 m9 E. a% g: Y
update、delete
# }# q$ W2 j% g8 f, s; h* \1.根据model 的id在内存hibernate的缓存中查找该对象
9 K( n2 ]8 R8 _- d, z- S; Z. ~
1 e+ R/ O7 ?7 J6 Y如果内存中没有就到数据库中查找来保证对象的存在
6 [' N3 L5 t- H+ Q. {5 U
, \5 U* p# P" f2.根据model和cfg.xml文件中映射文件的注册来找到hbm.xml文件
1 ~# d. k, ~5 W( C  Z( }
) ?6 y- d; o7 q0 y3.根据model和hbm.xml 文件来动态拼sql

$ b. X+ ]4 z* K1 B: H4.客户端提交或者刷新内存
8 G' g9 L4 U8 h2 S! T
% K. P9 B. W( |5.执行sql
9 p: B  L( p' L* W. E5 U

8 V6 F4 I  m( U$ b+ ^# r
Query
2 D6 A8 r- ]5 mload
. n6 D$ b9 ]/ ^$ `' g* z0 j4 K4 N& u
1.根据model的类型来找到hbm.xml文件
- F4 K) x0 T; U! Y
: {5 ~, d2 @0 w2.判断id对应的对象在缓存中是否存在，如果存在，就直接使用，如果不存在就进行下一步。
8 {( h$ [$ b5 c) `* P4 ?
9 g7 Y! j/ e; ~8 `& A3.用id做为查询条件来动态拼sql

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

3 }( i8 e9 O: C: S: i) V5 h5.返回一个model类型的对象
* Q: D, v$ o" o" g$ U
get

    1.根据model的类型来找到hbm.xml文件
# w: Y+ k( s8 l0 B, Q
2.用id做为查询条件来动态拼sql
9 Y+ Z& w/ H% O  s6 S8 {
3.执行sql 直接在数据库中查找，如果没有查到就会返回null

query
% t+ B) A% j" Z% ^8 s
1.分析hql语句，得到model的类型

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

' _- o1 z6 X0 T1 I0 ~3.根据model和hbm.xml文件来动态拼sql
5 w: w- K2 p8 _6 Y
4.执行sql查询数据库

4 C8 J, n/ F) q& V4 `( ]& D, ]& o5.返回一个resultset

& L/ ^% D" F1 O' R& J( u- z6.循环resultset的值，放到model中在放到集合（List）中
9 M# w% R2 w, Y# C: f

. s! Q: N4 V. }) S
谈谈hibernate缓存机制

. Z" s( E& Y0 y" M+ @8 R4 S缓存其实很直观的理解为放到内存或者硬盘上的一块区域，缓存就是一个缓冲的作用，有很多时候，我们的数据需要经常访问，如果放到数据库中，不是不可，只是效率上低，如果有了中间产物来代替数据库，就省很多事情了。打个比方，去买酱油，不一定一定要去酱油的生产工厂去买。代码中需要数据的时候，可以先到缓存中查找，如果存在，就直接拿数据，不存在就去数据库中取，也省了很多事。
) b7 {; ^  Y  c, T2 T: \2 ]! l


hibernate使用的是二级缓存，有两个级别，分别是Session，SessionFactroy级别，一级缓存是Session级别的缓存，Hiberante来管理的，这个我们一般不用管，二级缓存是SessionFactory级别的，可以进行配置和更改，加载卸载，就是我们平时用的hibernate配置文件中的配置SessionFactory的属性。
5 j) h7 z4 A0 b* e
0 b# v* m( D3 ?
& v- ]0 q# N3 ^# M% L* Z7 C# ?3 `
对一级缓存中的session事务进行数据的预存取，数据在各个session的上下文中存在（单例），当session关闭时，就是session.close( )，整个所有session范围内的数据全部清空；二级缓存默认的情况下是不开启的，如果开启，数据库汇总的所有数据都先copy到二级缓存中，这里要注意的是，一级缓存是每个线程下创建的session缓存区域，可以是多个，二级缓存只有一个区域 ，画个图比较容易理解。
) S  w1 m( Y* g  h/ v


| 一级session缓存| | 一级session缓存| |一级session缓存| |一级session缓存|
" {0 |. ^% @7 o8 Y. i* h) v
| | | |
8 G  p2 y0 I& r
' N; i8 y, D) G$ E: \3 V: c| | | |

—————————————————————————————————
- D2 ~$ i5 q* w8 [% V2 H- H! r
sessionFactroy级别的二级缓存

. t& Z- {6 `2 D——————————————————————————————————————-

|
& z+ Q8 J9 q6 p
+ V+ O1 D7 d3 T+ O|

. I1 i3 E% h) s( k|

% y- y- g6 J6 H( J——————————————————————————————————————
8 b) M6 b$ Y" f  r
: M6 r- T! Z3 _; X* x$ P. l' e: {DB
1 u8 f0 R7 T- a& M% c. e8 C
% v! y2 n+ y- K! w+ W2 ?6 k; j—————————————————————————————————————–

admin

Spring
/ n; {: b& A8 M; n

• 是什么？
  
  8 V9 O, y( ^. Q7 Z$ N4 B1 h

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

1 B0 R5 l! l1 I# `, `3 g( H! h

• 有什么？
  
  % q6 L9 V3 r9 d7 |% ~

每个包的功能：

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

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

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

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

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

AOP ：面向切面编成

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

: h) Q+ r* n, B9 x3 J

• 能干什么？
  ) i: O) \8 \" D
  

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

• 怎么用？
  $ ?# R. E1 c) D$ [% h4 \
  , U8 x6 J0 y" z4 u9 Y0 F) t
  • 搭建web工程，引入spring的jar包
    
  • 在web.xml中添加如下配置
    
    
  
  
  3 F) r! I" D" u& ^+ k) a1 N# f

            contextConfigLocation
2 C  n& r+ d5 p& }1 a2 g

            classpath*:applicationContext*.xml
" H/ Q! U2 u9 e' g9 d

   

        
4 G5 F6 h1 ^0 J6 E

            struts2
  ~$ c) @' J: e

            
' G; U& W, ~3 l8 ?3 o1 D# I7 C

                org.apache.struts2.dispatcher.FilterDispatcher

            
! L' R8 X# d- [2 p* c7 `

        
; j* r8 a& \. t

        
3 A* S. m3 p' s& e; {

            struts2
/ p, N2 x6 h# w# d

            /*
5 J8 D  A$ r+ |; P9 u% g

            
6 W8 N; d% U6 Q  J* P# J" X  ~

                org.springframework.web.context.ContextLoaderListener

            
; j9 R$ K8 a: K0 k! S

        

• 部署
  
  3 |/ S% ]9 G$ G( |9 ]

• 容器和bean
  

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

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

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

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

" l$ a+ E  j8 _' }/ L1 H: B) g

• IOC控制反转
  
  
  
  0 Y; }5 l* V# |5 f% p  ?/ V
  
  从前的应用程序想要得到A的实例他会直接主动的去拿，当用了sping后，应用程序由主动的去取变成被动的等待，由spring来控制应用程序所需要的对象
  
  
  • IOC的优点
    
  1.可以通过IOC来获得实例
  2.可以通过DI来获取注入的资源
  • 配置IOC的原则
    4 x0 W0 j1 G/ C
    • 一定是可变的资源才采用依赖注入
    • 一定是层间的接口或者是模块之间的相互调用才采用依赖注入
      " v! v7 z7 J' u2 Q; X

8 M' t: D8 h  S5 M4 \) Q; u7 v

• DI依赖注入
  

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

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

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

例如：

在配置文件中

/ s& T9 m8 r/ @$ p

: S5 A8 F( T3 S0 q

在应用程序中

Public DBDAO dao ;

Public void setDao(DBDAO dao){

This.dao = dao;

}

3．构造器注入

6 g* G2 Z# {  w9 @( u% Q: P& F

4．ref 表示参照其它的bean

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

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

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

6.lookup注入

7.singleton

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

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

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

8.DI的优点：

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

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

• Aop面向切面编程
  1 N7 d8 t4 e, g6 t6 J. A. Z% l
  

1.AOP面向切面编程 一些较好的模式或者是示例—-范式

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

2.AOP的思想： 主动—->被动（追加功能）
1 L1 I9 N& \3 D) ?$ A/ a, p

3.AOP 的概念

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

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

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

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

5.引入 ：扩展的功能

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

7.aop代理 ：实现机制

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

4.AOP的事件机制
: _, M& Y+ `$ k

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

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

3.找到切入点

4.确定连接点

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

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

+ b, D! t1 v, V% N
+ y" J: a% ?- F4 P# C
8 j: T' Y. H, p! f

- W1 R, S7 J) }( g& d
0 N) Q- w) c5 k" Z6 I7 R- s4 o6 C
; b# b- t" J! O9 m9 _

5. AspectJ

5.1.在xml中配置比较烦琐
' V- l8 X$ e5 q2 ?1 I# }- g

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

6 J! S8 x; b5 }) X- W

         


* [4 h1 J4 w, ~3 t$ P" K         
% K2 K% I' D0 D# J, Q; A$ k

        
% n' P9 y! c9 ]# Y9 N# i

        

expression=“execution(* com.javakc.aop.MyTarget.t*())”/>
/ p  C7 v6 l' f7 G+ K* D; P. r/ N

        
6 h! X* R& Y0 `$ }( b! i

        
! V$ \9 Q8 _2 ]! D  ^7 \" I( A

   

% {5 T; m) q0 Z- A" W/ X

5.3.使用注解的方法相对简单
" Q$ k6 k7 T( h# X9 }

@AspectJ的基本语法

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

直接在类上定义@Aspect
: `  [6 l) T4 \3 q+ J

2.@Pointcut声明切入点
- k% Y2 L; \0 j5 _9 L& L, `

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

2.2、可以使用匿名的pointcut
* z& ]' _% F% W+ U4 w- I7 m

2.3、执行切点的几种方法
0 F( D# @" g5 V+ U

2.3.1 execute（public * 包结构.*.*.（..）） 可以指定到具体的方法
$ c7 K5 u/ a7 P$ s5 K: ?; T

2.3.2 within 指定到包，不能指定到类
7 g% s3 ]1 S* d& f9 i6 @, I, n" d

within（”com.javakc.spring..*”）
7 D$ o2 K4 N4 M% o" U

2.3.3 this 指定到实现接口的所有的实现类
7 f8 o; {) E/ @0 a8 S

2.3.4 target 指定具体的实现类
5 l6 f* U8 Z. T  Y6 d

5.4.advice的五种类型的示例

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

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

追加的方法的参数名字一定要与retrning的名字相同
+ U! Z1 g8 a* k

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

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

得到目标对象的方法的返回值，来作为参数，进行下一步的处理,参数没有顺序，按参数的名字进行匹配
& f; ^6 T; ?  N3 {/ @- o- Q

完成追加的功能

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

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

(2).

     2.直接引用匿名的pointcut

     (1).@AfterReturning(“execution(
; o7 Y! ?8 f! ^- X* k6 r/ b; P

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

     (2).@AfterReturning(pointcut=
" F( Y6 h/ n* B4 D9 y6 S

“com.javakc.spring.schemaaop.TestPointcut.t4() &&
* f3 M* b* S5 u. i4 e, a9 u

args(str)”, returning=”retVal”)
9 t6 A! O4 K! Y9 {+ H2 Q0 M8 C

@AfterReturning (pointcut=”com.javakc.spring.schemaaop.TestPointcut.t4() && args(str)”,returning=”retVal”)
5 D! {+ S" [+ b8 M" }( K

public void testAfterReturning(String str,Object retVal){
: }' y4 Q: ~& q7 \: O5 _# w7 l

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

    }
& u4 k* K' R0 ^& R) ~7 H

5.4.2.@Aronud

     注解@Around环绕追加功能；

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

     必须有参数；第一个参数的类型必须为ProceedingJoinPoint；
6 U5 p' g8 f- _$ @

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

目标对象的方法
7 W2 Z* \8 u" L  p, _" a) X

     1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
3 K( Q5 F( d% J& l2 S/ _

     (1).@Around(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
$ c8 k4 j7 H3 p+ ^8 a/ }& c4 R

     (2).@Around(“com.javakc.spring.schemaaop.TestPointcut.t2()
2 L8 |; {: y' m: P% M2 l

&& args(str)”)
5 g+ e; p- `' g1 Z

2.直接引用匿名的pointcut
" a% `0 l. b! J8 Y- ]3 m

     (1).@Around(“execution(
6 u6 @. E' i% g- P6 y  Z, k+ K1 z1 X

* com.javakc.spring.schemaaop.Api.test1())”)
4 X9 ], P1 x! X" ~, P  U

     (2).@Around(“execution(
9 a1 `8 R" H9 J6 r

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

// @Around(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
9 z/ a: G& d: s5 s" I! N

     @Around(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
% h. j" F+ D* [+ j2 G8 W* f

public void testAround(ProceedingJoinPoint prj,String str) throws Throwable{
' M% ?9 d( ?& X% \: w/ q1 Z- b+ _

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

        Object obj = prj.proceed();
; u8 p8 @3 B. F9 n8 w

        System.out.println(“around1==========after1pointcut==>”+str);
) [( h0 G; U; u  W- Q

    }
, o* v9 d% R; Z

5.4.3.@Before
0 C' \: k1 p% a! z' |4 C: u& _7 [

注解@Before在执行目标对象的方法前追加相应的功能
! m8 z' O9 D% K# E3 g* I# A! |. `

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
) k; x7 A- e' B' h$ e

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

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

注意args后的名称与参数名相同
" E- Q5 Z1 ~2 q/ v& g: B$ F" V9 l

2.直接引用匿名的pointcut
, F' ]8 i0 f! z

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

(2).@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
: G0 Z7 N- _; s' S; z2 `6 ^" ]

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

// @Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
) \( `0 H0 M3 e. `  b9 L2 Q

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

public void testBeforeParam(String str){

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

}
/ A# I2 I4 l2 ~  s3 p

5.4.4.@After

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

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

     (1).@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
9 y4 A! M1 r/ Z

     2.直接引用匿名的pointcut
; r+ A- ^! Q' L# V, Y$ {' c

     (1).@After(“execution(* com.javakc.spring.schemaaop.Api.test1())”)
' i8 n' s/ r- X+ }' q4 @! G: ]

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

    public void testAfter(){

    System.out.println(“after1== >pointcut”);

    }
/ O: W5 S2 p5 {1 v5 M

5.4.5.@AfterThorwing

0 m2 g5 Y, u, p$ o- m

• 描述一下spring中BeanFactory和ApplicationContext的差别
  7 N6 k2 f7 C. i' p) e
  ( A0 b6 b+ D; I5 y" @

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

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

代码示例：

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

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

• 谈谈spring对DAO的支持
  / O& m# N& J% P- O
  

Spring提供的DAO(数据访问对象)支持主要的目的是便于以标准的方式使用不同的数据访问技术。
3 G) \) R$ n  X) {. J* o. d7 }# R

简化 DAO 组件的开发。
Spring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法，用来简化代码开发。
# a2 d5 e# R2 A2 ]" I- X

IoC 容器的使用，提供了 DAO 组件与业务逻辑组件之间的解耦。所有的 DAO 组件，都由容器负责注入到业务逻辑组件中，其业务组件无须关心 DAO 组件的实现。
1 t1 I$ r: ]& D/ R+ [; ^

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

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

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

  N! @' @5 t9 v9 n3 r5 v
) u: s8 y/ y0 V1 A# q3 p

• 谈谈spring对hibernate的支持
  1 P. O% |' U7 c, `1 p5 f; G: Z2 Z
  9 _/ a1 U3 f, `  u; P

在所有的 ORM 框架中， Sping 对 Hibernate 的支持最好。如 SessionFactory 的注入、HibernateTemplate 的简化操作及 DAO 支持等。另外， Spring 还提供了统一的异常体系及声明式事务管理等。
* L7 `+ g1 R, _' u( m) C7 d/ f

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

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

4 }# k+ y/ R7 h" Q) U7 s- J' t8 O5 L

        class=“org.apache.commons.dbcp.BasicDataSource”>
% Q; F/ I! ]3 e( D: o& g! f/ I

        

            oracle.jdbc.driver.OracleDriver
" R6 N+ N- ^5 W- Y% T- t

        
) G7 N+ Z' M$ t

        
6 a6 i! L( b2 Z' Y1 X4 A  a# o" H

            jdbcracle:thinlocalhost:1521rcl
! `: M% {7 a" w9 u. m

        

        
6 K. Z' a3 G0 D/ w

            javakc2

        
6 o8 Q7 ]" ?" p

        
1 b) H/ {* Q! j8 b7 K; k8 V

            javakc2

        
! C3 r  `/ F5 ?7 `, S4 R

   
4 p0 I, I. j" J& M7 c* e( \

4 T# s; s1 o8 V; Y* P4 b  n. \

   

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

        

        
- l! M$ \  Q/ n; L* Y

            
2 z( q3 d" Q5 P6 N  U

                com/javakc/spring/h3/UserModel.hbm.xml
; \( M+ f1 v% |. ^

            

        

        
) u- b1 _* a# `

            
9 g7 I/ i) O" x5 y  u$ Y  N

                hibernate.dialect=org.hibernate.dialect.OracleDialect
% d( s$ V' S& t  F

            
  L! D# A6 a# n' g2 ~

        

   

   
* M' Y; C$ C" l. D

        

   
& O4 t3 J# }& W$ S

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

   

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

        

            java:comp/env/jdbc/myds
0 R4 F& D0 m( E. d9 H* v

        

   

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

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

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

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

   

        

   
+ @# u! q$ V! s; `! U# u

/ v) f! w( \; Q- U

   
& B# _8 p5 Z- w2 e5 I& ~

        
/ ]1 u8 v+ D- }) T

            

        
4 y, X. P1 E: u

   

   

        

        
6 u* `; f( e8 W; U& @' q# ?4 P

   
0 U1 \1 G2 c9 V: M' ]

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

( Y4 @/ E! @- N& J- {6 N2 z

Spring2.0之前事务的写法 ' s6 b- o1 S0 [6 F- }$ z2 ~" a        class=”org.springframework.transaction.interceptor.TransactionProxyFactoryBean”         abstract=”true”> 3 k) l/ S$ I" d! o2 C1 @ 8 m/ J" `% e6 k, S0 W3 q6 o # w: M7 Z1 @! @- p+ _                PROPAGATION_REQUIRED,readOnly ' n: P8 d2 W( a0 @3 h7 w 8 {( ^) @/ B0 W( Q  \$ d0 Y                PROPAGATION_REQUIRED 7 X/ I' A: d! U3 k/ }; K 3 r0 D; |6 H* i5 o( f: n: J1 C, n. W0 Z 7 W8 {* I5 _/ ]& u$ W! Q * S% e$ j9 g0 o; { 8 D" p5 a( p1 E* n& v; B! |

• 谈谈Spring对事务的支持
  
  7 N) \  {8 B( r

1、声明式事务管理：

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

2.做法：

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

2.2

2.3 注入数据源

, u1 o3 i0 l/ W% f3 N



1 r/ M8 o& i! r% H$ U8 s( z9 j: w

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

9 Y. c8 v! c! m! R

2 c+ g$ W1 F+ S: C

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

' \) r( o* g5 t- {9 V4 V2 o/ d2 {
/ N4 }  E5 N' M/ m

: [1 Z  X& j9 B, n, B# N

2.6 定义切入点

, a+ c' E4 l1 q
  h0 I4 S2 o  S
2 G  }1 j4 o" N% |& n7 ?

' C, ]0 _  k$ l3 K' \  a, {3 G0 m1 x; {

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

1.注解@Transcational

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

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

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

) v* {. m, m9 y% B' Y

如何在Spring中使用Hibernate的事务：
* v; r% @) d( \% ]  b6 k

9 S2 [4 W' e& @6 T

0 _0 E: V& l+ [4 d

如何在Spring中使用JTA的事务：
: O. J/ x( J5 |% e* X9 s

$ n, k% G7 M! ]3 k. F: C2 d

admin

事务
ACID
4 [6 k: R" u+ f" I4 `（1）原子性（A）：一系列的操作具有不可分割性，要么成功，要么失败

- l' q8 N; O5 d& r（2）一致性 ：操作的前后满足同样的规则，保持平衡。

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

( [( h+ A8 O, b3 e1 E7 J  ]（4）稳定性 ：保证数据在事务的操作的过程中不会遭到破坏，而且是永久性存储的
  {8 m' e# m6 u
7 L3 b5 H9 a8 |

, L. }% f; \# G, g# v事务模型
（1）经典事务模型又叫平面事务模型（JDBC） 事务不允许嵌套

（2）嵌套事务模型
6 x7 e: i2 j; U" o3 i) |
. c+ x9 z* J5 F2 X

- X+ r# L. G7 u9 c# f: K/ P( f事务的两种方式
8 |, t2 m2 e0 V. a) [（1）声明式

8 W3 ~& G: j/ K# o) d# U( N7 ]在配置文件中设置以下6项
0 T5 z$ Z& `0 U4 u5 {, a' L2 e/ Q
- p# p5 B# \' k" C# F（１）.required

如果客户端没有事务　在bean中新起一个事务

如果客户端有事务bean 中就加进去

1 U( H) e' ]- R(2)、 requiresNew

( o& }7 i8 c2 V& A8 q) {1 G不管客户端有没有事务服务器段都新起一个事务
2 b, C0 h' ~5 j7 Y
如果客户端有事务就将事务挂起
, v- T0 K$ d; k
' w( F& w5 G: A5 g(3)、supports
" O9 D: H- `$ C' k* p' Z
如果客户端没有事务服务端也没有事务

如果客户端有事务服务端就加一个事务

(4)、mandatcry

* L- L% z; z5 M1 h. V- v如果客户端没有事务服务端就会报错
9 H8 q0 Y  u" k8 L
如果客户端有事务服务端就加事务
8 E/ {  A) j1 Z3 N) _' J6 S
(5)、notSupported
0 W3 [& o$ k7 W, t5 n
% E1 i2 U( _; A/ @/ R不管客户端有没有事务服务端都没有事务

6 U4 Y. c, V: q4 i/ q/ }如果客户端有事务服务端就挂起
6 Z+ O6 q# w* Q7 u! r; V" y* d+ A
% K. |  g. z/ X(6)、never
: t* p" Y/ y: \6 Q% Q4 G& U
不管客户端有没有事务服务端都没有事务

如果客户端有事务就报错

（2）编程式事务
0 s3 @  \& H; P5 P! U
! ?6 a# \) [$ T3 c# Q. w7 {Javax.transaction.UserTranscation

8 Q5 T6 q9 u* Y( [5 OJTA 事务可以精确到事务的开始和结束
8 Y/ ]6 a! u/ ~0 i5 R

4 F9 e1 [7 a0 z" S& y6 c
事务的隔离性
Read-uncommited
7 `2 c7 _. D" L
" ~. c: X0 g& E9 i2 x读取未提交的数据（基本上没有锁）脏读，存在不当读取的问题。
5 f: H7 a* |+ s+ S( v  a. M
9 w' d" S. i$ ^6 u# MRead-commited

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

3 Z, l( x6 @1 V4 f9 ?无法读取已经写入，但没有被提交的数据。

* C4 [: @% f* t  b  K0 p3 P* _Repeatable_read

: G. s  H5 f- _/ ^% N( Z  m0 @读取的数据不允许修改或删除
: C( w5 X4 E# L# {
0 W+ n, N& L9 x不可重复读（行级锁+不允许修改/删除）
0 o/ O. L& b: r+ H) e
Serializable

: w; ]8 H( \3 D" U幻影读（表级锁）
' J, x+ w2 D" r0 [


6 N- m6 |! t0 _8 Q$ ~& Kstruts
$ n4 L6 s* J6 C$ [( P' s开发流程
$ L; Y6 [- v& I5 a& V' J
4 {: {5 q3 w. j1、创建表单
# u. e+ w# G5 S: a; T# o1 Z% P% D  G
0 H- m% W/ b1 L5 J: s2、从表单中获得输入

3、处理输入（业务逻辑）
1 Y' Z( W  ]. v# s' {
4、根据动态输入改变输入流

要完成上述四步，我们需要创建
1 i4 X0 V: k, Y* P- ^
1、一个ActionForm

! G" y  ]' Y4 d) d& U& [% ~2、一个action

7 M+ q+ U( O0 B6 n0 C7 K/ E4 h3、一个配置文件struts-config.xml
! K% E( H/ j4 i4 ^! z
4、创建页面
# e6 c4 E  A& r, E
创建ActionForm

1、写一个类继承ActionForm

2、私有的属性

3、相应的get、set方法
$ D1 B" c/ O" r- {6 _
4、重写tostring、equals、hashcode三个方法

创建action
" U& I0 `7 b0 |
: ^4 P$ d7 ^4 Q7 Z9 t' \1、写一个类继承Action

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

8 q  [' x' s/ w# L0 D) G& Upublic ActionForward execute(ActionMapping mapping,

ActionForm form,
! I% w  j/ N4 S" b
+ a6 a# S+ Y. zHttpServletRequest request,

1 `& Z& g. i. s  }; hHttpServletResponse response)
, h7 F7 C/ @" w& P6 ^- F
0 [) k, S3 `/ i( t+ F& _' X) p- L9 B{

3 Z( o7 Y) b( u+ |3 }% G  e. `//1.收集参数
8 P; z& u  _/ W+ U9 H6 B! t
MyActionForm myForm = (MyActionForm)form;

) ]8 F3 I; K7 Y+ N  M: [/ s3 A//2.组织参数
3 h; j/ Y% }; E; o9 Y. Q. j) v
7 F4 m4 o: D3 k

2 Y8 Q# x- L3 ?' f& \, p//3.调用逻辑层
! \6 b( {; S, ?6 U; y' Z- d
boolean flag = true;

6 u$ g. J3 m) Q# V; v6 ?  K+ R& O//4.根据返回值来跳转到相应的页面
) g, _& U, D/ B7 E
/ w* G( ~/ a( `ActionForward af = new ActionForward();
" L9 E7 f" Y& j1 I( }8 \
if(flag){
1 u$ }+ c+ ?5 Y+ ?% p% [; F
2 h! ?1 I' x; T6 g7 Vaf = mapping.findForward(“1″);
2 t( s0 {% y, k* j
}else{

af = mapping.findForward(“2″);

}

return af;

}

配置struts-config.xml文件
8 k4 j6 U) K: v2 l/ w
1.<form-beans>
5 m$ [. c) M0 V2 V: \5 r7 j
  I- L8 n$ j0 T; O5 u6 w  X<form-bean name=”myActionForm” type=”全路径.MyActionForm”/>
6 }3 L, c" ?  C/ |: D- E
! p" n  ^* t7 }3 |1 o. t1 Y<form-bean />

</form-beans>
- i2 |) x" c4 {0 u3 ?9 ?
. X6 z+ a1 k4 h, m" W2.<action-mappings>
: ^$ r- C1 [* _& ], g- t
& O  W  K* a1 A' C% _<action path=”/sll”
5 E0 s% P& @3 ?7 s: ]
name=”myActionForm”

8 U7 O: |% U" V# x* Stype=”全路径.MyAction”
: i% t: c) q/ }. q! l- W/ W
) q) {, @5 `" u+ O, @  Q2 y' z4 ]scope=”session”
# c: b- R+ E- i1 c
. Z0 }. S, L: P$ ^' i  |: Q; ^; xinput=”错误返回的页面”>
3 R, n: @, M; h
<forward name=”1″ path=”/1.jsp”>
- v; }+ ]+ a9 t1 x
3 j8 M7 d; `% V2 @<forward name=”2″ path=”/2.jsp”>

</action>

</action-mappings>

! ~6 I4 N5 `9 b  Q( p. w  y步骤:

/ @/ n- z6 I! j1.创建一个空的web应用

2.将struts的包放到lib文件夹下
7 ^8 K' n. Y2 s3 o7 h
3.将.tld文件文件和struts-config.xml、web.xml放到WEB-INF的跟目录下
0 x( ]. b, `  S* y0 T* \. L5 l
4.配置struts-config.xml文件和web.xml文件
) X6 u. n7 f8 k9 {+ |
- K; j! u6 q! ~' ]5.在页面引入tag文件uri
  F% L! d# e8 G9 V4 R' q, P
STRUTS运行机制
6 p3 W& M/ P& @
1、界面点击产生请求
7 |$ ^6 C% _3 [: a4 _' ^
3 a4 ~& R. u& I- \2、容器接到请求
4 k+ K7 y0 C# e/ p
3、匹配web.xml文件中的*.do来调用ActionServlet
; ^2 I; i5 F: u  X
4、ActionServlet的处理

- h4 [9 f+ L7 C: T$ R$ k: ]4.1 读struts-congfig.xml文件形成ActionMapping
5 e- N! n3 J: B; H  {& \+ V7 Y
& ?' ?8 S# }3 C% C' T( s4.2 通过path 来匹配Action类，通过Action的name属性来匹配ActionForm类

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

4.4 由ActionServlet转调Action的execute方法

' P8 y5 b7 G3 I" {9 K: F+ a3 W  g4.5 得到execute方法的返回值，跳转页面
& q! T  l) H. w( ]# O4 H
4.5.1 RequestDispatcher
6 H0 J3 j' }0 I% C% T4 @
0 Y1 T9 h2 C) L8 z( [" p4.5.2 response.sendRedirect(“list.jsp”);
7 q" Q- K  V8 e* ]1 \


  s+ H* t9 P, T进入execute方法
2 l' M8 v2 t8 V3 |% @& p( R/ U* w
1 收集参数
7 l. W, V: c& L9 K: _
0 G1 l" Q4 ?/ r9 ]2 组织参数

2 d2 H' [6 \0 E  G, ^) m; @3 调用，逻辑层

* y8 {% E# a- ^6 |4 G4 返回值

" @( q* P$ T6 W( s! K& g3 p4.1 选择下一个页面 （ActionForward）
, C$ f' @$ R, _# I6 b, d
4.2 把值传给下一个页面

' R: F( G( W6 e' `" R. I% @
% U  v! d) p3 r% R; @! o
; L/ D# B; q, q% k! U. S. x- Z$ C( n比较struts和struts2的不同
1 J/ I; g8 r5 X- a; R* t
Struts
+ }3 f' b" S2 s/ z& P0 b
9 K6 |* H( k9 }. J4 d! d7 d/ _Struts2

; h5 `/ N3 ?; U8 M! D3 ~组成        五个部分：ActionServlet，ActionMapping，AtcionForward，ActionForm，Action        十个部分：AcionContext，FilterDispatcher，ActionMapper，ActionProxy，Configuration Manager，Action Invocation，Interceptot，Action，Result，Taglib
url        .do        .action
分发控制        AtcionServlet        FilterDispatcher
# M* z, A( a, Q& J3 P, l收集参数        利用JavaBean技术，将数据封装到ActionForm的子类中；
一个Action对应一个ActionForm的子类

使用拦截器将数据封装到值栈中。
使用域模型，一个Action对应多个值栈中的Model

读取配置文件        ActionMapping        Configuration Manager
1 r9 X7 W# {# ^0 }拦截器        无拦截器        执行Action前后有拦截器
返回页面        将字符串封装到AtcionForward，进行跳转页面        Action中直接返回字符串，通过Result跳转页面
页面跳转方式        两种：dispatch，redirect        三种：dispatch，redirect，chain
+ I+ C, ~. w, }9 j值栈        无值栈，Action通过在request范围内设置属性，向jsp页面传递数据        有值栈，Action和jsp页面通过值栈传递数据，jsp页面通过OGNL取得值栈中的数据
配置文件        struts-config.xml        struts.xml
! o+ X/ J& S3 s' g8 F5 h中文问题        不能解决（需要使用filter）        可以解决中文问题：
1、在jsp页面添加Meta；
" V2 f3 I" {; J& e. o
2、修改struts.properties中的设置。

admin

其他开发工具和技术
- D. @& d) a. E: X6 c2 J$ }Ant
Ant是基于java的批处理工具

$ b/ g# [+ i" X' ]3 j2 }' f5 U一、配置ant的运行环境

1.将ant的bin目录添加到path中

7 c0 a) j7 q+ V" V5 a$ o2.配置JAVA_HOME

# z3 R, p! D6 y# I7 B$ b/ v3.配置ANT_HOME

二、配制build.xml文件，该文件放在应用程序的根目录下

: g( O! C, i% U5 G$ w编译java文件
- G7 j8 p1 g+ ]
( G5 w* p' ^3 |1 b7 `6 ?执行java文件
* \* T/ M* r4 n, ]2 [  Y3 r
; r* C- P. a* o# P: tcopy

6 U; y* c9 n) Y8 L) V0 }  ^7 T删除

0 v8 m; g+ H6 B. k& B$ {5 }打jar包

: P# Y- s9 [" _4 f3 i/ ~根据注解生成配置文件

: A! L8 W8 q: t/ N, t" qXdoclet
通过注释生成一系列文件的工具（txt、xml、java、html等）

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

1.在java文件中写符合要求的注释（将hbm.xml文件的内容搬到java文件中去写）
8 y% ^( h% R: `1 `
: O, c5 [+ ^5 q1 Q+ D# ^1.1 在类的上面 写与表的对应
' {/ R% J8 A  n1 O) y+ |
5 l. \5 e5 o9 e8 F: K7 m2 E0 W1.2 将每一个属性的注释都写到get方法的上面

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

& k$ @4 i9 ^* p9 V: o$ w% J8 p

: Z& o- f& J) z2 o$ o: N- blog4j日志管理
( j* v: G% x, X: j1、是什么？
$ v5 F' a; ]3 U
: h$ g3 D( q: J- U' j# ^在开发期间用来测试、对整个日志信息进行管理的工具
% W! _; ?4 K5 p" p8 c) M
. K4 y6 K* b7 s1 a2 ?4 W  z# G2、功能
2 ^' d# C  r; I2 v% q
; j. [& J) c. w1.控制输出的目的地
  T9 w! N) d$ J% D) m7 y8 P
( u, E# z4 n& Q) _2. 控制输出的格式

: C( r# W- `/ m' l  J3. 控制输出的级别

3、日志的级别

1. debug 调试
' _& K! [& W$ i2 ^
2. info 给用户的提示信息
7 o* F) N' ^2 a: i6 s9 X! e
8 T% I! `% i) E4 w3 E3 |! o3. warn 给用户的警告信息

4.error 给程序员用来调试
$ I# l& n) E; a0 G5 C4 w! h: n# i) e2 r; d
Debug—-〉info—-〉warn——–〉error
) k+ t4 Q# v, T% n' _
4、配置

# U8 N# i' O' @" f% ?  }1.配置级别
9 d( j+ z& n$ x( Z  P
+ {: L9 W& R, [" g2 D: A4 s/ O2.输入源 （控制台和文件）
! m$ y8 w$ v# r- F$ s& }2 i& }
5 n, x% T! P0 @0 F* h! W3.可以进行分包控制

+ D: y& U6 Z' O& h( ~( r: Y, VLog4f.logger.包结构 = 级别

5、使用
+ R) w4 o* D- Z% P0 j: G
Logger log=Logger.getLogger(Test.class);

" R$ n, A6 n, n    public
void t3(){

        log.debug(“this is debug”);

3 d! u# J; ]% \# [/ p        log.info(“this is info”);

$ ~8 x+ f0 G; D. {5 E        log.warn(“this is warn “);

3 d' C' v& G2 H$ o& D# r# p, A        log.error(“this is error”);

    }
2 }- Z2 n7 G4 y3 z* e; L4 K
Junit
1.是什么？
& h' J% _5 t9 p0 h$ z1 s2 B% c2 Y, d2 ]1 y
4 P0 |  o' B: d$ _) H单元测试的框架
3 u# {, l' s. o. k
2.怎么做？

写一个类继承TestCase

测试的方法一般都以test开头并且没有参数
- M. ^& `. \9 }2 ^; S# |2 s- Y
$ P9 P% q8 [* B( _0 W在测试方法前执行的方法public void setUp( )
5 T1 Z3 Z" l" N3 E* G7 ^1 Q
在测试方法后执行的方法public void tearDown( )

error和故障的区别
8 F, Q5 E5 O: S4 ^& t; K; u3 S
error ：代码有问题

2 l% B/ c$ n( m1 N故障 ：逻辑有问题与祈望的值不相符合

生命周期
7 `2 \+ s3 ]' o- |5 ~, f/ G
, q, m& P7 s: t! M测试—〉SetUp（）—〉testXX（）—〉tearDown（）—〉结束；

4 @+ b( y8 S) V# O, TTestCase套件
* N1 [* \- a2 k- Q# h+ t, U3 v) T
public class MyTest{

, A9 Y! I" r- u, m9 ]        Public static Test suite(){

0 c  h/ w1 e: D5 F7 k( NTestSuite suite = new TestSuite();

3 M5 P  U2 ^2 m) A: W* B8 S- isuite.addTestCase(Test1.class);

suite.addTestCase(Test2.class);

; L( z- j2 k/ h1 O" m( y+ z}

/ Y2 n# m6 K- n: c; Y}


: I* h! }6 Z8 e) H
Ajax
是什么？
- D3 |8 ]. k; T/ a% V8 dAJAX即“Asynchronous JavaScript and XML”（异步JavaScript和XML)。是一种创建交互式网页应用的网页开发技术。
4 Z; _. H3 h2 \+ a9 Z
无刷新页面。
6 O3 d' g+ Z" M; m9 B: D
有什么？
* I. K/ O% a- i, kAJAX是多种技术的综合，包括JavaScript、XHTML和CSS、DOM、XML 和 XSLT、XMLHttpRequest。

能干什么？
( D. k& Q0 F/ l9 B! W& D# `  T使用XHTML+CSS标准化呈现；
: C9 F; q3 ?4 ^; Z+ k. a  f使用DOM进行动态显示及交互；
& C  i/ q+ V% K* h7 m使用 XML 和 XSLT 进行数据交换及相关操作；
6 q& d% l5 ]$ g! Q$ L使用 XMLHttpRequest 进行异步数据查询、检索；
% R% S, \! U5 ~/ J使用JavaScript绑定和处理有所得数据；

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

& O; l6 A) E6 O+ G- ^. M使用Ajax的最大优点，就是能在不更新整个页面的前提下维护数据。这使得Web应用程序更为迅捷地回应用户动作，并避免了在网络上发送那些没有改变过的信息。

+ u( R0 P  A$ s# F- U9 H9 Z对应用Ajax最主要的批评就是：
1 它破坏了浏览器后退按钮的正常行为，就是用户点击后退按钮后不能看到之前的数据；
2 一些手持设备（如手机、PDA等）现在还不能很好的支持Ajax；
6 r9 k: U1 k9 C9 O; B3 用JavaScript作的Ajax引擎，JavaScript的兼容性和DeBug都是让人头痛的事；
4 Ajax的无刷新重载，由于页面的变化没有刷新重载那么明显，所以容易给用户带来困扰――用户不太清楚现在的数据是新的还是已经更新过的；现有的解决有：在相关位置提示、数据更新的区域设计得比较明显、数据更新后给用户提示等;

& `* x3 V7 Q8 C; i+ R0 O; q: t# n! z怎么做？
<script language=”javascript”>
" n: I8 |. L" \+ f) }8 x* e
. a5 a8 g4 P- Gvar req;

function add(){

; z5 l5 S1 h+ ]% ]1 c3 }  x5 d//1:创建用于传输的对象
4 X& ]: B5 e3 f& t
( F2 D- `8 {- m2 K# @3 treq=new ActiveXObject(“Microsoft.XMLHTTP”);
+ I' E* _4 O4 k  J" H3 T. K- O6 U
3 B" F3 L: d- L9 w" l$ j// 声明返回后，处理数据的方法
- l0 G" Z, m7 l5 d; v% S
& J: ~# w3 h: _1 f# R+ ?req.onreadystatechange=manage;

) `# j; I7 P; c) ]% a//2:准备传输的内容
/ O4 C2 C5 Y! `( ^
# |6 i, n; n; q5 S6 y8 Avar str=”test1111″;

- O6 P& D4 G. a//3:发出请求

req.open(“GET” ,”/others/ajax/test/t2.jsp?str=”+str);
' n- G: t, \( o4 ~
* P* C7 j* X7 yreq.send(null);

}

. ~. O9 Z5 x7 V- D. C( }# P) X//4:接受返回并处理
. i) P# z! a* h' y5 V! E
! ~' L' S, i' R+ v' P& J' e% ifunction manage(){

if(req.readyState==4){

$ E% \# S8 l5 v- Oalert(“r==”+req.responseText);
- e" T0 `9 }5 C
! g9 Q  p* S3 E5 ]}

: k* d& f! a# [/ X# f$ H: k0 u}

</script>

readyState的取值如下：

7 }0 L# i& c# i( x3 Z# D+ D6 I　　0 (未初始化)
. y( }/ M$ f: a1 _3 |
3 Z" ?% A& l3 N3 y　　1 (正在装载)

　　2 (装载完毕)
& Y( `5 ^; O' W( O- V  t7 c
　　3 (交互中)
4 B  V0 s; a7 \6 ?6 y' A6 N
/ y! p) \1 t6 O+ _　　4 (完成)

$ C1 T  s6 a8 n" x" y8 o
& m2 n$ J; I$ j& ^% `2 V
" p/ _; Q1 V2 Q原理
Ajax的原理简单来说通过XmlHttpRequest对象来向服务器发异步请求，从服务器获得数据，可以是xml格式，也可以是一个字符串，然后用javascript来操作DOM而更新页面。

0 r: u7 J5 j* I* Y" lDwr
是什么？
& A' o& S4 Z( G  X( ^. iDWR（Direct Web Remoting）是一个开源的类库，可以帮助开发人员开发包含AJAX技术的页面。它可以允许在页面中使用运行在WEB服务器上的JAVA函数,被调用的JAVA函数就像是在页面中JavaScript方法一样。

有什么？
2 D) I: j8 g  G! r7 @6 [7 e它包含两个主要的部分：允许JavaScript从WEB服务器上一个遵循了AJAX原则的Servlet中获取数据；另外一方面提供了一个JavaScript库可以帮助web开发人员轻松地利用获取的数据来动态改变网页的内容。
: }1 Z; t& N+ L) o' @( A

# @$ B7 Q7 {7 n
能干什么？
动态地把java类生成为JavaScript，感觉调用就像发生在浏览器端，实际上代码调用发生在服务器端，Dwr负责数据的传递和转换。这种从Java到JavaScript的远程调用功能的方式使DWR用起来有种非常像RMI或者SOAP的常规RPC机制。
0 F$ I( @- x8 P" ~" c/ K7 Z4 s
( [: a* R0 [7 w2 @+ c
1 w9 m  \1 _5 V) y2 Q4 O
+ k  o( o/ l. A* o* @怎么做？
① 编写配置文件
' I: z5 o3 \7 E9 [  S& H/ P
web.xml

; L! a1 Z, V2 G+ ^<servlet>
0 R- c6 d: z4 ]: t8 G1 s) w
3 q/ h! q3 p, T6 B' B6 \, Q' V<servlet-name>dwr-invoker</servlet-name>
7 @% e+ {! P$ H
<servlet-class>
" j5 e) O8 P1 Z! o
2 p/ n+ T& K* Z/ k  oorg.directwebremoting.servlet.DwrServlet

</servlet-class>

7 r3 |" ]) i7 E<init-param>

# M. e. s* r  y* ^. k5 }0 A<param-name>debug</param-name>
: d% I9 C3 f# S( S+ y
<param-value>true</param-value>

</init-param>

</servlet>

<servlet-mapping>
4 K0 Y' L5 V3 o/ i
& C4 I& A) d# G  `+ r! i<servlet-name>dwr-invoker</servlet-name>
6 Y+ _2 e5 B$ L- I9 V! i
* j3 d! ^; V8 T( K7 J  f<url-pattern>/dwr/*</url-pattern>

</servlet-mapping>
. I, E0 B( E3 G6 L7 Z3 I
dwr.xml

6 p; N; T5 Y. i5 {0 M<allow>
7 s9 T7 S# ?% ^; C, w. P! E
<create creator=”new” javascript=”kc2″>
- I0 K, i$ V; j, m; s. V
<param name=”class” value=”dwr.Service” />
; R  ]/ O0 P- h) n8 e1 c8 q. m# N. b
6 p* D$ I5 O8 w( v; o</create>

; ]2 H+ q! J, d0 U2 i</allow>

②编写service
0 D- d8 z8 h+ H& H& D
- M& k4 g# b# j( @( Cpublic class Service {
8 T4 S" V  X8 z
public String sayHello(String yourName) {
  m2 \$ ~0 {  I' L7 v  a+ X
0 x! t; y% F4 g& U3 K' t//可以是访问数据库的复杂代码
$ _, z& W; T4 h6 Q% b' K$ m% f9 ^
return “Hello World ” + yourName;
  ~; _( V( |/ j+ p5 z6 }0 a3 q
}
* \0 T& q' E4 L1 ]: H& y
2 ?! [8 d# E/ V  U}
, g! E3 a" `7 v- G3 ~1 N
③测试DWR

将代码放入应用服务器（比如Tomcat），启动。
% P1 i7 J, `! o$ X
1 v- ~- h' U% _. E+ i9 G然后在地址栏输入http://localhost:8080/你的工程/dwr

7 P9 N9 P6 k+ _2 q/ V④编写jsp页面

1） 要引用3个dwr的js，其中engine.js必须要，如果需要用到dwr提供的一些方便的工具要引用util.js
  ^4 R/ a! S1 I# P4 I) ^0 I; J! t
0 y; m3 r9 B( G1 C' r2） 然后还要引用dwr自动生成的js，dwr/interface/service.js，注意js名字要和dwr.xml配置的一样

3） js里的service.sayHello和java类的那个有一点区别，多了一个参数，用来得到返回的数据