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

admin

JEE
简述JEE
9 d/ X1 k3 m2 OJEE　： JAVA　 PLATFORM　 ENTERPRISE　 EDITION
; K& I; e% D* E- Z$ o6 o
+ ]3 \. M# b5 w2 }7 yJEE是一个规范集；

: a: ?! |: s; ?4 x( ]' i! [; FJEE是一个框架集；
: n( D6 L' D2 I2 x% }
! E1 g! }: @5 M- h! z3 M7 q# m5 QJEE是一个技术集或API集；

& ~) m, H$ C* y" ]适用于创建服务器端的大型的软件服务系统


. y4 [% i, V4 D$ M1 x2 Q
/ t9 I) h: P' z( Q1 _0 DC/S B/S 模式
C/S client/server即客户机/服务器模式，客户端也参与程序的运行与计算（富客户端、胖客户端）
7 \- U0 T# M/ y8 R8 Z
B/S border/server即浏览器/服务器模式，又称为瘦客户端，客户端不参与程序的运行与计算



" B. X, y& k4 y! c' \5 U企业级应用（大规模的应用）的特点
. C: z; i" A1 R% a9 v: ]) |+ K1.生命周期长、稳定、可靠

% A( ?& T6 L; U5 I8 Y2.组件往往分布在异构的环境中，能够跨平台

3.维护性、扩展性、重用性

4.有事务、安全、线程
8 ]7 U- W, {* g4 Q8 f( U6 }5 F+ q
! M6 K& O" O: \; y+ s' V

. j6 c: M5 g2 N8 a3 Y  Q什么是业务逻辑？
依照业务逻辑划分模块，

所谓判定业务　就是具有以下特征：
- [. q  a; c6 X
1.业务流程

$ M$ {6 h3 `+ q- c/ K, Y2.业务判断

3.功能组合
" v1 q* k. [/ r% k' q. b

5 M+ _# d8 f9 W3 _7 ]- v
9 ^- B, G1 A, Q  d  M- A1 G平台（角色）的划分
1.平台供应商。提供满足API集实现的厂商（BEA weblogic IBM webshphere）
3 }/ T0 x6 s9 T7 q
3 j' b) N: Y( y, f% y' {2.组件供应商
) g: z1 f& P# r7 i
5 m1 E( n, f1 K) }3.组件装配人员

+ R. Z5 ~4 S5 E7 a6 D* v0 c4.部署人员

5.系统管理人员

/ {  g% B' j6 }( b3 h6.工具供应商 提供开发组件所使用的工具（Jbuilder、eclipse）

" L5 x. }# S" A, ~3 E1 _
! i3 n2 c. |& d9 _4 C
5 M" `/ W) b0 ^. |7 r2 ?java技术分布（设计架构 模块内部设计）
1 [; }% H2 z. z( V$ c/ E; k, K1.表现层 Servlet、 Jsp、 JavaBean、 Taglib

2.逻辑层 EJB(SessionBean)

! O3 m# u  X4 }2 K3.数据层 （　JDBC 　EJB（EntityBean））

4.服务 JTA（JAVA事务架构） JTS（JAVA事务服务） JAAS（JAVA授权与验证服务）

4 W, w( V9 C+ Q. N( W5.分布式通讯 RMI（IIOP）+JNDI 、JAXP（JAVA 的 XML 架构）
% j7 q9 U) D* n+ C: b* S, T
JAVAMAIL（邮件服务）、JMS（消息服务）、IDLC、JCA（JAVA连接器框架 （成））


- A% u1 l, v! Q
3 E" V) E3 X( _- P$ kJEE的体系结构： 是一种组件的体系结构
1.组件 ： 能够完成一定功能的封状体（独立的功能的集合）
. d- U4 G% D1 A. b; p+ _) W8 J
" h  S5 i9 |, Z9 _4 H不能单独运行，必须运行在容器上
, a) k! r( g6 o: p' a% c$ b
分为两类：web组件、ejb组件
7 y0 v" e' c- Q6 j3 w
& y/ Z& h. D2 n+ q3 D; c2.容器 ： 提供组件的运行环境，并对组件进行管理（一段程序）
+ m5 Z! R* I; }9 {, o; F
管理组件的生命周期
6 F. t# s$ O: `/ k1 u" ^3 l1 ]
# s- W, O2 \7 e5 O+ }8 h  _不能单独运行，必须运行在服务器上
5 V! {1 Y% I, @2 Y( K! V0 e
% g9 `# W9 c/ k$ c+ a程序（组件）通过上下文来调用容器（context）
0 S( f3 ~- S+ E7 V; N4 N) v; L
组件通过web.xml向容器描述自己，使容器能够认识组件

( H; m" H( L- G: D: D* X  H容器通过回调方法来调用组件
2 n: R$ P  y$ m4 \2 v* i+ f
9 Z3 k. d8 H$ I3 Z5 Z( G分为两类：web容器、ejb容器

% E% i+ a& \; U7 {& v3.服务器 ： 提供容器的运行环境，提供大量的JEE基础服务

! G3 V/ }% Q' ~1 Oweb服务器（只提供web服务）
. A) Z5 H# b; i' ]# Y
jee服务器（提供web、jee服务）

8 B2 T7 m% l1 S

什么是回调方法
由容器自动调用的方法，就叫回调方法。

  v# o* z7 u  @+ A

ＲＭＩ远程方法的调用机制
4 z" G* A8 G# q- ]8 Y/ D2 @例如：Ａ主机有Ｂ（）方法，Ｃ主机有Ｄ（）方法，Ａ　想调用Ｃ主机的Ｄ方法

& @1 a4 E( E! i5 p. ]: H* |



6 g+ P( N- ~9 D; T/ m* ?* }# Q学习方法
3 h3 |, u, U& \7 f1.规范（熟记） 2.熟悉API 3.多练 4.多想

admin

Servlet

•     描述war包、jar包、ear包的结构
  
  1 r! i, ?$ Y3 x( z
  ' n  K- a/ o3 ]5 o, Y

war-                            web文档压缩包

—WEB-INF

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

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

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

) H5 D. s# q/ X2 v' }7 ?

jar-                             java文件压缩包

—META-INF

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

0 `7 A, P( u% X) Q, r% q

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

–META-INF

—Application.xml 配置文件

–*.war

–*.jar

; k$ s" p" ?) l9 h8 a

• 什么是servlet？servlet主要做什么？
  " Y8 J2 v" `" W4 S, Q
  
  3 R- k' u6 j( s/ f5 `- W& Q- \5 s

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

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

• servlet 与cgi相比的优点？servlet的缺点
  
  2 G  f$ V7 G2 T$ w7 @
  

优点：

性能（线程比进程更快）

可伸缩

Java强健且面向对象

Java平台独立

缺点：

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

' R8 x  E* ?+ m0 x, y* p6 @

• 常用的servlet包的名称是？
  8 L" N& u/ H  P5 z: L
  
  

javax.servlet

javax.servlet.http

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

Servlet

–GenericServlet

–HttpServlet

–自己的servlet

ServletRequest

–HttpServletRequest

ServletResponse

–HttpServletResponse

% d0 x! s7 U* u) W  f% R; x

• 对比get方法和post方法？
  , [( n; n9 `7 f7 x- z4 C
  : z% d- t6 n0 U7 i" \+ ]* J
  

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

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

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

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

' T7 l7 G, Z" [  _4 d

• 归类描述HttpServletRequest接口都完成那些功能
  9 p- p) Q7 E  l2 F% u; Z
  
  
  • 读取HTTP头标
    
  • 读取cookie
    
  • 读取路径信息
    & q( L" m- R) ?- C9 o- ^
  • 标识HTTP会话。
    
    

• 归类描述HttpServletResponse接口都完成那些功能
  
  
  2 D+ _# ^% M& [3 g& N2 o/ m
  • 设置HTTP头标
    
  • 设置cookie
    8 z( v+ |. C& s$ J
  • 设定响应的content类型
    
  • 输出返回数据
    7 j' u* L  p2 }5 r
    

• 描述service方法所完成的基本功能？默认是在那里实现的？
    L4 |( N# `( w! z9 u* s# X
  
  

基本功能：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.启动服务器

1 V9 ^! R4 `" r2 X1 Z$ W: G4 n; N+ `( q

• 为何servlet需要部署描述？
  
  
  

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

• Servlet基本的描述应该是？请写出来
  
  ) [' `8 Q  Q4 C  D5 r
  2 f- }' H  y4 H. r& |

) Y) [$ \9 r; y; q/ F# q4 v, j

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

( L8 n4 N( w# X5 W: q1 v9 T$ a) g

• 如何在html中使用servlet
  0 W3 O  @, d6 Q* m2 p% d: T
  ' l% \: j; O% d2 S
  

FORM标记

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

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

语法：

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

{HTML form tags and other HTML content}

</FORM>

3 D+ X+ t2 G2 i' @. r

• 如何接受request中的参数
  
  5 W' K, p  t1 G, bString userName = request.getParameter(“userName”)方法
  ) u) J! @/ y7 ~2 e. X
  

1 D* ?& i+ Y5 O7 g, J

• 如何接受request中header的值
  
  0 t3 q) Y' E3 Y2 |: E
  3 g' q# b# D- N, u- d: W) I- h

request.getHeader(name);

request.getIntHeader(name);

request.getDateHeader(name);

request.getHeaderNames();

: H5 E9 h' j' Q" J7 O3 o

• 如何输出html
  $ t5 c- O) ^6 l$ p4 C+ {
  
  - C+ q1 w) {8 b3 }" c9 ^

PrintWriter pw = response.getWriter();

pw.write(“<html>”);

pw.write(“Hello”);

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

  A+ Z/ H' }4 W2 _$ @* O

• 如何设置输出的contentType
  
  
  

response.setContentType(“text/html”)

• 描述servlet的生命周期？
  
  2 z# S5 v8 B% W4 q. n
  

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

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

• 描述init,service,destroy方法的功能和特点
  
  
  

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

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

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

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

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

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

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

• 什么是回调方法？有什么特点？
  
  
  ' ^$ U# P/ c0 v! ]  _9 j: a

由容器来调用程序的方法

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

! q4 T% b' j' L% j: ^- ?

• 如何设置初始化servlet的参数？
  ! I; q! c2 H' ~" j) L( u
  + o9 e( ]( Q+ t  ~# u在<servlet>中添加如下配置
  
  

<init-param>

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

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

</init-param>

$ A. c5 r9 C  M+ D6 p7 ]  _

• 如何获取servlet初始化的参数
  
  
  

public void init() {

greetingText = getInitParameter(“greetingText”);

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

}

8 U% N! q" D/ L4 `7 Z

• ServletConfig接口默认实在那里实现的
  
  ; r0 D! \( v( K: R- ?& Q
  6 d( Y# K! ]& ]; Y7 [

GenericServlet类实现ServletConfig接口

• 什么是ServletContext？有什么作用？
    {: L* b! {2 L( M; d
  8 }& ~% z( V+ X) f; j9 l$ c0 Q
  

Servlet上下文

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

$ e+ q: o  R4 Z- p

• 如何访问ServletContext接口？是在那里实现的？
  , `+ r& k6 x. b) l4 i
  
  

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

GenericServlet类实现了ServletContext接口。

+ ^( X3 {; T, @; W, P' F

• ServletContext接口的功能包括？分别用代码示例
  % n+ m+ m$ r/ A0 I/ |7 [
  % Z6 ?! |% ?4 v( D! `+ n
  

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

( b2 F' h( R9 O. H5 p9 A" B

• 如何设置ServletContext的参数？
  7 ~$ p7 g9 v" Y) m% y
  ; ]1 _  `# N9 }- {% n3 d7 B
  8 ?2 i* o. V+ }6 o

<context-param>

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

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

</context-param>

. \( m+ j: L; \9 B# j2 J4 @

• 如何获取ServletContext设置的参数值？
  . t9 Z6 F9 \1 o
  3 W) A2 M8 e1 P' R4 z1 q
  

ServletContext context = this.getServletContext();

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

• 描述Web应用的生命周期？
  
  ) x9 U7 R7 d! O, f
  

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

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

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

• 如何用代码实现监控Web应用的生命周期？
  
  
  # V. v. _( M, A) X0 j
  

public class Test implements ServletContextListener{

public void contextDestroyed(ServletContextEvent arg0) {

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

}

public void contextInitialized(ServletContextEvent arg0) {

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

}

}

" o1 H7 G  u, Q% E- r

web.xml文件中的配置：

<listener>

<listener-class>

com.csy.Test

</listener-class>

</listener>

; K3 _3 ^0 _* I( j( B: b: Z4 f

• web应用中如下错误码示什么意思：400，401，404，500
  1 M) H) N3 g  ^2 j4 J, a. T# D: F
  
  400 Bad Request//错误请求
  401 Unauthorized//未被认可
  404 Not Found//没有创建
  500 Internal Server Error//服务器内部错误
  
  7 {$ k* n' c5 H  Z" u) w

" K8 B  q6 ]5 c% d, n

• 描述Web应用中用声明方式来进行错误处理的两种方法
  
  
  / ~% y4 r. i2 L: g" C$ |% O

使用error-page元素声明一个给定HTTP状态码的处理器

<error-page>

<error-code>404</error-code>

<location>/error/404.html</location>

</error-page>

可以声明任意数量的错误页面，但一个给定的状态码只能对应一个页面

使用exception-type元素声明给定Java异常的处理器

<error-page>

<exception-type>

java.lang.ArithmeticException

</exception-type>

<location>/error/ExceptionPage</location>

</error-page>

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

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

( M4 y5 b# G* `6 E% o. w1 R  E9 H

• 描述记录异常日志的方法，都位于那些接口？
  & P. L$ ?1 e5 Y0 n* P8 s
  : o: n0 s9 i$ \$ V2 v
  

GenericServlet：

log(message:String)

log(message:String, Throwable:excp)

ServletContext：

log(message:String)

        log(message:String, excp:Throwable)

0 `* S, O1 Z) }3 y+ f1 a6 p

• 什么是会话？
  
  
  

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

$ P( k, s2 @* m* u  g( s) m" ~

• 如何获得会话？
  ; o% q- |6 K2 {' l, U% `+ @
  
  HttpSession session = request.getSesseion( );
  
  - R' O4 {: ?7 M3 P, V6 O2 E! ^! d

• 会话Api的基本功能？
  / z" {/ e7 E+ n& W$ N4 _$ n
  4 b. B& H) M& e4 r$ T: E8 H
  

getID() :String

    isNew() :boolean

    getAttribute(name):Object
: P+ ?' `- V( q6 P( _

    setAttribute(name,value)

    removeAttribute(name)

• 如何销毁会话？
  
  & N/ j$ [0 r1 f4 P. a. [
  

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

<session-config>

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

     </session-config>

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

invalidate()

     getCreationTime() :long

    getLastAccessedTime() :long
4 U1 f' ?1 k* S3 r( O5 f

    getMaxInactiveInterval() :int

     setMaxInactiveInterval(int)

1 |# ?9 c- n4 z1 D: ?

• 描述会话保持状态的基本原理
  
  # Z1 |; ^, f8 l- J& Z: o2 W
  

% b; q4 }. ^1 s4 J, A

    client server

" l) e5 M- d) `7 f$ i3 |" t

request
5 P7 @, P! a. R7 Z# ~

response (sessionid)

request (cookies)
7 {7 \: z9 s4 K. }2 ^

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

) C+ e- k) }# M/ `3 L  N' d

• 请描述session和cookie的异同之处
  . l8 F. b6 u( z" s) v
  : z9 a) Q5 S+ X7 [
  

• 如何读写cookie，代码示例
  . }- `  O, Y1 Q4 t5 h. r. X
  : q7 h6 U* j% {
  

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

response.addCookie(c);

读：Cookie[] cookies = request.getCookies();
3 R$ g& X6 K: d6 k& J1 u* J/ A4 T

        for ( int i=0; i < cookies.length; i++ ) {
3 f& ~" h/ P. d  k6 M$ V5 Y5 C

            String key =cookies.getName();
( M% l0 c9 Q. {% c$ I4 S% k

String value = cookies.getValue();
$ [) f- f2 o" J' m+ a4 [' E- d5 L

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

     }

% I! y) c5 ?. C9 p

• 什么是URL重写，如何实现，代码示例
  
  
  4 K: U& f7 Y6 K8 r0 I

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

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

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

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

+ ^: g) ?" q& M! H

• 描述web应用的4种认证技术
  4 ]) V; d. `5 r0 \) W  }/ ]8 o
  
  

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

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

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

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

& r, Y7 ~+ S. {4 B

• 什么是授权，什么是验证？
  ; c5 v8 v; J$ ]# J4 z1 f
  # T) i6 z# \( H. K( v. {3 f
  , ~6 W8 W6 {  _

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

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

. ]$ P$ {0 d: H3 m

• 什么是HTTPS
  
  : [! w' L. `. o6 z. {$ X: O) s* H
  

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

• 什么是审计？
  
  
  

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

7 b' A, {/ R: K# _( W4 g$ K

• 如何实现声明性授权
  $ O7 h9 A* n( b$ O; C1 A9 |
  
  

1、标识web资源集

2、标识角色

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

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

在 web.xml里配

• 描述servlet并发问题？
  
  
  - f% H$ T/ I& m3 ~

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

! g& J2 B: G- N! }: j

• 描述Web应用中的六种属性范围
  
  + Q( Q/ a3 N8 j5 P/ y
  # ~: d4 D% x1 @- p, c/ n1 U2 F

局部变量（页面范围）

实例变量

类变量

请求属性（请求范围）

会话属性（会话范围）

上下文属性（应用范围）

" M$ q" ?  N; _9 P( U

• 指出上述六种哪些是线程安全的
  , _7 G8 ^& P& m0 g. @7 g1 s
  6 D/ X2 x: w1 H! s4 m5 q& n
  

局部变量和请求属性

" O% I' ^; Q: E. |  r+ ~

• 什么是STM？如何实现？
  
  
  

SingleThreadModel接口

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

% b# V2 U! X3 J9 T, S' r- H. K

• 如何实现并发管理？
  6 }& @; _3 B8 W( m4 d) o' T
  ) I3 ?- a' @$ s; l
  

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

使用synchronized语法控制并发

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

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

# E9 Q( m& V: Z

admin

Jsp
什么是Jsp?
6 |' M+ X/ E/ Z, Z: GJava Server Page    结合java和html在服务端动态生成web页面的技术
# @! {9 U/ Y& E5 L+ P7 H


% y& k! H4 D! B4 x  _描述Jsp页面的运行过程？
- K2 Y2 G# s  l& z7 p0 `/ D  u第一步：
" t3 g; D+ G3 A2 J! B$ R, d1 D
; @1 p2 j/ w  T7 B请求进入Web容器，将JSP页面翻译成Servlet代码
$ `% y3 Q' Q' x$ D
* V7 G8 G6 k& N) W第二步：

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

+ D' e3 K9 R% b4 R- K* W第三步：
9 x1 ]% O6 C5 Z; E8 B, g7 g$ w& j
Web容器为JSP页面创建一个Servlet类实例，并执行jspInit方法

第四步：
  t' I$ j7 x0 B
( x* v8 l& S, {6 y# mWeb容器为该JSP页面调用Servlet实例的_jspService方法；将结果发送给用户


7 M9 D, _) ]$ @) j
2 b+ H6 C5 d2 |2 `$ |+ x# f) c描述Jsp页面的五类脚本元素的功能、写法、并示例
4 V4 r0 R+ ^5 a5 M- x( s) F注释 <%– –%>
5 g0 j' A8 x" w7 S* K
% ^8 q3 w, @% X" @# k<HTML>

% v7 H' I  I' G8 i5 T! \" M<%– scripting element –%>

2 s& h2 H9 J' M8 W' H; t6 _4 Q& _</HTML>

& g" @8 Y1 a+ W7 r指令标记 <%@ %> 指令标记影响JSP页面的翻译阶段

1 ]! C% c  Q* F' b! A3 J<%@ page session=”false” %>

声明标记 <%! %> 声明标记允许JSP页面开发人员包含类级声明
5 Z4 U& @: K4 M+ O
<%! public static final String DEFAULT_NAME = “World”; %>
% L& Z" A0 n: ~- h# I9 x/ N, T
' K/ x. d. l' ~# [    脚本标记 <% %> 脚本标记允许JSP页面开发人员在_jspService方法中包含任意的Java代码
7 q6 n" V# G# Z" r
    <% int i = 0; %>
7 Z7 y8 ]; ^6 r+ {1 _& ~
表达式标记 <%= %> 表达式标记封装Java运行时的表达式，其值被送至HTTP响应流 <B>Ten is <%= (2 * 5) %></B>


3 u1 o7 H( o& u: [" X
7 D/ F! t& r$ l- N$ ]+ A" j  m描述Jsp页面中的注释种类和写法
" ?, D$ ?0 S1 h% {1 j3 A" m2 DHTML注释
# v8 K& ]" k, n# h) [) q
<!– HTML注释显示在响应中 –>

0 _2 j2 z& G" K8 A; J' A- {: SJSP页面注释
$ h* w9 M% q: E$ x2 }
, d4 Z2 }1 i0 q8 S0 W7 w0 [/ H<%– JSP注释只在JSP代码中可见，不显示在servlet代码或响应中。–%>
6 U! r9 N# D4 A! U
Java注释

7 j( _! S8 \5 }4 f3 g) ^<%

/ a9 G- o5 h5 D* L+ _/* Java注释显示在servlet代码中，不显示在响应中

*/

  ?+ A, ^, I6 t4 c%>
0 h- w3 G3 B0 ^6 \' n5 V7 w

% i' p" D0 @5 V/ X
描述Jsp页面的指令标记的功能、写法、并示例
指令标记影响JSP页面的翻译阶段

' \  L% _* k: W8 y<%@ page session=”false” %>
  v( }8 \2 y- V) l+ @$ j/ @6 u
<%@ include file=”incl/copyright.html” %>
. J6 y( |, Y! ^
<%@ taglib %>
% a- y; m1 f1 l) O/ w- S


描述Jsp页面的声明标记的功能、写法、并示例
声明标记允许JSP页面开发人员包含类级声明
; |, q- C' \) V1 m8 r( d8 ]$ u/ M
5 ~- P  Y/ B) f) B2 h& y+ ?写法：
( X3 s: X6 ]8 [8 r
<%! JavaClassDeclaration %>
% ^8 X$ d7 ~& `# G
例：
9 w* c0 j- Y- P- ^9 e
* g, H! Y& W7 n7 e<%! public static final String DEFAULT_NAME = “World”; %>

$ O8 {3 [2 B6 L* z<%! public String getName(HttpServletRequest request) {

return request.getParameter(“name”);

}
5 g7 u! A7 z: N4 j; A
+ d% H" U- E9 T* [! D/ w6 Q%>
- r7 i" r! N' {& `! J
<%! int counter = 0; %>
  o- M/ @4 i: N& Z" L1 `

6 k2 z& C; B. ~3 i! E6 o5 P
描述Jsp页面翻译成Servlet的规则
- t" `  P8 i: |0 e0 l1 |4 Jjsp中的注释标记被翻译成Servlet类中的注释
( u- g- ?: _9 ?0 i2 n
5 Y, F2 I# O: m! s$ |5 u+ Rjsp中的指令标记被翻译成Servlet类中的import语句等
2 o( s- ]+ i) |( Z" _4 I
jsp中的声明标记被翻译成Servlet类中的属性

: S! }* E+ {: ojsp中的脚本标记被转移到Servlet类中service方法中的代码

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

) @" e/ p# |$ b# [7 V# {% E

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

6 v: A+ x4 t: `" D  mresponse 与送回浏览器的响应相关的HttpServletResponse对象
. K& v1 _  K, N: r* R
out 与响应的输出流相关的JspWriter对象
7 s2 N2 R' S, H+ Z# V
7 a% s- Y( `0 S/ f2 g4 n& g    session 与给定用户请求会话相关的HttpSession对象，该变量只在JSP页面参

5 g6 f1 K; p1 v5 p* X1 {0 n$ A$ I与一个HTTP会话时有意义
" o: g( S7 Q& w: D+ H3 `' O
    application 用于Web应用的ServletContext对象
: u, Y0 O$ |  g6 c: g! U* ]1 g3 ?: u
config 与该JSP页面的servlet相关的ServletConfig对象
5 u  j& L" k# J; W4 U$ j  S
pageContext 该对象封装了一个JSP页面请求的环境

9 ^$ C# z% \" z9 u  M: dpage 该变量与Java编程语言中的this变量等价

    exception 由其它JSP页面抛出的Throwable对象，该变量只在”JSP错误页面”中可用

- R+ o" I& f8 g! C3 \3 e. u
: x4 }0 R" ?* g( X. |+ [3 O5 j
% j9 ]6 R  ~* b% m! |+ _- K* Vpage指令的功能，写法、并示例，并描述它的如下属性的功能和用法：import、session、buffer、errorPage、isErrorPage、ContentType、pageEncoding
' v2 r% w1 D, zimport import 定义了一组servlet类定义必须导入的类和包，值是一个由
0 e' j; V& ^9 w6 L6 D
- g1 L, L; R3 ^2 s0 N# h& ?  Z逗号分隔的完全类名或包的列表。
* u2 }4 A( {2 D1 ~
( J, R+ v# N2 X- J$ \, Z$ _/ msession session 定义JSP页面是否参与HTTP会话，值可以为true（缺省）

8 O$ c" ?- B# g5 [4 F, z或false。
4 G1 H% L  g% _% D
buffer buffer 定义用于输出流（JspWriter对象）的缓冲区大小，值可以为

/ ?7 R2 y( d: o- {6 s: U. r& hnone或Nkb，缺省为8KB或更大。
% K! M+ u1 H+ b- M/ ^
errorPage 用来指定由另一个jsp页面来处理所有该页面抛出的异常
" L7 a2 W9 F% W% @% X
isErrorPage 定义JSP页面为其它JSP页面errorPage属性的目标，值为true或

false（缺省）。
$ `6 C( [  |' d6 \2 T
: j# L; l( n! _! C; q# m( u' JContentType 定义输出流的MIME类型，缺省为text/html。

pageEncoding 定义输出流的字符编码，缺省为ISO-8859-1
: h+ d  o8 m, T2 H. h


描述MVC各部分的功能？MVC的优点？MVC的缺点？
6 f; v) C1 u  Z, I0 DMVC各部分的功能：

Model（模型表示企业数据和业务逻辑）

9 i% ~5 \( W; E. ?6 k. `9 B封装应用状态

响应状态查询

1 [# P% T  E5 y7 Y: k暴露应用的功能

2 g- z( D4 H% O3 |) n) OController（控制器接受用户的输入并调用模型和视图去完成用户的需求）

验证HTTP请求的数据
2 R5 u8 f- n5 Q6 W9 J) H# I
将用户数据与模型的更新相映射
5 Z$ z3 Q: M. V# y  a+ Q3 m  O
4 b2 ]1 h  A) |% ~选择用于响应的视图
7 Y7 ]: w* F; f+ G/ {# R! |% T/ q
3 R: I) M' x. _$ ]View（视图是用户看到并与之交互的界面）
. P) d5 A, `- ~2 S6 \  d: ?7 F
产生HTML响应
8 D: z0 _9 Z: a( O- q
: v: y1 Y! Y" X& e: f5 p请求模型的更新

7 T6 m* G  B/ E9 ?  @提供HTML form用于用户请求

MVC的优点：
4 o4 Y# `' L2 U0 f% B: L
        低耦合性：视图层和业务层分离
) U& m" c( A4 h, I; [
- f, u: @0 }# w  W高重用性和可适用性
3 u1 [$ C8 }- h5 h  t$ T2 z
% X; ^. }2 y  Y, Z& s$ P较低的生命周期成本

. a; ?; k. o& _1 l$ u. O: U快速的部署

可维护性
8 f1 ~6 I6 M( ^7 K
有利于软件工程化管理
- J$ \9 n1 u9 s/ B* Z% ~  u2 |
提高软件的健壮性

) _* ]. {* [" jMVC的缺点：
6 C" r0 F3 p+ v3 x& P
        工作量大，增加工作的复杂性，MVC不适合小型甚至中等规模的应用程序
  {" j1 Z( i0 U) O
) n/ Z  i  n  l( G

. M+ \3 e  n0 U- N2 Q( m6 a什么是Model 1结构，以及结构中各部分的功能
" m1 I+ f& }; q结构：jsp+javabean

) A6 U8 l# E5 M2 V7 c' V# Y  [# zModel1中使用jsp来处理web应用中的视图控制部分

Javabean收集参数
2 I) N( _  r) m1 f1 j) b
- V, V2 s& S# c1 ?/ i$ A) H
- s$ W1 U" L$ I0 p2 h" C" i( q- L
! y! i( ^# Q: W- ~3 d: S什么是JavaBean?
) N  _: s1 ]' y4 [% d* R( d/ M用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。
* s( O0 s7 O6 a) r, U% T4 }

# _& ~& M2 ^% G& W
JavaBean的规则？
- y+ q+ X- x+ F, u使用get和set方法定义属性
, ]) M5 w3 H: c/ C; Q
一个无参构造方法
4 h( O5 i0 g. P
4 U. C+ |9 Z, d5 v# \无public实例变量( 所有属性私有化)

6 e/ u# w3 ^% e4 O. B

. l+ G4 q7 j$ k/ H- H$ j; [3 ]/ M什么是jsp标准动作？包含那些？分别都是什么功能？如何使用？
3 H! Z* j! L: ~+ q7 T+ BJSP页面中使用类似于XML的标记表示运行时的动作
  }1 g- j0 o0 M% e% v/ Y# \" B
jsp:useBean

jsp:setProperty
/ X- l" H, s% K4 Z6 G
" x4 J# X& h( F* u3 p) G* Y0 Ojsp:getProperty
- [1 k: |" K/ V3 @
jsp:param
; P4 R, L; a- G$ j$ l$ }) E' K
jsp:include

jsp:forward

! w0 T0 _0 x  c. U/ p# M  h4 S

用代码示例如下标准动作的使用：useBean、getProperty、setProperty
9 o* \2 w/ q: F<jsp:useBean

id=”myForms”

class=”com.base.mystruts.forms.MyActionForm” scope=”session” />
5 h( c$ i5 M/ C% i+ z/ t
    <jsp:setProperty name=”myForms” property=”name” />
# s5 s* ^" M# N4 R. f
<jsp:getProperty name=”myForms” property=”id” />
) w4 }) R& d# }: q+ Y


描述说明Bean的四种scope
page

+ _  v: K8 o3 Y% M- s* H) f+ Drequest
0 b* a  }  c- D& o6 v
& [' e" Q0 \* X) k+ ?7 }* usession

+ S# T+ k7 E4 m5 h0 z5 oapplication

# j. V: v2 D1 _6 d4 }2 f2 ]  l
% Q+ k% t- l" f9 b) i. ]5 K
描述说明页面上的字段和Bean中属性的对应规则
8 F3 K# s: M8 j! V  X- \8 Xid 指javabean的变量名

class指javabean类的全路径

scope指javabean的应用范围
; m! [" l% O1 q
& G2 N) z7 y3 }2 _$ i. Pname指所用到的javabean的变量名

    property指javabean中的属性
' L6 m. @& F( R" ]3 ~# G

- n9 I! ?* b* d
7 R3 n" k/ H: Y; A" n1 @8 \3 _/ a& X描述useBean动作的处理过程
使用id声明变量
3 Q. A: w4 G, R3 u
  `; q: ~$ J' t" ]( s试图在指定的范围内查找对象

如果没找到
# K8 R( H: M2 W( G6 Z: K
8 A" m" _1 d4 p, f# S2 c7 ^  L创建一个类的实例

执行useBean标记体初始化对象
/ I6 L+ F3 p6 i: {% `
* z; _9 \. `% g, d0 M9 J# P如果找到

7 L/ {2 W. P. |# @5 e7 D     将对象转换为类指定的类型


$ Q& z  b6 E( z5 f9 F  S2 Y# D
1 E7 T+ i: i( S, i描述forward动作的功能
8 M3 l/ N* O: a8 E  u# j$ |' N使用脚本代码处理请求时，可用jsp:forward 动作产生一个不同的视图，
- Z! v7 G# @2 z8 @2 p
7 n( p& e( L8 I使用同一个request：

1 I% o6 Y; N$ {, C+ v

什么是Model 2结构，以及结构中各部分的功能
jsp+model+servlet
, S0 v# ]. T# L3 m8 g0 R
Model 2架构使用MVC模式，JSP页面充当视图，Servlet充当控制器
" p# c' [  c+ |; [# P- u2 x2 Q
Servlet控制器：
& E- N; K% `) z4 J  o5 D
" o0 w# o& b5 n) ?* q7 G& a验证HTML form数据

( Q0 r  M, s  z' s, @2 ?% p6 x$ M7 v调用模型中的业务服务

- Z- J+ Z1 s9 s/ T+ m4 F4 L0 l7 w存储请求（或会话）范围内的域对象

选择下一个用户的视图
; Q* A) f1 F5 F5 a4 L
" f! S" c3 W$ R7 D; iJSP页面视图：
0 {% F1 z# F$ K& g
/ @( s- d8 `* R+ |8 o使用用户界面（在HTML中）
$ V; Q% o) h9 o4 C- `: c7 K
        访问域对象
$ P. E0 ~4 N. A4 M


- b; e) q5 @, I" r* Y( Y3 _" P如何获得分发器？分发器的功能？
上下文对象中的分发器：
5 c/ j2 l7 n2 i& v6 O& U1 F
4 _; `( w1 |0 e7 Z* X" D, K6 wServletContext context = this.getServletContext();
  r: O1 S5 ?# s- e
RequestDispatcher servlet = context.getNamedDispatcher(“MyServlet”);

7 j2 s  I5 ]# ~$ Y% Gservlet.forward(request, response);

1 d. r; Z; q6 d  K1 q9 y请求对象中的分发器：
. C; X; J% ]# w
RequestDispatcher view = request.getRequestDispatcher(“tools/nails.jsp”);
: P4 ^/ [) p) ?, b3 ~; X
( F% y" C4 x% \( nview.forward(request, response);

6 ?3 f# T. ~* S4 w/ X可以将请求转发到另一个jsp页面，并保持请求的传递性

1 |7 [. K6 A5 z

Jsp中页面跳转的两种方式？
! h/ i* x2 E+ Q1 h: A8 P3 y使用分发器跳转页面
RequestDispatcher dispatcher = request.getRequestDispatcher(“url”);

6 p3 R; A6 R& P" E. a- gdispatcher.forword(request);
4 ?  D0 S. `+ ?! H9 d
$ t0 \8 b# s" W. N    特点：保持请求的传递（上一次请求中的数据，在下一个请求中仍然可以得到）；
& `. Z: `3 `; T" D6 p* L+ D) D3 A% D
) V$ i' l2 G" T' a4 d/ n        转发的页面只能是同一个Web应用程序的其他Web组件

& m8 B( V# b0 z% r2 j; t4 E0 v使用重定向跳转页面
7 D( g) `. p2 [% p; q% A# q" ]response.sendRedirect(“url”);
) {/ o) a) G- ?5 b( s
. I1 z# C; o' I# w0 b0 ]    特点：产生全新的请求，（上一次请求中的数据，在下一个请求中不能得到）；

3 U( P4 G1 W5 H( j. Y7 _        重新定向的页面可以是任意的URL
0 Y" d& r* A' |1 o6 |" h* H8 p/ n
4 ^& A$ `) }* _9 v- w( c' k
! F8 W; h/ n! [# Y# V7 r! a5 w
- R3 O! k, y; q  Y. ]& s描述Jsp中引入另外页面的两种方法，并比较两种方法的特点？
<%@ include file=””%> 在编译期间把另一个页面完全嵌入这个页面,可以说是一个页面

! l# \# y& Q7 Q在这里可以共享变量
% t2 z6 G* v1 l& B
<jsp:include page=””> 动态的再运行期间把另一个页面加入这个页面,可以说是两个

4 `& `% H$ d. R: C页面，不可以共享变量
, d8 k3 F$ }1 b( Q0 f


什么是自定义标记
自定义标记库是一个Web组件，
5 N( B+ w& h, q7 j1 D) s& s, h0 z$ g, R
& _* r, f, B$ _9 V) F4 s  q包括：

一个标记库描述符文件（*.tld）
6 ~' ~- M. O1 f
所有相关的标记处理器类(*.jar)
+ A7 O3 q3 F% v- v
2 y6 B' [1 v4 H% }6 `  }
3 H, @3 |2 L! m! Z
$ D4 n# C9 \+ |( `0 M: t" U8 L描述使用自定义标记的步骤，以及每步详细的工作
使用自定义标记前，要拿到.tld和.jar两类文件
- B: G& k( o0 P- t
把.jar文件放到WEB-INF的lib里面。
5 E. g/ ]. s' ^把.tld文件放到WEB-INF根目录下。
* [3 c! f+ T5 r# i( j/ F在web.xml中配置。
<taglib>

' \# Y9 w. \2 Y) _<taglib-uri>http://java.sun.com/jsp/jstl/core</taglib-uri>

     <taglib-location>/WEB-INF/c.tld</taglib-location>
, H% }, B+ u# S9 S
9 t3 U7 p4 F: o1 ^</taglib>

( Z) R  v( ^; Q9 Z" L在页面中引用。
+ k. g1 a; L3 W3 C; S<%@ taglib uri=“http://java.sun.com/jsp/jstl/core” prefix=“s”%>
& o" r0 f/ Z6 X) e+ B
uri必须与web.xml中的uri对应

( A& u3 T2 Q9 Y$ \. gprefix是前缀，用来区分是哪一个taglib
# ]8 J0 ]; _8 z! D
' F3 a6 T! q  G2 {; x使用标记
) P+ t  c" |% c. l& d格式：<prefix:tag名称 属性>
/ l2 G- G# U/ G: \& F- s! L3 O0 }
<s:forEach >

admin

在tomcat下配置数据源
1、服务器与数据库的连接
8 a( X2 E. Y9 C3 w: I
配置server.xml文件

1.oracle
! p: Y, Q8 }! v. `; t
$ }4 A0 e1 k8 U8 q% Q5 C# K% |<Resource name=”jdbc/company” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”
& l. f) y2 N4 m' F: n, a1 X/ _6 e
                        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”
  D" s3 m! c* b4 w4 i& E8 ]" A: n
url=”jdbcracle:thin127.0.0.1:1521rcl”
% u. G/ Y2 h" I: `5 ]! q2 ~
! X, M( o' W# q7 ]) a  ?driverClassName=”oracle.jdbc.driver.OracleDriver”
9 Z, G- j4 v# ?+ a
" |3 k& B) Z! r/ E1 E3 _' v# H3 uusername=”aa”

9 ^# L. L! A+ Q7 ~4 lpassword=”aa”

maxActive=”50″
' ]1 h& w) G  Y
maxIdle=”10″

maxWait=”-1″

/>

; p: i0 ?/ A" V4 `( c2.sqlserver

7 p5 d3 B- n0 m. A4 |- j<Resource name=”jdbc/webpage” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”
* J+ W, C( E! ?0 r1 m, {
/ b4 t" a: }. N! e        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”
/ h+ f6 ?( c- X" x
url=”jdbc:jtds:sqlserver://localhost:1433;SelectMethod=cursor;

DatabaseName=webpagetest”

" L( D# }6 K; s( N% J  I$ m( RdriverClassName=”net.sourceforge.jtds.jdbc.Driver”

username=”aa”
& E$ U: X  H! u9 }4 ~7 ^4 w: \
  u. J7 \* S* a5 A& D; Z. Upassword=”aa”
0 Q$ x3 F! _2 h+ B
7 Y5 A6 A" N4 N' w$ imaxActive=”50″

8 ^) o" x& D+ E$ umaxIdle=”10″

maxWait=”-1″
7 u  P5 m/ |0 n% w8 U9 r, ?$ p% R
/>
% j2 v9 J2 s5 l# L& k% B/ F
2、配置自己的web应用的xml文件

# j- Q6 E- S. G% {' q( k" r% r
- b# @! ?% g4 q
6 F2 L* o  ]3 f  q9 C% h<Context path=”/eb03web” docBase=”F:/workweb/eb03web”

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

<ResourceLink global=”jdbc/company” name=”jdbc/company” type=”javax.sql.DataSource”/>
% N) Z: \4 N! p4 y! c, K
</Context>
& d4 v/ B2 b( \& b2 f# |/ R
9 d) o7 X+ `4 M

8 ^9 N$ c6 P6 ?8 k, m/ K3、配置web.xml文件

与服务器建立连接
/ {. i1 }4 R9 j; v4 i" k4 M
<resource-ref>

! N( `. x9 n8 K7 _( n  Z<res-ref-name>jdbc/company</res-ref-name>

- v* r$ }/ B$ X8 _<res-type>javax.sql.DataSource</res-type>
) {8 l& G' E6 e/ {$ T
<res-auth>Container</res-auth>

</resource-ref>
, \# ?% U6 T  X4 N$ O
" G1 D6 B4 W& M! v1 u4、在应用程序中不直接与数据库连接，通过DataSource连接池建立连接

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

System.setProperty(Context.PROVIDER_URL,””);
( ~1 Q- x3 G. {# U/ {" y- F
; _* z# }+ k& {' d2 d, t& ^System.setProperty(Context.INITIAL_CONTEXT_FACTORY,””);

//2.创建一个上下文对象
0 `$ H. J  ?- c# ?
InitialContext context = new InitialContext();
" [& U. o- ?- {& k6 `3 Q
//3.通过上下文对象在连接池中查找DataSource

DataSource ds = (DataSource)context.lookUp(“java:comp/env/jdbc/company”);

' ^1 c5 w- C; D//4.通过数据源建立连接
7 g5 k; H. d" U9 v
- L' ~- t( j. B, W2 t  [ds.getConnection();

admin

ORM对象关系型数据库映射
& t# A8 `5 ^; {/ W(Object Relation Mapping)

: \0 B4 f2 X: ^9 b- m  V* Y一、映射的特点
  F% X1 v- j# h/ Z
1.一个对象可以对应多个表
. w, H( ?( c4 u9 J$ H
" K; A% l5 m, C& Y" z/ X/ S2.一个表可以对应多个对象

( q* w& Z/ i, z  h/ ?5 I6 K, a2 M3.对象和表的关系不用完全对应
9 V& h* j+ T1 T  i/ T. l
. t% X0 R9 Y, s" M% }9 `  u4.对象的属性的名称和表字段的名称可以不同

3 J/ P0 r$ B( R# x0 n3 V) G5.类型可以不同，但数据类型之间可以转换

6.对象中必须有主键，数据库的表对主键无所谓

7.数据库中有主外键关系时，对象中可以有，也可以没有

  c' E  s# K. J, h" G: [+ K
2 B& ~2 ^  v" W8 {& z! W8 b
二 、有一个映射的描述文件————>xml
4 e- ~5 U+ ^8 T
5 r5 r0 k6 Y+ w/ x& |三 、怎样实现描述文件————>一段程序
$ l( H9 Y; d3 ~4 h; j8 x. I8 H
对象 映射（mapping） 数据库

: F+ G4 f( v4 }# Q7 e  f8 Kuser
4 l/ ~% _2 ]2 v* q
id=11
2 A8 W% z" `; C8 g
! q+ L( x* ]* \& y7 T/ V( z$ Oname=”张三”———— > (1) —————> tbl_user(id,name,age,tel,address)

9 k! F: S$ ]) m7 L$ w9 b! I3 cage=25 <————(2) <————

; M( P9 r# h( i: G* o  B
4 m4 R6 X! I) e# h2 d
5 e, y; P  ]9 E# }& Y2 S' c$ {( |(1)从对象映射到数据库
" X7 H) O0 I) L
1.JDBC
# P, a; O- w7 J  [) |
$ d  ~' q5 C& h! H0 V# ]( ]- r2.根据描述文件来动态拼接sql
% G( }, L# [3 m4 l) z8 {
* y* c$ K1 D, L: j& o, S" [3.执行，添加到数据库中
, Y4 k) e* p$ j
. g; n7 l- A7 j" [  g5 w4 Y

" c, D* L* `" J) O(2)从数据库中映射到对象
3 ?7 `9 B! W7 `+ T$ p( k
& t. S! j6 h5 ~' m$ z! F( K1.JDBC

5 U0 q" ^) n; `# S, V1 a& u2.拼接查询sql
* e7 N) w8 G7 s1 X9 c* m
1 ^; ?0 T. F+ v  ?  K, M* L3.ResultSet
/ D2 L2 i2 V$ c) s) {# d
$ X" y  ^6 f9 \9 [- z4.Model
- }7 @4 t" Y6 c
" d4 U8 H* f5 U9 r, C& b: M

hibernate
) `  ^* `: @  ~0 s4 r9 A开发流程：

) s/ X# ~# x5 n2 G* L, }是什么？
hibernate是一种基于orm 的轻量级的框架
% X: A  W" M8 }% H6 ^6 N$ S: i
1 o, ^7 N1 q+ k- Q8 _0 J( s
, E% \5 ~$ U% f) E: X! C7 P# D5 ?" P
有什么？
/ ~9 ]( S& ?* a/ C3 e6 @: w1. session 保持连接状态（依赖事务和连接池）
8 B- M8 K' M) l
2. Transaction事务

3 A- Z0 ^) |8 N! P! v/ N8 x3.
0 ?' }. ]5 \; fConnection Provider 连接池


( W( q5 q- c# L' T8 {9 d, s
能干什么？
, A$ @/ Z2 V/ p" u5 C3 z8 N+ ]7 A1.orm

2.提供操作数据库的接口，简化数据持久化的编程任务

6 I, _0 U3 F8 i6 H6 @
5 ?; O1 y" V5 _' O
怎么做？
8 u% p" s9 Z, K( f; h" B0 P% p, A1.搭建hibernate的运行环境，将hibernate的包和hibernate所需要的包拷贝到lib 文件夹下

7 V/ o, x0 B0 Y* F6 ]8 D9 D8 u( i2.O（vo）
8 @- l  M" W" D# ^
7 U0 ]$ i# P& l* u: z8 k" k4 h3.R （关系型数据库中的表）
; q6 I# E4 z; c) V- ]- l* h
4.配置文件

4.1 cfg.xml 放在classes根目录下，默认名字为hibernate.cfg.xml

a.与数据库的连接

b.可选配置
- N/ E% K! [; f' D' q8 e0 n
+ x* J; `9 F, Ac.映射资源的注册
" O- s  H; Z6 H  Z+ k. K. p2 i5 S- R
, u$ u. f" b* C# ?4.2 hbm.xml文件 名字与类名相同 并且与类放在一起
0 V3 _- O! D7 q/ a7 h/ r
% x3 E  l; `# i  y( Ya. 对象与数据库表之间的映射
3 e: z# N% c5 q( Z+ ^
b. 对象的属性与数据库表的字段之间的映射
# Y! s: {9 _- r  G
c.组件之间的映射

+ b2 H4 ?) M' ~' ^$ p& v1 q; Sd.对象与对象之间的关系映射

) t. b. _/ J$ n5、客户端
- X* d* `: ]. B3 ?2 u
" E4 S7 k# o% p' Q1.得到SessionFactory
! x+ H+ P, Y: Q  e, K# y9 @
8 k2 h+ _) R8 J; Z0 {  j$ S2.通过SessionFactory 工厂来创建Session实例

3.打开事务

4.操作数据库
0 N( Z+ R! B, b7 H1 V$ K
5.事务提交
1 e( y; d, L5 d7 ?# b% ^! H7 }
6.关闭连接

运行流程：
7 V, S" l: c" _$ r6 A' k" B
整体流程
( l; Z, l3 M4 t) E! c# Z1.通过configuration来读cfg.xml文件

& C! l( t# _  @2 g- R: M! U- R2.得到SessionFactory 工厂（根据数据库的连接来创建sessionfactory）
* Q) c: W9 @% y  b+ u
1 R6 v( U8 f( ^: G* A3.通过SessionFactory 工厂来创建Session实例

( Y( x% W& ~! Y2 @4.打开事务
5 H$ {" }1 S8 @$ G+ ~
$ ]/ Y: b* ?* L; w; M5.通过session的api操作数据库

+ Q$ O- e0 V$ P6.事务提交
7 q; a0 ^) x7 D1 {* r/ v" _, A
7.关闭连接



save
( l% a  D5 @9 |3 h) n1.to—>po

7 A5 t* I+ _& n* ^  I& {  o2.根据model和cfg.xml中映射文件的注册来找到hbm.xml文件

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

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

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


( \4 D; ^3 H1 {' n
) o; Y$ @1 r- X# f$ v- w8 ]) L$ o% supdate、delete
  C6 T0 F' L/ Y( k2 ?! x1.根据model 的id在内存hibernate的缓存中查找该对象
: f6 i1 F0 F. a' k3 l
/ H+ |1 O$ N: M( L6 h如果内存中没有就到数据库中查找来保证对象的存在
5 i& }9 |1 o( E! {4 V, L
) W) K# n) M( E3 {* O2.根据model和cfg.xml文件中映射文件的注册来找到hbm.xml文件

. f) i* a; v. w+ @; }3.根据model和hbm.xml 文件来动态拼sql
; t3 u- c' g  r: E: n
4.客户端提交或者刷新内存
8 v+ K) A9 q. ^4 G7 r8 q7 x
+ D" G9 i! t/ l2 f5.执行sql
$ n; Z% M0 O2 j* Z5 Z

7 v# I! W5 L8 v
Query
load
4 H7 v; V* n7 i0 x
  O- }1 i; T6 H" k. q1.根据model的类型来找到hbm.xml文件
" t- i9 M) E" c1 B1 A9 ~; n: @9 z
2 g  j5 ?4 _1 s1 o2 f8 W1 D$ R2.判断id对应的对象在缓存中是否存在，如果存在，就直接使用，如果不存在就进行下一步。

* @1 S8 h5 y! f/ n3.用id做为查询条件来动态拼sql

4.执行sql 查询（先在内存中查找，如果没有找到（会抛出例外），就去数据库中查找）
5 u8 j& B4 H( Y9 S2 n. v% n
8 [3 M' a: k8 ~& T+ g) V+ {5.返回一个model类型的对象

: e% ?( v# C; wget

    1.根据model的类型来找到hbm.xml文件
2 g/ |- O+ A2 ]( d. q! f
9 c# B2 @) K" Z# u1 c( h2.用id做为查询条件来动态拼sql
6 y/ b4 x# J9 k1 C4 p9 G$ v, n+ L4 H
# t5 w) Y4 l+ G' e/ ?0 F2 c6 v3.执行sql 直接在数据库中查找，如果没有查到就会返回null
- t' ?3 f9 l3 X& m
% I- S" s9 G& ~( U' oquery

1.分析hql语句，得到model的类型
' a# k. ^  ]5 {$ }
! ^$ }. V5 `& ^) ~, U2.根据moedel和cfg.xml文件中映射文件的注册找到hbm.xml文件

% A  v: r3 o  t" U3.根据model和hbm.xml文件来动态拼sql
, D. P! ^, {. Z2 y3 d, P
0 d( N9 J6 @5 B" g1 C4.执行sql查询数据库

5.返回一个resultset
* h# n1 Z8 {; ?" g
6.循环resultset的值，放到model中在放到集合（List）中

/ q) I9 l/ y6 O# p# U# _% U( @

谈谈hibernate缓存机制

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


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


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


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

; ]( ~+ d5 i  _3 T3 [| | | |
5 q) L0 x5 q0 x7 `
| | | |
& Q$ N1 L' c0 ^4 @: @
3 M0 _8 ?0 k0 \, U" F—————————————————————————————————
0 I4 O1 @9 N4 s: R7 e0 k' n* ?8 y
  f/ Y1 d/ s! w- V5 gsessionFactroy级别的二级缓存
' ^" O1 i0 X& O8 D# w
( ~# ~7 M: X3 V' L, f——————————————————————————————————————-

* |/ n' C9 w2 F* }' X|

4 _' Z- W0 E4 M, u9 G|

|

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

DB

7 t) \8 [' z6 ?) @+ q—————————————————————————————————————–

) f: s% u: Y1 ^( c3 e- w

admin

Spring

• 是什么？
  4 i( i2 o! q1 m3 S
  

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

• 有什么？
  
  * N8 A) a- l' m# j# v# a; ~

3 r. k* u3 ^0 q5 O8 H1 G

每个包的功能：

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

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

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

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

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

AOP ：面向切面编成

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

• 能干什么？
  7 q$ K( I! c3 [4 ]5 b
  ) ^( ^; U& M* I, G

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

/ ?6 l* i. B' j/ p& B/ z% T

• 怎么用？
  
  ' L, ]0 X% H7 P" ]9 }4 g4 O
  • 搭建web工程，引入spring的jar包
    
  • 在web.xml中添加如下配置
    
    
  
    _: e* p; R6 {2 j* d6 `
  $ y6 ^2 o" W, _! W& c

            contextConfigLocation

            classpath*:applicationContext*.xml
5 h  k, K% o+ r4 Q, B9 Z

   
( ~1 a* y& |* ^$ w3 i7 @

        

            struts2

            
* C6 d( ?& z, ]9 }& @

                org.apache.struts2.dispatcher.FilterDispatcher
3 c% ]: ?2 b# I9 d) @

            

        

        
  Q1 w% L* t2 y8 X$ }! X

            struts2

            /*

1 G5 c, h( M1 z

            
3 ]' f) O& v% b4 m) a$ q% e5 t

                org.springframework.web.context.ContextLoaderListener

            
1 w) z6 z' O, W/ U0 B. b* O

        

• 部署
  , E# Q/ i4 d. t/ }" d- `# y
  

4 C, [, S* `/ o6 [5 f+ V
- S' r7 `# ?) K$ w: r4 _
$ b" w) o, H0 e" W

• 容器和bean
  

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

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

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

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

. o* g, g- g1 k7 J& `% S

• IOC控制反转
  5 f! x2 V7 {1 G& z1 q' W& q, r' E
  * V( z4 c7 l$ g3 g: _
  
  
  
  从前的应用程序想要得到A的实例他会直接主动的去拿，当用了sping后，应用程序由主动的去取变成被动的等待，由spring来控制应用程序所需要的对象
  
  + a8 \" {- R' ^1 y6 v
  • IOC的优点
    
  1.可以通过IOC来获得实例
  2.可以通过DI来获取注入的资源
  • 配置IOC的原则
    
    • 一定是可变的资源才采用依赖注入
    • 一定是层间的接口或者是模块之间的相互调用才采用依赖注入
      

* F4 i6 Z# i6 F/ s' v, {. a

• DI依赖注入
  ' O+ i0 k* f( d

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

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

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

例如：

在配置文件中

. o/ X3 p; X' m7 F+ v$ M

在应用程序中

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面向切面编程
  ( l% E- F6 P' O# u3 Q: c3 I
  . ]* v; b0 o% D6 b  D* m9 W

1.AOP面向切面编程 一些较好的模式或者是示例—-范式
7 [; }6 t" s+ ~3 I2 \' v

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

2.AOP的思想： 主动—->被动（追加功能）
. @8 V- ?- a6 Y' K" m

3.AOP 的概念
- i3 q8 J: L  `3 l

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

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

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

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

5.引入 ：扩展的功能

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

7.aop代理 ：实现机制

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

4.AOP的事件机制
! M9 T5 u/ \6 {& T3 l: A

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

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

3.找到切入点

4.确定连接点

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

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

( J' m' t% ]2 ^5 Y
# B, d4 T2 B$ c  s1 ~


/ S5 J9 q( j  Q- w/ n& l( Y  F; f

5. AspectJ
" a- a, `  R( w# a# Q3 P, J& B4 Y

5.1.在xml中配置比较烦琐
; {- C' |5 Y% `, P

所有的入口必须从一个代理（ProxyFactoryBean）开始
# T2 d: |. ?" C) D, x4 d

: Y8 C9 [* _, X7 E& J

         


         

        
2 X; ]5 k2 d& U0 j9 l2 v

        

2 F0 S* U3 O. A( j+ ?6 Kexpression=“execution(* com.javakc.aop.MyTarget.t*())”/>
1 ^+ j! A# y! r* ~6 D- O0 o

        
% n: X5 E1 v! `. x

        
# {5 I* k! x$ d) R8 U

   

+ H' O7 B$ l" Q5 T# s5 W

5.3.使用注解的方法相对简单
" \' B0 Q3 V# K" J

@AspectJ的基本语法

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

直接在类上定义@Aspect
' d! N7 `3 \  w6 n0 I* p+ w

2.@Pointcut声明切入点

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

2.2、可以使用匿名的pointcut
7 m7 u9 ?# U  _1 Q

2.3、执行切点的几种方法

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

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

within（”com.javakc.spring..*”）
- Y7 {9 e/ t; f% V$ n1 f0 j

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

2.3.4 target 指定具体的实现类
/ Q' I/ S; n, Q3 Q! t- m

5.4.advice的五种类型的示例
0 F9 V& v/ b8 M9 j; ~& Y9 M

　　　 客户端必须从接口走才能得到监控，实现想要追加的功能
: ]' l  ^4 W6 ^, h% ~, r

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

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

在注解@AfterReturning中必须加上pointcut和returning两个参数
" @- j9 V. X) T( \' X4 q

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

得到目标对象的方法的返回值，来作为参数，进行下一步的处理,参数没有顺序，按参数的名字进行匹配
1 p% V, K9 j0 U- g. s  F0 y# _, \

完成追加的功能
) y' U$ a% g; T, B! o

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

(1).@AfterReturning(“com.javakc.spring.schemaaop.TestPointcut.t4()”)
: Z( d3 n8 O( X  Y0 ?

(2).
0 d: F3 r6 d- m9 Z- U2 S& ]

     2.直接引用匿名的pointcut
5 {7 h2 I, q' G- R3 Q! j* v5 Q

     (1).@AfterReturning(“execution(

* com.javakc.spring.schemaaop.Api.test4())”)
: g4 e. y2 |3 y! o6 {

     (2).@AfterReturning(pointcut=
( K( {5 `6 N% z7 ~

“com.javakc.spring.schemaaop.TestPointcut.t4() &&
5 ^0 H; u' F1 W) ?$ L! L8 ]! @) b, d

args(str)”, returning=”retVal”)
. h! \! X7 d0 S

@AfterReturning (pointcut=”com.javakc.spring.schemaaop.TestPointcut.t4() && args(str)”,returning=”retVal”)
0 d$ I  o: Y- S5 M# [

public void testAfterReturning(String str,Object retVal){
' U" f+ F9 Y3 J0 n5 C) j

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

    }

5.4.2.@Aronud

     注解@Around环绕追加功能；

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

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

     通过ProceedingJoinPoint的实例的proceed来调用所监控的
8 d8 ^+ F! ~7 w  Y  m

目标对象的方法

     1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
* m% z% Y5 H. L% x0 O! [0 f0 n8 ]% g  Y! Y

     (1).@Around(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
! V! K: }( |' z/ G1 W/ S4 ]

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

&& args(str)”)

2.直接引用匿名的pointcut
4 W$ q: G1 @, H8 z$ _

     (1).@Around(“execution(

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

     (2).@Around(“execution(
6 ]0 n1 `5 c2 d0 W" V' ^

* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
8 v4 u3 t5 K, j- c0 g

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

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

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

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

        Object obj = prj.proceed();
0 h8 h5 {& j2 w; U$ B

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

    }

5.4.3.@Before
+ R+ t1 r9 c7 X2 K+ S( J

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

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
% @* e5 i, E% f  z4 G6 j

(1).@Before(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
5 D/ w7 T- }$ f

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

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

2.直接引用匿名的pointcut

(1).@Before(“execution(* com.javakc.spring.schemaaop.Api.test1())”)
# r2 I) X9 x, j( ^: k6 ^

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

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

// @Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
3 a+ l  J1 w: B8 W- |6 c; I5 n

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

public void testBeforeParam(String str){

    System.out.println(“before1=param=>”+str);
- {) [8 |* j- r8 U3 s4 H% b

}

5.4.4.@After
8 o8 u, {- ]% \3 H

注解@After在执行目标对象的方法后追加相应的功能
5 e8 M' O1 B; B0 j- j

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
4 v7 t7 p8 V  O# [

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

     2.直接引用匿名的pointcut
3 d$ u) ?$ s  p. ?" n( _

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

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

    public void testAfter(){

    System.out.println(“after1== >pointcut”);
; v7 R7 A3 H4 W% |; v

    }

5.4.5.@AfterThorwing
% |* ^4 p" Y4 n1 w7 j

5 Y1 a+ u% F* U

• 描述一下spring中BeanFactory和ApplicationContext的差别
  
  ( P+ b& F6 x6 w' G; W! G

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的支持
  
  . Z( h5 F2 v4 u. A9 B

Spring提供的DAO(数据访问对象)支持主要的目的是便于以标准的方式使用不同的数据访问技术。
: Z3 Q) i& n0 u$ ?

简化 DAO 组件的开发。
5 F/ O  S( [7 n5 c; h' NSpring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法，用来简化代码开发。

IoC 容器的使用，提供了 DAO 组件与业务逻辑组件之间的解耦。所有的 DAO 组件，都由容器负责注入到业务逻辑组件中，其业务组件无须关心 DAO 组件的实现。
) N: y6 t# q9 F" m! z. c

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

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

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

1 P6 i# ?* h% n& f& H. ]
5 a% ^9 {( j: H% G$ f

• 谈谈spring对hibernate的支持
  + [7 J. u3 L, c5 c, B
  & k9 V5 l2 t; V, A! I

在所有的 ORM 框架中， Sping 对 Hibernate 的支持最好。如 SessionFactory 的注入、HibernateTemplate 的简化操作及 DAO 支持等。另外， Spring 还提供了统一的异常体系及声明式事务管理等。
1 N4 ~+ f  w$ s7 Z* b* t

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

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

        class=“org.apache.commons.dbcp.BasicDataSource”>
. Z/ v. x# Z! E' b/ i8 l* W+ h' ?0 R

        

            oracle.jdbc.driver.OracleDriver
3 O) B4 G8 f9 q+ Y1 ]5 o& ]

        
, [: O+ @& }6 H- [+ B1 `. D  C

        
& L4 a: I# v( h1 \% ^% f( j1 C

            jdbcracle:thinlocalhost:1521rcl

        
+ m% {1 y* C0 K% m" ?! s

        

            javakc2
+ o1 K" F! `3 y

        
4 I- p5 P& W5 [

        

            javakc2
% ?( L% w/ J" C! p& ?( B

        
5 O7 t5 u- d+ t

   

! m' g" v9 y; ?/ v+ c

   

        class=“org.springframework.orm.hibernate3.LocalSessionFactoryBean”>
6 {9 ^" [4 R# }0 W% J

        
7 P; q2 C* U5 @: w  ^1 z) E

        
8 [$ P, u1 f# Y

            
4 d) J0 p) ]  t% a& B) l, r

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

            
5 Y5 `( J* K5 H

        

        

            
1 H: Y+ V, C4 q% W

                hibernate.dialect=org.hibernate.dialect.OracleDialect
6 m" |* g! Y( N

            
1 \9 B8 D9 K1 U5 A! {- d

        
4 o5 k" `! v$ r. r& A

   

   
; c& M8 [4 O4 Y3 l& {$ a

        
, ?: x1 q$ T. q, e# f$ V7 S

   

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

   

        class=“org.springframework.jndi.JndiObjectFactoryBean”>
9 B. y2 I* f0 l- l: k

        
9 R# x, ~+ R' j! F4 k, e

            java:comp/env/jdbc/myds

        

   

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

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

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

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

   
. y7 w* v6 Y4 V( Q- H/ ?4 P

        
  b% h* _& ~. `

   
/ n$ n9 S5 I1 O2 i/ r0 C

/ k) ~  B! \* {+ v1 Q' R$ L- B, [

   
" M9 `& p0 H- x; \$ X% g

        

            
6 Y- y$ Z$ c0 X% I

        
9 s# V, v% D1 l/ ^7 _- H3 B

   

6 L- K( f$ Y# H$ ?- l8 `: N3 H, x

   
* ^( K( X% N/ P4 }$ q$ ~

        

        
, k. c' G6 [" G# ~

   

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

, w6 Y* U5 k7 ~  K8 \* U9 n+ r

Spring2.0之前事务的写法 : s# d. z' r  C- ?* ]6 p: E        class=”org.springframework.transaction.interceptor.TransactionProxyFactoryBean” $ m5 _0 S( P1 G9 T) N* H         abstract=”true”> 0 ]1 q4 B7 O6 G5 L; } " @6 }- H  i7 ~! j# }                 PROPAGATION_REQUIRED,readOnly                 PROPAGATION_REQUIRED 7 d. ?$ I; i. A$ J% M; P 6 H: n* A/ E) u% A; V ; H. W6 m7 G0 v 9 R7 Z5 N  U1 J2 X8 K8 \3 j

• 谈谈Spring对事务的支持
  2 N+ y5 W6 o1 A) A2 |3 F/ R& W
  

  L3 A+ k+ o# y0 Q* n1、声明式事务管理：

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

2.做法：

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

2.2

2.3 注入数据源

+ X, ?8 P: \. c! V2 h
# e4 C& s/ c% j! N% _; X6 i& _

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

0 x  L( ]6 R$ D2 Y" B1 D

, `! B" j4 x! \" W8 i2 j! G! U! O0 k

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

% _1 U$ V1 A+ @3 {4 D$ w1 [$ a
5 L" g. g) i: c: W

( t- A+ Z% ~/ U% r; t8 O
9 ?4 M/ e7 ^  a" H: J8 d

2.6 定义切入点

8 P2 p8 o: j. W4 z# G) ?6 [* [

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

1.注解@Transcational

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

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

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

1 G6 Y; b& t6 \; P# H  ~- {& H* o- x" @
4 p$ t0 J0 S! u* H

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

4 n! e& D$ D: h; z* E

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

admin

事务
; A+ L6 s2 |# T  X1 b  X1 DACID
（1）原子性（A）：一系列的操作具有不可分割性，要么成功，要么失败
" t: ~4 i1 d! [. \/ z- @8 m9 y' s
; I7 s7 w: \/ u1 d& f, n  l（2）一致性 ：操作的前后满足同样的规则，保持平衡。
" y$ W2 B6 @! r7 X
! x8 Q8 @* A$ m5 I. C/ h（3）隔离性 ：在事务运行的过程中。事务内的数据对外的可见性和可操作性（必需由数据库的支持）

（4）稳定性 ：保证数据在事务的操作的过程中不会遭到破坏，而且是永久性存储的
( W2 f0 }6 W: O! T9 O
% ~# s# `! r; s3 c7 j

0 m' R! Z5 d' }+ Y4 y& l事务模型
（1）经典事务模型又叫平面事务模型（JDBC） 事务不允许嵌套
) i8 y- E  m0 B4 R& `
( H  j% h' Q! D2 s$ ^+ V（2）嵌套事务模型
7 X! A) Y# x' @

) I+ m! H4 z9 d
7 C* C1 L& K0 \' a1 j8 W事务的两种方式
（1）声明式

6 Z* U$ O+ A7 K: h+ i6 \9 p在配置文件中设置以下6项

（１）.required

5 {' Q3 Q7 v$ j# J1 N% }如果客户端没有事务　在bean中新起一个事务
! d& f& _0 ?3 ]6 M8 M- i' n
如果客户端有事务bean 中就加进去

(2)、 requiresNew

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

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

(3)、supports
, J* e  v- i6 u# i2 q* ~
如果客户端没有事务服务端也没有事务

' h" ]  L/ C1 c5 ]) U/ T如果客户端有事务服务端就加一个事务

7 L4 m) b% w# M+ O! j7 n# r+ c(4)、mandatcry
- l" \  B! \  |$ A3 E0 n0 s
2 U1 x  |) `2 o1 q如果客户端没有事务服务端就会报错
: C  a# t9 l7 U0 D/ P9 H$ S. N
如果客户端有事务服务端就加事务
$ L: g3 d9 }+ N& Y3 `  l
* f* |" @1 g. ^5 y: J9 _8 Z0 c(5)、notSupported
0 n8 D8 f& N% w/ D, K
" r0 ^) `' r  Z; N' ]) T% u  ?不管客户端有没有事务服务端都没有事务

如果客户端有事务服务端就挂起
. P7 l, X$ L4 a: h  m0 V" R& c
(6)、never

不管客户端有没有事务服务端都没有事务
# V& s; s) B, E8 W7 J: m( y+ L
% ?" Y7 A1 G2 }0 Y3 A; v1 T; L; Y如果客户端有事务就报错
& t* c/ E) W, I! t
（2）编程式事务
; O) I' |3 i2 o
Javax.transaction.UserTranscation

5 Y  Y3 U4 s( Z0 X! `/ lJTA 事务可以精确到事务的开始和结束

% u; r! S; D* ^, k1 ~" J

事务的隔离性
/ L1 z8 z! v4 F: QRead-uncommited
/ ]4 [) T# T7 ]5 k% g" o7 x4 x
读取未提交的数据（基本上没有锁）脏读，存在不当读取的问题。
6 v" z( f' i* A' V6 R7 }: H
Read-commited
5 |- P) y! B1 u
读取已提交的数据（行级锁）
' Q' k  n5 `6 O( e* {
无法读取已经写入，但没有被提交的数据。
) O9 g; t9 B- {: C! n3 K
Repeatable_read

读取的数据不允许修改或删除
* [: u) b+ Z; h: i3 D. u
不可重复读（行级锁+不允许修改/删除）
( X6 N( i4 E1 f" J6 U! S4 N4 b
Serializable
& N& e9 S6 K6 s* A: @; `$ l
3 ~* Y  p5 E0 W0 K- b2 t* K4 g幻影读（表级锁）
# `, F/ R& d; F$ P  E8 V
2 F1 T/ z9 W9 }1 @# [4 o$ R( d9 C5 O
  }6 H- C; V! ^
struts
开发流程
. S: t. j; J. b& n  F  m& c7 e
1、创建表单
& O1 |" R  a  B1 w) ^$ P3 I* n
2、从表单中获得输入

" R+ H3 y' I& |* k4 Z5 h2 T( V3、处理输入（业务逻辑）
3 ~2 O/ r! U3 A
* L" |' E2 X+ B: z7 e4、根据动态输入改变输入流

要完成上述四步，我们需要创建
7 }1 ?* r' U" N+ d- {$ P
1、一个ActionForm

2 O; |: U& V; @+ j7 g9 p! V9 i) T2、一个action

3、一个配置文件struts-config.xml
& T. Q7 K3 E7 R( l( L) V
1 }4 f$ ^* m0 X& \4、创建页面
: o/ L5 E0 I- N
. \1 ?  l7 S& V创建ActionForm
7 V, O. I; h( F6 G  _7 ]
7 e! q* K8 x, ^3 O; N2 U0 u1、写一个类继承ActionForm
% ~1 J) s1 ?6 {, @* C$ O) m) q
3 T! ]% F, I) ~* D& {& l; r2、私有的属性

3、相应的get、set方法
0 V# A7 l3 }' \% O
4、重写tostring、equals、hashcode三个方法
! |7 o4 |$ i% r( [9 x! k/ Y# Z
创建action
, r% P! \* E) |; D6 v; a) |5 m4 `
1、写一个类继承Action

2、实现一个公有的方法（回调方法）
. e4 D- i' _, j
public ActionForward execute(ActionMapping mapping,
) e  p  L, M5 r, Q
  p0 s* o! B/ X, f- X9 ZActionForm form,
/ }, B/ y5 ~; U$ j( K" Y% l) F
3 \$ y$ l; Z! ?# J% l) w4 G4 pHttpServletRequest request,
3 ]; ^4 v& W+ u8 p
HttpServletResponse response)

{
0 l" T% Z0 k& s, j
//1.收集参数

MyActionForm myForm = (MyActionForm)form;
' _* H- b0 Q) k6 e% n! o4 R
4 t' O$ ]; M" W//2.组织参数

; v- e% ?; y$ o5 `3 I% F2 d% c' B' ^- x
* }. m; @+ w0 b5 s8 d! K0 ^0 o
" U6 n/ ?! \: d+ |# ~! Q* G//3.调用逻辑层
6 @/ K% k! W4 j# U  \
. A& k2 q3 g6 P+ ~boolean flag = true;

( _+ x8 J% j# r: _; D//4.根据返回值来跳转到相应的页面
  x0 n% V( v; p& O
ActionForward af = new ActionForward();

( I# A( |" S8 y; w, s$ q/ Gif(flag){

" s* ?  K0 g& C& Saf = mapping.findForward(“1″);

$ }* e1 }6 K8 c: x' G! _}else{

af = mapping.findForward(“2″);
6 m, A( {  }4 l! G2 l
- f* p+ G/ W0 a5 Y; D. B) [}

return af;
; D2 H0 h; m! w
}

9 o) \. ?& [2 y6 V' Z配置struts-config.xml文件
0 r5 }9 n- g! a% M' M; J
: Z6 q7 L2 q: I' W, y1.<form-beans>
# h" p3 C5 n9 y7 ?% Y
<form-bean name=”myActionForm” type=”全路径.MyActionForm”/>
! g: A) D1 ^. s
<form-bean />

</form-beans>

+ B  H2 a% v$ N$ D  T2.<action-mappings>
2 O1 h# e% ?8 T1 \0 R: O7 a6 L
<action path=”/sll”
8 T; B, B+ e. b. U+ t
+ Y) @. _' x# F0 }/ O. n* J" Dname=”myActionForm”
+ X$ ^* y' }2 G) J5 N
  I1 O: ~2 R, _7 F* `+ U  I* ]6 I  btype=”全路径.MyAction”
# v& k$ K: W' i/ J9 U6 H
8 B& l& `0 M5 X8 Oscope=”session”

input=”错误返回的页面”>

<forward name=”1″ path=”/1.jsp”>
4 \' n' f6 r- }" l$ v
<forward name=”2″ path=”/2.jsp”>
: y) K( e; W3 Z. W2 K0 e9 q$ l. N7 _
</action>

</action-mappings>

步骤:

1.创建一个空的web应用

2.将struts的包放到lib文件夹下

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

4.配置struts-config.xml文件和web.xml文件

5.在页面引入tag文件uri

STRUTS运行机制

. O, G/ l" B4 K$ T- u1、界面点击产生请求
, V0 ~0 @8 a' D1 M0 h
9 k. K  a( y/ L) ~2、容器接到请求
# @8 S# a) N2 A" d3 S" t6 K
; s& Q; W, A: H3 j$ D0 t4 S2 y  H3、匹配web.xml文件中的*.do来调用ActionServlet
) y8 M& p: d% O0 ~& e2 ~  T
6 _; M8 {; \5 ?( z- p. K% ~) m4、ActionServlet的处理

1 ?4 x* M  ^7 P% j' }+ r- _( @4.1 读struts-congfig.xml文件形成ActionMapping

4.2 通过path 来匹配Action类，通过Action的name属性来匹配ActionForm类
2 d, c+ e2 c3 F: Q; O* F
4.3 通过反射机制来给Form添数据

$ _8 ?6 Q  ^2 D/ ^0 W4.4 由ActionServlet转调Action的execute方法
% e1 \7 l$ n$ Y8 F" l. s7 {
4.5 得到execute方法的返回值，跳转页面

1 D  K- Z: D6 T! A  m4.5.1 RequestDispatcher

+ T5 W2 u3 B2 d' e; a1 @4.5.2 response.sendRedirect(“list.jsp”);



进入execute方法
+ z. _" k# P8 X0 E! L; b
! S* Y) F+ k" N1 收集参数

2 组织参数

3 调用，逻辑层

3 N0 T6 [6 e1 i1 u, {4 返回值
1 X- v3 t: o9 ]- b
# _" N- O/ ~! i. \( m4.1 选择下一个页面 （ActionForward）
7 M4 v; |: n- p8 i' g
4.2 把值传给下一个页面
. p) z! a4 D1 s9 l/ b2 _7 E" i- a
! K1 Q& g& g! l4 C& M

3 S' V7 r5 J, |- u$ Z8 l; F; b. i+ s比较struts和struts2的不同

Struts

! |5 q+ B6 S- B2 DStruts2

组成        五个部分：ActionServlet，ActionMapping，AtcionForward，ActionForm，Action        十个部分：AcionContext，FilterDispatcher，ActionMapper，ActionProxy，Configuration Manager，Action Invocation，Interceptot，Action，Result，Taglib
7 B6 ~# H! R+ ~5 m% Eurl        .do        .action
分发控制        AtcionServlet        FilterDispatcher
收集参数        利用JavaBean技术，将数据封装到ActionForm的子类中；
一个Action对应一个ActionForm的子类

$ g2 X) K; U  B2 S6 i/ `9 [& t  i, w使用拦截器将数据封装到值栈中。
% }! _  @+ m3 ?( [3 b使用域模型，一个Action对应多个值栈中的Model
) i2 N( ]5 J4 C4 u7 F6 v- m
读取配置文件        ActionMapping        Configuration Manager
6 ~3 A* W( c- N. B% e拦截器        无拦截器        执行Action前后有拦截器
4 n9 u$ b( u8 V+ R9 Y返回页面        将字符串封装到AtcionForward，进行跳转页面        Action中直接返回字符串，通过Result跳转页面
页面跳转方式        两种：dispatch，redirect        三种：dispatch，redirect，chain
值栈        无值栈，Action通过在request范围内设置属性，向jsp页面传递数据        有值栈，Action和jsp页面通过值栈传递数据，jsp页面通过OGNL取得值栈中的数据
! k, V6 W' c: S  M2 N配置文件        struts-config.xml        struts.xml
; n- x6 m* J- \* ~- ]) E0 m中文问题        不能解决（需要使用filter）        可以解决中文问题：
- i- u1 z! z! h4 X4 ^1、在jsp页面添加Meta；
# b. x- g3 C, F% V3 w6 y
2、修改struts.properties中的设置。

admin

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

8 b  z6 I; a( a7 R- I9 ]一、配置ant的运行环境
$ }, @. D! [6 u  K. d: w
1.将ant的bin目录添加到path中

, w* _  u* q8 }& c2.配置JAVA_HOME

3.配置ANT_HOME
# \5 [4 P: Z) y3 X" p! i& c, t
% E/ W2 d& z7 S& }# Y5 m二、配制build.xml文件，该文件放在应用程序的根目录下
, L6 R/ C8 q- Z9 A$ B- T1 G& O( z
/ B. I3 o9 q1 O% Y3 f4 z" `9 \编译java文件
# @& [4 ?! s; d% j
执行java文件
3 P, c! ]. j5 X* j' p9 B$ n
- x8 T) ]1 \! Pcopy

$ A& C# Y3 }8 h0 ^+ j: _" |删除

打jar包

/ Q2 r- n% B* |; f  K4 f根据注解生成配置文件
( y5 e# `8 |) C, ?2 m! ^
( z3 y$ E! z, K- [) F1 _2 GXdoclet
通过注释生成一系列文件的工具（txt、xml、java、html等）

7 Q  ~9 w! ]) b* O/ }& C0 }xdoclet本质是摸板技术+字符串的替换

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

5 ]! c0 j3 |( k2 I1.1 在类的上面 写与表的对应
6 k( w8 \* z0 q( P2 y  H
1.2 将每一个属性的注释都写到get方法的上面

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

' k& a+ G8 _2 C2 T% c5 t8 f

* a  Z8 c' s8 i  H9 q' H: mlog4j日志管理
1、是什么？

: E* \6 D$ L5 z: R  L在开发期间用来测试、对整个日志信息进行管理的工具
( _* H3 x7 d# c
# \# _' @. [) Z2、功能
" d: T7 S. o% {, Q
1.控制输出的目的地

2. 控制输出的格式
; C  B0 _  `' d8 s2 A0 F# ~. @
3. 控制输出的级别
) \" _* I- `0 y% f
  m9 O0 |7 r; r) y1 k3、日志的级别
5 |: [- u# t- {9 t$ O
# B: y4 L; p  Q& L: A& [1. debug 调试
# m+ R# b  s! ?* D' L1 J! L' j
2. info 给用户的提示信息
8 T; I( R  ?3 r1 {0 {, H
3. warn 给用户的警告信息
2 n3 l# d. ?& a: V+ P5 _8 y& C
4.error 给程序员用来调试
8 e* z/ E+ C4 y, {1 l
Debug—-〉info—-〉warn——–〉error

0 R" s- W" u4 G5 i! @" q  t3 _4、配置
, B5 I* p1 {! Y# S* b% ?# Q( N# ?
1.配置级别
! q7 ?7 B8 J# t) k9 i- S) M9 c4 w
2.输入源 （控制台和文件）
: Z7 t2 h! ]' [& n
3.可以进行分包控制

  Y6 H2 a& D0 _  T& ELog4f.logger.包结构 = 级别
) m' G) L$ V% g4 J* G8 r9 b
: ?1 b& W7 ~. t4 n6 d5、使用

/ _: i+ A2 {. @* |+ jLogger log=Logger.getLogger(Test.class);

0 o# f+ B) C& j) N+ @4 D' s    public
; b  r. c. J6 H5 |' Mvoid t3(){
5 E9 a8 L1 W+ W; h
- U* N' e! s- c8 O7 w* V' e        log.debug(“this is debug”);
9 g5 f: ]$ i, _4 v" i7 I
        log.info(“this is info”);
3 p4 E2 S5 a7 q& T% z4 a
        log.warn(“this is warn “);

        log.error(“this is error”);

    }
2 l4 k  b2 A" G
Junit
$ n3 s2 H) v9 K+ g1 W5 o7 }- E( X1.是什么？

! l# _- _5 ^( R单元测试的框架
0 s( I3 c  J" p5 C
0 h, q- v0 E& t* o2.怎么做？
$ V* N: ]$ g, b0 \7 r7 ^
- O: Y/ _% w# s9 ^& J0 M" ~写一个类继承TestCase
5 M& x# p- z' O" `  l3 }; }
测试的方法一般都以test开头并且没有参数
6 M) B8 J8 ^4 V, ]5 G) z
2 F. x: t0 P1 R在测试方法前执行的方法public void setUp( )
( }% U3 C) A5 d  U1 e+ m. S
+ M- `0 Y9 E* `' T; q在测试方法后执行的方法public void tearDown( )
8 [5 F6 Y4 ^& h% E9 u: e& S
7 ^2 ?- t' S: A; eerror和故障的区别
; G- e. `  v, L% R6 {/ `
error ：代码有问题

故障 ：逻辑有问题与祈望的值不相符合

生命周期

测试—〉SetUp（）—〉testXX（）—〉tearDown（）—〉结束；
( I  q( V9 u3 {
4 z; W# y/ `0 K! o% J: K. Z  iTestCase套件

public class MyTest{

        Public static Test suite(){
0 I$ S$ o3 v! k) s9 R# P; o  I' Q
TestSuite suite = new TestSuite();

& {. B/ F' U$ M4 g, w& Gsuite.addTestCase(Test1.class);
9 Z3 z% F  p$ u( W3 q7 ~% K
suite.addTestCase(Test2.class);
" B; b- a1 p: D9 z4 ^: H/ O
}

}

6 t- {) h& K: S9 b
/ b6 O2 _. l2 R" L
Ajax
是什么？
. S) |; v- w+ G3 w* G$ z5 T, pAJAX即“Asynchronous JavaScript and XML”（异步JavaScript和XML)。是一种创建交互式网页应用的网页开发技术。

无刷新页面。

. F* J7 x. N9 P有什么？
8 }; ?0 r: f4 R5 ~; c; Q' PAJAX是多种技术的综合，包括JavaScript、XHTML和CSS、DOM、XML 和 XSLT、XMLHttpRequest。
% C/ I; g5 W5 D
能干什么？
9 ^* Y1 }) ?+ G5 m使用XHTML+CSS标准化呈现；
使用DOM进行动态显示及交互；
0 [3 f! y) D& c( }; L: x使用 XML 和 XSLT 进行数据交换及相关操作；
使用 XMLHttpRequest 进行异步数据查询、检索；
) E+ w1 H  X' Q# ~使用JavaScript绑定和处理有所得数据；

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

与此不同，AJAX应用可以仅向服务器发送并取回必需的数据，它使用SOAP或其它一些基于XML的web service接口，并在客户端采用JavaScript处理来自服务器的响应。因为在服务器和浏览器之间交换的数据大量减少，结果我们就能看到响应更快的应用。同时很多的处理工作可以在发出请求的客户端机器上完成，所以Web服务器的处理时间也减少了。
. s8 l8 d* }5 u! M6 y
使用Ajax的最大优点，就是能在不更新整个页面的前提下维护数据。这使得Web应用程序更为迅捷地回应用户动作，并避免了在网络上发送那些没有改变过的信息。

对应用Ajax最主要的批评就是：
) @+ u/ W6 R- W# I. i5 B1 它破坏了浏览器后退按钮的正常行为，就是用户点击后退按钮后不能看到之前的数据；
2 一些手持设备（如手机、PDA等）现在还不能很好的支持Ajax；
, R8 k' Q2 _( o6 r2 h1 l. n9 V3 用JavaScript作的Ajax引擎，JavaScript的兼容性和DeBug都是让人头痛的事；
4 Ajax的无刷新重载，由于页面的变化没有刷新重载那么明显，所以容易给用户带来困扰――用户不太清楚现在的数据是新的还是已经更新过的；现有的解决有：在相关位置提示、数据更新的区域设计得比较明显、数据更新后给用户提示等;
* I" j9 G* E0 Q2 E5 D% q; u
& ]! b' E0 H+ r( c+ P: K怎么做？
<script language=”javascript”>

var req;

- y' i+ v! d) Z$ o8 w$ qfunction add(){
: ]) c7 h- V4 O% ]
//1:创建用于传输的对象
4 W* \) B2 H- a* A/ }4 P
req=new ActiveXObject(“Microsoft.XMLHTTP”);

$ y  J+ v  R/ j) G0 W2 Q// 声明返回后，处理数据的方法
4 _6 r$ n5 v2 w8 _1 f7 t3 D, ?
* e% V+ h$ u: A) P5 A, P1 xreq.onreadystatechange=manage;

//2:准备传输的内容
+ e: e3 Z: Y7 p7 ~) A, k
0 P8 s( Z1 G7 a: j; d* Q2 yvar str=”test1111″;
3 c: {; ^0 R1 M/ G, d) P5 O
$ h# U- s% m. l4 s//3:发出请求

req.open(“GET” ,”/others/ajax/test/t2.jsp?str=”+str);

req.send(null);

0 N. U- z" ~* L; h$ e' M4 ^}

4 z) R, i4 ?( @) t/ X) W//4:接受返回并处理
! @% o: ^& I, Q
function manage(){
8 z2 M, H. F& }3 q
if(req.readyState==4){

alert(“r==”+req.responseText);
, H3 u' z5 p5 E# m
}

}
7 Y( n0 z/ i- s3 J  [
</script>
. Y" i5 m; c! k* i  ~1 G
* D! e0 R, h$ ~0 i+ Q( P9 VreadyState的取值如下：
1 A9 b% {  Y$ P6 B+ u5 q* |
4 i5 ^8 X3 t& _8 P. o& E7 T; r2 M( a　　0 (未初始化)
: W8 w% R1 A& B2 W+ G$ }
+ T$ M$ m% p& m) _  _8 H. |4 y1 l　　1 (正在装载)
6 b4 {; D0 Y4 r5 M( c* O: D3 c# C
/ I: N9 |" y  G9 Y, h$ Z3 }　　2 (装载完毕)
% F# D/ V) {2 A/ v  g$ v- V
　　3 (交互中)
3 ?" r- a$ a7 d, M3 ?7 }, D
6 O3 ~1 I1 F7 ]/ @" d7 K　　4 (完成)

+ T8 |% [+ ]; j$ [" c" E& ~
+ Y; @+ a/ _+ b5 G) V
原理
8 k. E: R" J8 r% @Ajax的原理简单来说通过XmlHttpRequest对象来向服务器发异步请求，从服务器获得数据，可以是xml格式，也可以是一个字符串，然后用javascript来操作DOM而更新页面。
4 E* D6 N" Z# q  J2 L) T; ~' P* ~
Dwr
是什么？
+ R7 g, c- g# [8 J# E' T6 gDWR（Direct Web Remoting）是一个开源的类库，可以帮助开发人员开发包含AJAX技术的页面。它可以允许在页面中使用运行在WEB服务器上的JAVA函数,被调用的JAVA函数就像是在页面中JavaScript方法一样。
2 F0 h2 N5 u: d) y0 u+ w
: r$ H* {0 ]4 |有什么？
它包含两个主要的部分：允许JavaScript从WEB服务器上一个遵循了AJAX原则的Servlet中获取数据；另外一方面提供了一个JavaScript库可以帮助web开发人员轻松地利用获取的数据来动态改变网页的内容。

" ^7 M/ @/ O4 `& f7 I- C

能干什么？
- r: U# n% I' Y( j6 ^+ m! e+ R动态地把java类生成为JavaScript，感觉调用就像发生在浏览器端，实际上代码调用发生在服务器端，Dwr负责数据的传递和转换。这种从Java到JavaScript的远程调用功能的方式使DWR用起来有种非常像RMI或者SOAP的常规RPC机制。

: E' A! z2 W; x. O

怎么做？
1 }' j; F( u" E. L6 I6 J; q① 编写配置文件

web.xml

<servlet>

% |/ j3 {6 z! ?! @<servlet-name>dwr-invoker</servlet-name>

: @3 b9 c0 n- n6 W8 |/ Q! Z: [<servlet-class>
% H; c$ Q3 i. V1 a2 `! A
7 d1 @5 @5 m+ ~5 C: morg.directwebremoting.servlet.DwrServlet

</servlet-class>
2 q3 o: I( J; v4 u
5 f9 a! B" W/ W. R<init-param>
/ ~. y6 W3 C- C
. E: k! ?( D! ^+ _' x2 o: J* u% m<param-name>debug</param-name>

<param-value>true</param-value>
. G$ [( h8 F+ f0 N" C
</init-param>

</servlet>
5 i. S% C! q! p' E$ Y* N
<servlet-mapping>
( R3 D# [% X, U) u3 r
  `! N% m) k. |# z<servlet-name>dwr-invoker</servlet-name>
2 T8 j- U  m# B4 s
2 e" h& f# b. d<url-pattern>/dwr/*</url-pattern>

( F2 [3 }  e2 z. r" p* T) H6 s% s</servlet-mapping>

! Z5 u* H# x8 o  f7 Fdwr.xml

<allow>
# u$ @2 {! c, h* A2 N2 p- M3 U
# Y6 V/ o' h5 b! {% f, n" p<create creator=”new” javascript=”kc2″>
( ~! Q, p! t  ^8 P$ k& a  h
<param name=”class” value=”dwr.Service” />
2 v, q$ S$ ]  n
</create>
! u: m5 a8 V9 {8 J( g
( r3 z4 s& P, f8 J</allow>

% `. X1 o2 e. V3 T1 E) F: W/ P- F3 F②编写service

public class Service {

4 C+ ]: K# n2 l2 Zpublic String sayHello(String yourName) {

: N: w* \( L1 l: {  b" |, S# l//可以是访问数据库的复杂代码
& A2 N5 G% Y; S; o  V% J5 ]. b
! Y: D% W) G1 q4 X; breturn “Hello World ” + yourName;
9 G" C7 i4 u( G- u! ^: K  A' }% W
}

* q  d; E" ]: D! s}

③测试DWR

将代码放入应用服务器（比如Tomcat），启动。
9 O  D5 P5 k- Q
, d- q6 q! k  T& ^0 H) w/ R然后在地址栏输入http://localhost:8080/你的工程/dwr
) T( j" j% E$ r" T( l; H/ R0 D+ K
- R0 G) P3 F! c# e, ^④编写jsp页面
& w2 G( |. I4 V" f# {2 n
1 L) n( _. B8 x1） 要引用3个dwr的js，其中engine.js必须要，如果需要用到dwr提供的一些方便的工具要引用util.js

9 D8 G4 m2 S- J+ h3 d2） 然后还要引用dwr自动生成的js，dwr/interface/service.js，注意js名字要和dwr.xml配置的一样
$ f& h& t$ W5 L; T6 H
7 Z7 i/ @+ ^& ?* T' ]3） js里的service.sayHello和java类的那个有一点区别，多了一个参数，用来得到返回的数据