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

admin

JEE
简述JEE
JEE　： JAVA　 PLATFORM　 ENTERPRISE　 EDITION

JEE是一个规范集；
% e' I! h$ W! x% m7 {- \
JEE是一个框架集；
2 V( j8 A( G% t
4 i4 s8 O2 T; q) {$ x, [2 xJEE是一个技术集或API集；

' L9 L8 l5 V1 B5 t适用于创建服务器端的大型的软件服务系统

( W% e  N5 C3 n
) x; @* l7 Q. s9 B* W
C/S B/S 模式
  L' j- r! h1 J) L$ |- ]$ OC/S client/server即客户机/服务器模式，客户端也参与程序的运行与计算（富客户端、胖客户端）
' P) s' R" y$ _  k" Z
B/S border/server即浏览器/服务器模式，又称为瘦客户端，客户端不参与程序的运行与计算
6 y9 O+ G/ {( C$ ]9 P$ t  e& K
  J1 d4 j. G1 Z$ A: N' T& N7 A
- c& w) k' y0 [( `; \+ m4 A' s
企业级应用（大规模的应用）的特点
1.生命周期长、稳定、可靠

; [. `! S6 i8 |# S0 x4 E5 p: E' F2.组件往往分布在异构的环境中，能够跨平台
; A* p7 e" j. N/ m: O
9 Q8 i+ A9 u& v3 T/ S0 A4 b# E1 r3.维护性、扩展性、重用性
, ?. `9 w: n* F' _8 k
- _6 e' ?  B% B4.有事务、安全、线程
0 h+ ?8 g( A0 w& |( y- p
1 q1 N8 o, w. i4 B1 z6 s

8 n) o/ T- ^/ N; |9 Z% x' k什么是业务逻辑？
依照业务逻辑划分模块，

所谓判定业务　就是具有以下特征：
% Z. H) e6 f( P3 b  C* l
4 S; @  k: V0 m/ V/ F! {1.业务流程

2.业务判断
2 w" n: i. S. C% m  m
/ x: |! z$ A' \3 ]+ y( F0 H- f3.功能组合



平台（角色）的划分
1.平台供应商。提供满足API集实现的厂商（BEA weblogic IBM webshphere）
0 b! G' W+ O( ]' ^% I
7 |* S0 P" W9 J) K) I+ a2.组件供应商

0 D: j" A; Q& H, C: A/ _7 Y: n3.组件装配人员

4.部署人员
9 Q4 W( s% n- R7 L7 m
: Z7 \/ ~" Y1 [. F5.系统管理人员

* o# Y. u8 n# y( t6.工具供应商 提供开发组件所使用的工具（Jbuilder、eclipse）


# `* J) u7 n8 S  ?( ~$ D- i5 n
- u* t6 d+ s9 }! C: Qjava技术分布（设计架构 模块内部设计）
1.表现层 Servlet、 Jsp、 JavaBean、 Taglib

2.逻辑层 EJB(SessionBean)
- c# e7 m. ~" n' d$ ]6 H
3.数据层 （　JDBC 　EJB（EntityBean））
/ b- [3 q: M" S: `
* k  e  n9 n3 `' f4.服务 JTA（JAVA事务架构） JTS（JAVA事务服务） JAAS（JAVA授权与验证服务）

5.分布式通讯 RMI（IIOP）+JNDI 、JAXP（JAVA 的 XML 架构）
# {# ~+ f" `7 e' m) B" q; J5 u' Y) \% B
# o; b/ {" W& {. j3 {5 l, `JAVAMAIL（邮件服务）、JMS（消息服务）、IDLC、JCA（JAVA连接器框架 （成））
7 w- R/ H6 n6 p( S
5 B: o" v4 V) ^
8 q' U4 F+ G" S$ r0 v6 {( @4 l
JEE的体系结构： 是一种组件的体系结构
1.组件 ： 能够完成一定功能的封状体（独立的功能的集合）

7 X5 ]  o: P" s* {; s不能单独运行，必须运行在容器上
; [$ O9 C9 ^4 @6 ]3 e1 B9 Y; f
! Z7 X* t0 [" v) s. v" s$ ?分为两类：web组件、ejb组件

2.容器 ： 提供组件的运行环境，并对组件进行管理（一段程序）
6 Z  q( V) D1 O5 f
5 d6 w" Q  U9 Q# s: w1 M2 T! |" T管理组件的生命周期

不能单独运行，必须运行在服务器上
% b9 x6 d5 n. r5 g( O
6 W  [/ J4 r  i程序（组件）通过上下文来调用容器（context）
$ G0 Y8 A# B( J
  @  T% z# S5 Z$ U: W! i' {组件通过web.xml向容器描述自己，使容器能够认识组件
5 }6 g6 c5 M/ s+ g2 _! g
1 D7 `; G% v  j6 l& Z1 B容器通过回调方法来调用组件
) Y! n$ g$ r& Z$ N. K+ ^9 V: ~4 a
分为两类：web容器、ejb容器

7 `3 y% Z! ^4 R) C# D: {3.服务器 ： 提供容器的运行环境，提供大量的JEE基础服务
% X2 I) G; \; D/ ?$ Q/ {
. ]4 U) G& X4 C+ l, _web服务器（只提供web服务）
0 m& g. x( C' b3 R2 ^3 [% ]' L- `
4 F  N' r# {8 kjee服务器（提供web、jee服务）

: _: K6 k) I& d
  w! v: T: d& @( O
6 ?7 u( J0 w- ?" i什么是回调方法
8 Z9 e# [) n- x. U$ K由容器自动调用的方法，就叫回调方法。



; ^6 _. R4 g4 B! A5 w5 G5 U4 IＲＭＩ远程方法的调用机制
2 N4 e2 g! ^+ C' [' t1 a1 ]例如：Ａ主机有Ｂ（）方法，Ｃ主机有Ｄ（）方法，Ａ　想调用Ｃ主机的Ｄ方法

& G, n, v; T9 h$ E8 q) h
( O* \8 V5 s8 j0 c0 P% N

- y0 s% p, M& G8 ?  s/ @/ S
学习方法
% `; W* k, e3 |" k  b( I7 u2 D- x1.规范（熟记） 2.熟悉API 3.多练 4.多想

admin

Servlet

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

war-                            web文档压缩包

—WEB-INF

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

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

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

3 M6 |9 b* Z5 b+ O/ v/ ]  q

jar-                             java文件压缩包

—META-INF

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

7 {9 b4 X% m" U, d9 @

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

–META-INF

—Application.xml 配置文件

–*.war

–*.jar

' i; M) \$ j0 p6 ~) g5 @) p

• 什么是servlet？servlet主要做什么？
  & }& {7 j5 O1 E+ M# s- [1 R+ w2 \3 q
  3 n. V, ~$ V- ]* F
  & _# c# A* r: s

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

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

; T! f3 f6 R: f0 o; g# P$ k' o  d

• servlet 与cgi相比的优点？servlet的缺点
  
  
  8 {3 s2 N- {) Z" S3 ?9 o

优点：

性能（线程比进程更快）

可伸缩

Java强健且面向对象

Java平台独立

缺点：

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

• 常用的servlet包的名称是？
  
  1 A0 S7 @7 s* O, M5 g
  ; Q8 K6 H% F; M0 ^$ Z! z$ i5 \# Q8 h+ R

javax.servlet

javax.servlet.http

/ s) ~$ b, c/ j" T# C# }

• 描述servlet接口的层次结构？
  
  - m' A% p9 J  J4 ~/ j! m1 E& k
  6 N  ~" B7 ^" c8 b% k8 o3 ]" c

Servlet

–GenericServlet

–HttpServlet

–自己的servlet

ServletRequest

–HttpServletRequest

ServletResponse

–HttpServletResponse

3 b) _( b6 E& D( L& R4 n

• 对比get方法和post方法？
  
  
  

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

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

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

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

4 a  S  g* R# |* M2 W- v" L

• 归类描述HttpServletRequest接口都完成那些功能
  ) L6 x5 M, o* b4 k
  : m& Z! S9 O2 |
  
  • 读取HTTP头标
    ' _- h, u, c+ ^2 {% S
  • 读取cookie
    6 d! X, N; o5 f2 a/ {3 f
  • 读取路径信息
    ( F- q1 {0 R4 x1 }6 b
  • 标识HTTP会话。
    & ^! ^4 }6 b, h! ^' J! G' t  Q$ k3 v
    

• 归类描述HttpServletResponse接口都完成那些功能
  
  0 R: _3 }2 E" f# ~4 t/ J2 x. Q
  + ?! B5 B( X$ X2 D0 j; v* l
  • 设置HTTP头标
    
  • 设置cookie
    
  • 设定响应的content类型
    
  • 输出返回数据
    2 i' i4 M+ U& n3 N% `
    - E6 C% K) ^- e1 m

• 描述service方法所完成的基本功能？默认是在那里实现的？
  
  # l2 l/ i5 d9 j& s" I/ H, X7 K# E
  

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

实现：默认在HttpServlet类中实现

• 如何开发自己的Servlet？描述应该做的步骤和每步需要完成的工作
  / [5 s% h) h2 W; j
  
  $ U4 x. o9 o+ W3 e. G: E0 q

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

" Z& W- s. v2 a: u6 d

• 为何servlet需要部署描述？
  5 C( @( n0 t% S1 h  q
  - d+ o4 G& R' v
  

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

• Servlet基本的描述应该是？请写出来
  ; D, M; Z1 K$ K1 v
  
  

# [1 @5 r& w" M$ Z+ p: ~

<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
    {1 ^- a0 `: X. z- [' W; y4 R$ V
  - ]+ H: ]: M' b* s% u
  ) L1 s. A' j+ `5 `3 n

FORM标记

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

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

语法：

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

{HTML form tags and other HTML content}

</FORM>

$ U+ }9 C3 X9 d4 o" W$ l

• 如何接受request中的参数
  
  String userName = request.getParameter(“userName”)方法
  & [5 v0 r7 ?7 m7 h' t* P. f
  

• 如何接受request中header的值
  
  ( g, C- U& B# ?# |
  

request.getHeader(name);

request.getIntHeader(name);

request.getDateHeader(name);

request.getHeaderNames();

3 t% C8 [& k2 o$ M

• 如何输出html
  / s3 ~+ a0 m; _' I
  ' Z) S7 s: P& L. l, B$ {
  * m* u; z. ~, |& }, N- `% L# b4 i; m

PrintWriter pw = response.getWriter();

pw.write(“<html>”);

pw.write(“Hello”);

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

% q9 L& G5 c1 |; u7 h5 k

• 如何设置输出的contentType
  9 ^$ ~9 f+ ^: A0 d
  
  

response.setContentType(“text/html”)

4 _9 F  y. G  [

• 描述servlet的生命周期？
  ( d3 t9 p5 u/ L( P+ h
  
  7 V7 l+ \, _6 I

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

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

8 o$ t+ q/ N' P3 u8 @/ E/ \# i

• 描述init,service,destroy方法的功能和特点
  7 T, s9 c4 j$ G" e& i
    z5 g$ e& y& i
  : ?+ K% @% ]3 @/ G3 t

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

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

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

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

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

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

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

• 什么是回调方法？有什么特点？
  
  
  $ G& Z: k' Q2 R! a, ~

由容器来调用程序的方法

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

7 [5 ]& ?% ]9 E1 }+ q+ T$ B8 g- X) u

• 如何设置初始化servlet的参数？
    H" A! Y% L, v2 C; \1 [" o; A3 F; E
  : z0 Y1 w' Y3 ~  U1 R7 v  U在<servlet>中添加如下配置
  7 q3 F1 f0 G% l# s. I9 T
  , `$ [/ j$ Y4 H

<init-param>

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

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

</init-param>

4 V0 ?( @# ?3 A3 {

• 如何获取servlet初始化的参数
  
  7 v) D& @! @; T3 O* C% A$ _& Q
  : e" o) g+ e' }5 s8 f% W

public void init() {

greetingText = getInitParameter(“greetingText”);

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

}

• ServletConfig接口默认实在那里实现的
  " g# ]7 T& H. [! d2 {0 v
  2 R& h& T4 G' T: j. U+ I2 R( v
  # C0 d1 l: Y& B* }0 |

GenericServlet类实现ServletConfig接口

1 H* U. T7 Z) g7 Z

• 什么是ServletContext？有什么作用？
  8 ?  s* f3 C7 }* O2 E2 Y* \
  
  6 [0 ]  M3 M) L0 M5 H

Servlet上下文

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

! \9 R5 [& ?( o

• 如何访问ServletContext接口？是在那里实现的？
  
  : Y1 l. F- ^# y, y# c
  ( G- M) |) c& n( Z

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

GenericServlet类实现了ServletContext接口。

& M+ s! U: V8 o8 A9 F4 A+ W: k

• ServletContext接口的功能包括？分别用代码示例
  & U+ {, Y: a& C
  
  ) i- l5 z1 _) P! v* U( j/ k, b

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

getInitParameterNames() : Enumeration

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

setAttribute(name:String, value:Object)

getAttributeNames() : Enumeration

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

getResourceAsStream(path) : InputStream

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

log(message:String, Throwable:excp)

• 如何设置ServletContext的参数？
  7 }# k- M/ N4 X9 R( T
  
  & T9 p! a! v5 g8 O0 P" J( i

<context-param>

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

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

</context-param>

8 I7 k$ B$ \8 z/ m0 Z

• 如何获取ServletContext设置的参数值？
  5 s) W" r9 o) n( m$ p1 x" ?& w
  ) o: ^3 {- r% d8 I1 z8 d2 S0 g
  

ServletContext context = this.getServletContext();

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

• 描述Web应用的生命周期？
  
  9 w6 Z( L8 ?/ m! E( x5 E* c
  ; B' w1 T" _$ q8 ]; O

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

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

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

. L* K3 r% ~, }6 h" ?4 u+ }

• 如何用代码实现监控Web应用的生命周期？
    L& _0 B% V6 E6 b, |$ e
  
  ( S9 S- I8 x  i: e2 u
  

public class Test implements ServletContextListener{

public void contextDestroyed(ServletContextEvent arg0) {

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

}

public void contextInitialized(ServletContextEvent arg0) {

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

}

}

  s2 a4 o( i( }. _% |

web.xml文件中的配置：

<listener>

<listener-class>

com.csy.Test

</listener-class>

</listener>

1 I3 p) t( N0 o  F. f0 H) G& S

• web应用中如下错误码示什么意思：400，401，404，500
  
  9 @9 t* I& X) w
  400 Bad Request//错误请求
  401 Unauthorized//未被认可
  404 Not Found//没有创建
  500 Internal Server Error//服务器内部错误
  
  

• 描述Web应用中用声明方式来进行错误处理的两种方法
  : y4 c1 O2 Y/ F$ h0 G
  
  6 p: F7 A( m; c7 g3 f

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

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

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

+ z$ E$ n$ A! g& ]

• 描述记录异常日志的方法，都位于那些接口？
  1 r. q3 B3 O1 N& H7 l& F
  . }2 \9 p6 h( l0 O6 o: D
  

GenericServlet：

log(message:String)

log(message:String, Throwable:excp)

ServletContext：

log(message:String)

        log(message:String, excp:Throwable)

& k+ v9 M1 c+ _2 B+ J* ]

• 什么是会话？
  
  
  

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

" U0 s; u& |  d' z: G

• 如何获得会话？
  1 }: i2 x0 _) [
  
  HttpSession session = request.getSesseion( );
  
  5 o( u% r$ v9 M, L

$ U" ~, |3 @) Z; t1 Q# e$ n0 T/ ~

• 会话Api的基本功能？
  
  ( o* u  L1 W: v6 a7 Z
  

getID() :String

    isNew() :boolean

    getAttribute(name):Object

    setAttribute(name,value)
" s! P! A* D# `( U: B9 k6 M# }

    removeAttribute(name)

% S5 h9 w; X. }' ?

• 如何销毁会话？
  
  & C2 U6 S' n- R, _* ~4 V
  ; h* N+ D0 G5 k! v& }

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

<session-config>

         <session-timeout>10</session-timeout>
, q) [3 B% ^; z

     </session-config>
" s! z5 e8 _# d7 \" j& [  b+ Q

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

invalidate()
" L+ V' U0 g1 y

     getCreationTime() :long

    getLastAccessedTime() :long

    getMaxInactiveInterval() :int

     setMaxInactiveInterval(int)

% g; ?7 j, z2 f: R$ `, L: C# I

• 描述会话保持状态的基本原理
  ( a( c3 ]" m! J) ~7 a+ [8 b
  
  

    client server

* @7 n4 T8 @  o" v" g: ~5 I& J

request
6 t* h% B9 c) v% p- i2 B3 Y

response (sessionid)

request (cookies)

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

: X( Y' N) L" c# ?. w; ^# b$ t+ U

• 请描述session和cookie的异同之处
  
  
  3 q# o( F4 @0 ~* m

$ N) G# t  n0 Y! B- u) B7 R
* S( C1 C7 u- H' `

• 如何读写cookie，代码示例
  
  2 b* x; d/ h8 P8 p6 Y
  4 `  j9 \3 I; _' E

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

response.addCookie(c);

读：Cookie[] cookies = request.getCookies();
! Q8 U5 C6 ]* M4 g9 f9 ?# z9 I

        for ( int i=0; i < cookies.length; i++ ) {
( L  g7 T7 b7 y/ B% Y

            String key =cookies.getName();

String value = cookies.getValue();

System.out.println(“cook”+i+“:key=”+key+“,value=”+value);
1 r1 S5 s6 H+ I" d

     }

• 什么是URL重写，如何实现，代码示例
  
  , d0 r7 F# \+ S) R
  & g0 [' X' R  L0 }. z' |

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

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

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

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

% i/ G9 p0 d: W7 ]/ w* X0 t% [
4 c0 a, M+ c, ^) o; R# m

• 描述web应用的4种认证技术
  " B6 o7 z0 x3 Y. v7 }
  1 [0 {) d( v8 ^$ U$ V
  

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

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

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

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

$ d7 g6 B. u9 o' g9 S% l1 Z% }

• 什么是授权，什么是验证？
  
  : g5 ]" j) k. k1 c, i4 y
  # g: b, J4 Q( q7 T+ ^- c

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

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

• 什么是HTTPS
  
  / e$ ]1 J' U0 E8 T8 O
  

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

" g9 s- [+ B+ c3 k1 P2 v

• 什么是审计？
  , u# W1 p* E5 [5 g6 v/ B9 M. O# H
  6 K& R. E/ u6 N0 U
  

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

" d. W7 |. s& Y" \, c& ?# O

• 如何实现声明性授权
  
  
  ) [2 J0 N; Y9 _$ ~) W

1、标识web资源集

2、标识角色

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

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

在 web.xml里配

9 r/ p$ k$ Y2 d3 `& N

• 描述servlet并发问题？
  # P/ b( @% D0 z; j
  
  ( H  U) O: _+ `' T. C9 X! q; V

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

( A5 K0 I; x7 \$ B- r

• 描述Web应用中的六种属性范围
  
  ' C8 }+ I; P: D" m) R! [: D* n- @
  % \6 b. [7 S4 S2 p# x9 V8 S

局部变量（页面范围）

实例变量

类变量

请求属性（请求范围）

会话属性（会话范围）

上下文属性（应用范围）

• 指出上述六种哪些是线程安全的
  * N5 d9 E- z7 O  Y
  
  ! Y# F7 z. R" ?0 V5 B

局部变量和请求属性

• 什么是STM？如何实现？
  + {5 T/ O7 J* z! w! Y% a
  ; y( c3 U- s, l
  ; w+ h+ r* F, V# Z

SingleThreadModel接口

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

• 如何实现并发管理？
  3 A0 X& m6 @6 M
  
  

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

使用synchronized语法控制并发

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

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

admin

Jsp
& t4 m+ t2 u7 p; V( t什么是Jsp?
7 @4 h; b' ?2 w/ ZJava Server Page    结合java和html在服务端动态生成web页面的技术


3 u. ]3 b! A0 V5 g
( i, c* {) _$ B* [# l8 _描述Jsp页面的运行过程？
第一步：

请求进入Web容器，将JSP页面翻译成Servlet代码
3 p% D1 H7 T. X$ H/ p" U1 ~7 ?
) v$ N2 h  i3 \+ N& `) d第二步：
! K# c0 z! A! i. U
' o" m( d  G, d* j0 O编译Servlet代码，并将编译过的类文件装入Web容器（JVM）环境
0 |( q" ^: R0 q1 A5 |: L
& V; |' y9 p/ M5 h第三步：
/ l. X7 r( i/ q6 p9 E
* L$ S: c$ j; U$ C/ P' f; V# x/ sWeb容器为JSP页面创建一个Servlet类实例，并执行jspInit方法

$ V4 x* r% j  Y+ J+ A第四步：
9 l# A4 E7 V) \% a0 J# n3 B
$ |' U; g6 a. t7 [2 L1 X. EWeb容器为该JSP页面调用Servlet实例的_jspService方法；将结果发送给用户
* [6 {4 p3 u8 L4 H

+ D( \9 t+ ?$ d* X. W7 u
描述Jsp页面的五类脚本元素的功能、写法、并示例
注释 <%– –%>

: e) Q* L, {( u<HTML>
3 C+ E  ^  l  F5 q% J1 D' q! A+ r
<%– scripting element –%>

</HTML>

# \; B6 ^, Z. ~2 b8 l. u3 b指令标记 <%@ %> 指令标记影响JSP页面的翻译阶段
& @7 q3 ]3 d) x, @
<%@ page session=”false” %>

* d' O" Y& D, V6 e8 |- P声明标记 <%! %> 声明标记允许JSP页面开发人员包含类级声明

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

- n( H7 K( M2 Q- v0 D2 S2 O, W4 D    脚本标记 <% %> 脚本标记允许JSP页面开发人员在_jspService方法中包含任意的Java代码

    <% int i = 0; %>

表达式标记 <%= %> 表达式标记封装Java运行时的表达式，其值被送至HTTP响应流 <B>Ten is <%= (2 * 5) %></B>
3 j5 ?1 c; k$ {% F4 O- C" A


7 @+ h% k* M) m! L7 O7 g" g描述Jsp页面中的注释种类和写法
HTML注释

: q) n1 s" @- F<!– HTML注释显示在响应中 –>

" ^( M! L$ b7 L$ i& i) w5 S; QJSP页面注释
2 ~9 g" |% I* \( T$ Y# l; h+ J
<%– JSP注释只在JSP代码中可见，不显示在servlet代码或响应中。–%>
: ?* G- p& `; P! Y/ m
Java注释
& p: N8 p4 L* y% @5 {! R2 ~
; W6 O) x, ]8 E, P4 o/ r! Q<%
7 W8 \' E- ^8 W- q
/* Java注释显示在servlet代码中，不显示在响应中

*/

%>



描述Jsp页面的指令标记的功能、写法、并示例
2 c' s9 }: Q  K1 H. W5 n& v指令标记影响JSP页面的翻译阶段
$ I2 }# \3 I" I/ `  b3 y
: [& E# R2 ~. ^( @2 _. X0 p<%@ page session=”false” %>

/ R. ]6 ]( y3 F6 i9 I5 F( A<%@ include file=”incl/copyright.html” %>

9 N" c2 Y4 k" M3 h7 @0 G, G<%@ taglib %>

2 O3 g* c5 q9 x5 r% J3 w

* a" A" _5 l! X# ^" [4 {: A描述Jsp页面的声明标记的功能、写法、并示例
声明标记允许JSP页面开发人员包含类级声明

写法：

6 v  ~, h. _. I4 u1 z. ~! v; Z3 K; V<%! JavaClassDeclaration %>

例：

& c+ ?5 D* D7 y# M4 j3 K/ w% K<%! public static final String DEFAULT_NAME = “World”; %>
! z& c7 d2 H- _& K
" ~  W  J, d. N( K: M8 s( g<%! public String getName(HttpServletRequest request) {
! _+ S  E2 R6 p
return request.getParameter(“name”);

}
  T5 e9 @' ~: x( Q" k% q% j
4 Q  w9 g/ k$ i2 D, y  A( {%>
! v/ V: L& R4 U; d
+ G: M, Q) T; \, }: c4 C# e# {$ k8 V<%! int counter = 0; %>
3 l- d  B( Y' m  \% k2 A/ q
. K+ x. X" `. l& Z& {0 D" Q$ N

/ n- V1 d: P% ~描述Jsp页面翻译成Servlet的规则
/ x7 }- x5 g& kjsp中的注释标记被翻译成Servlet类中的注释

; J) o2 w4 V3 [: B; u  ?2 rjsp中的指令标记被翻译成Servlet类中的import语句等

/ O% v( Z( y+ d# z" Ljsp中的声明标记被翻译成Servlet类中的属性
; V8 b$ W$ z5 I+ m0 e7 g( _
jsp中的脚本标记被转移到Servlet类中service方法中的代码

7 d/ R6 V. L( H) M8 Z5 ^# Gjsp中的表达式标记被翻译成Serlvet类中的write()或者print()方法括号中的代码
0 {3 v1 R# Z; p
! I) h% n2 V/ G2 t: C* l
# s1 J2 G4 `* |- M
描述Jsp页面的九个预定义变量的功能、用法、并示例
request 与请求相关的HttpServletRequest对象
5 N5 x: |4 h" n# R2 G
response 与送回浏览器的响应相关的HttpServletResponse对象

% F# j6 g" p( w' i% z5 F% Fout 与响应的输出流相关的JspWriter对象

    session 与给定用户请求会话相关的HttpSession对象，该变量只在JSP页面参
! O  Y! R) P) n# i& Z  v7 J
& |; o. `/ L) d' o9 {( O与一个HTTP会话时有意义

% d2 i% @: i, q    application 用于Web应用的ServletContext对象
) K# M; M* B& m6 ]
config 与该JSP页面的servlet相关的ServletConfig对象
* X( Y5 X- c/ c9 J& G- F7 m
pageContext 该对象封装了一个JSP页面请求的环境
! j3 l. R  e7 e( g
page 该变量与Java编程语言中的this变量等价
' R9 Y- D. O3 H- n
, N! [: n! j( A9 t    exception 由其它JSP页面抛出的Throwable对象，该变量只在”JSP错误页面”中可用

' Q8 u; v+ x1 O! K; T( K& J/ \9 R

. q1 f+ B1 r" k9 Jpage指令的功能，写法、并示例，并描述它的如下属性的功能和用法：import、session、buffer、errorPage、isErrorPage、ContentType、pageEncoding
import import 定义了一组servlet类定义必须导入的类和包，值是一个由
% x0 M6 C2 U: N4 \
逗号分隔的完全类名或包的列表。

, I( e, V; }" _/ k7 z- |session session 定义JSP页面是否参与HTTP会话，值可以为true（缺省）

* [6 y0 E" |0 [, h4 k, x+ k或false。

4 v& f; j3 P- obuffer buffer 定义用于输出流（JspWriter对象）的缓冲区大小，值可以为

+ Y% {/ X  _1 a: b1 ]" Qnone或Nkb，缺省为8KB或更大。
* W  J0 Q# U0 \
errorPage 用来指定由另一个jsp页面来处理所有该页面抛出的异常
) p, p; n, R! Z( N0 h7 V
isErrorPage 定义JSP页面为其它JSP页面errorPage属性的目标，值为true或

false（缺省）。
0 W* g! _" A- p% W
$ Z7 c0 ]& [" n  m$ j; AContentType 定义输出流的MIME类型，缺省为text/html。

- J# B( h. n3 f% c. EpageEncoding 定义输出流的字符编码，缺省为ISO-8859-1



* n8 N; o% M, r* V描述MVC各部分的功能？MVC的优点？MVC的缺点？
MVC各部分的功能：

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

封装应用状态
: E& ^! r$ U# E
9 A( Z  Y$ H9 J# b0 G9 ?响应状态查询

( A" W6 t. Y8 z, O暴露应用的功能
, j5 F- A. N1 u
Controller（控制器接受用户的输入并调用模型和视图去完成用户的需求）

" z, ], @3 D4 O" @" H( M1 A验证HTTP请求的数据

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

' i: T& r6 \( z; q! V7 ]选择用于响应的视图

View（视图是用户看到并与之交互的界面）

产生HTML响应

+ k0 s% N! x8 D请求模型的更新

提供HTML form用于用户请求

* l9 P" g) ?; u' F2 BMVC的优点：

: V4 h7 }6 J4 ^6 |6 e. K7 j        低耦合性：视图层和业务层分离

高重用性和可适用性

/ @/ R% m8 r, `3 j$ }* X* M) ~较低的生命周期成本
5 L& b& r- D+ b% K4 \
快速的部署
7 o% \6 v% a5 o8 e1 e5 b/ Y
) X4 C: j) B5 |2 K' N可维护性
) R! C$ }; T4 Z3 i. {7 Y  z
# B: C  ]& Y( h% N! e有利于软件工程化管理
$ j( ]: i5 ?6 A8 {/ T1 r
提高软件的健壮性

MVC的缺点：
/ L4 t2 X5 c$ o7 j
        工作量大，增加工作的复杂性，MVC不适合小型甚至中等规模的应用程序

3 x0 `/ _) N# \! _% {
8 E) C  G. y& h/ T( |  K" I
% ?! _; Y' ^! f, m什么是Model 1结构，以及结构中各部分的功能
结构：jsp+javabean
' t% G% a+ B* C& |$ P* U9 l) Q
; w1 n/ `3 v9 y' iModel1中使用jsp来处理web应用中的视图控制部分

+ [" Z1 Z" o4 W# g) p" ZJavabean收集参数
( I6 H2 ~$ C( l* v7 F0 w' ]
5 U: l. R0 c7 W
/ c5 W' w5 T: E; J
什么是JavaBean?
用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。



9 V$ Y, ~9 y$ [3 K, rJavaBean的规则？
! A; b- d, l. L$ B$ c" l使用get和set方法定义属性

一个无参构造方法
" g1 i$ Z9 y3 m8 k1 z$ A
无public实例变量( 所有属性私有化)
9 i5 M3 K8 H0 ~3 [+ ]

/ E/ n' {+ A' H6 }
5 W( ?5 F) N# Q4 a% i什么是jsp标准动作？包含那些？分别都是什么功能？如何使用？
% j9 k8 E! w$ p1 c. |7 H& j+ SJSP页面中使用类似于XML的标记表示运行时的动作

# Z; @8 a  Q9 G) P) Wjsp:useBean
" n5 ?# I8 a( ^( D: v1 w4 u5 u
jsp:setProperty

jsp:getProperty
7 d3 k5 a2 z# t5 l3 m8 }
6 N5 N* G9 u& n% Q! E' zjsp:param

jsp:include
7 O. `* `! |0 |. M6 W
+ U# w, l5 @; K8 P& M$ Qjsp:forward



! A! r1 I  S9 {* C/ b6 j用代码示例如下标准动作的使用：useBean、getProperty、setProperty
<jsp:useBean

id=”myForms”

( y/ J% s: k) N5 T- F0 q% Gclass=”com.base.mystruts.forms.MyActionForm” scope=”session” />

    <jsp:setProperty name=”myForms” property=”name” />
% \/ D6 L2 t- V; ^
<jsp:getProperty name=”myForms” property=”id” />

  h: _4 P7 {' N6 {/ Z, J

描述说明Bean的四种scope
page

request

session

application

/ U, @4 V* _. x) r- m* ^1 D

描述说明页面上的字段和Bean中属性的对应规则
id 指javabean的变量名

7 n1 {" W; X3 O0 k! }class指javabean类的全路径
6 h! n# ~% }* ]( r4 U4 [
" F) X- D3 s8 @- {! h+ R+ Oscope指javabean的应用范围
6 A" E$ h. z; y/ @
name指所用到的javabean的变量名
/ [/ o0 a3 X1 v6 ?
* e6 Z. f2 }9 T% u, [, T" w    property指javabean中的属性

9 w$ W2 R7 H) G- k( R
& y! P9 s6 ?/ ?7 I7 O2 N
描述useBean动作的处理过程
使用id声明变量

  f( A1 @& b/ s$ U' K, G- o* M试图在指定的范围内查找对象
( d3 ?4 ^9 g& d9 m
如果没找到

& B: H5 E" j' Y+ ?7 u! m. _创建一个类的实例

" ~1 W  Q- d8 E7 s5 W执行useBean标记体初始化对象

6 y# ^2 a/ |* l3 X% g" v$ e如果找到
! P& P% L/ a' m7 \9 x1 C
     将对象转换为类指定的类型


9 j8 p1 @7 e0 i" d7 E/ K1 a
描述forward动作的功能
& j+ u- n7 H. e* P) ]6 ]) C使用脚本代码处理请求时，可用jsp:forward 动作产生一个不同的视图，
. F: ^9 S/ Z: R' z8 H/ y( \- K0 U4 A
使用同一个request：
0 R  i! ^: I7 {" B/ Y
" D. [" F+ J4 F5 u+ `) `* ?

什么是Model 2结构，以及结构中各部分的功能
8 c, a0 R2 I( ], kjsp+model+servlet
4 H9 H% L) b8 M. f, _
Model 2架构使用MVC模式，JSP页面充当视图，Servlet充当控制器

( {, C4 G& r1 m0 s1 [+ O9 p9 pServlet控制器：

# }0 }9 E4 b1 t$ I: a3 i验证HTML form数据
6 U1 v. c1 m1 a" t: D" C
# M  I; M( ^5 V+ c7 e0 |) `调用模型中的业务服务

# M4 M. W$ Q  l存储请求（或会话）范围内的域对象

  j6 D, p& |5 `9 y* r, P选择下一个用户的视图
4 B3 h/ C  t; w& ~- f" a! n
+ q1 A0 \  ~, R8 G) e3 s! h) MJSP页面视图：
4 J" g8 L$ C, a) S% n5 m
* B. F! U- d9 z! Y) p1 x* d5 x% C  ^使用用户界面（在HTML中）

; f& L# z. ~! L# E- X2 U& z3 F        访问域对象
. n" V  E4 k% a4 S
: i( V% T: ~, b7 b
& b  f4 F% ?* r% w3 t
如何获得分发器？分发器的功能？
& ]* d, ?+ ~, Q6 s6 ^上下文对象中的分发器：

- F3 l3 h0 h; r+ d# FServletContext context = this.getServletContext();

: R8 f/ ~$ c" f# O9 GRequestDispatcher servlet = context.getNamedDispatcher(“MyServlet”);
( _5 Z: X! D1 O) Q
- h, Z. }6 n# g  B( aservlet.forward(request, response);
) C) M( j  t5 y3 a% c8 y! p4 \: X
' r% R% P. S) d) C请求对象中的分发器：

: l9 y/ P: Q- P) M5 Y) jRequestDispatcher view = request.getRequestDispatcher(“tools/nails.jsp”);

: P( {* |* `, D7 `' [4 |* V6 D% D4 |5 c& Fview.forward(request, response);

! I1 A# V5 e$ O' B3 Y3 }' t可以将请求转发到另一个jsp页面，并保持请求的传递性

: Y6 w9 o4 d. A" w
  _$ L7 j8 o) o3 Y1 E( P8 o) u# N* v* `
Jsp中页面跳转的两种方式？
使用分发器跳转页面
, }/ Y' A1 `* V7 P4 d. J3 u( C2 kRequestDispatcher dispatcher = request.getRequestDispatcher(“url”);

dispatcher.forword(request);

( m+ _1 T  c3 Z# E! ]  f2 `% j5 I    特点：保持请求的传递（上一次请求中的数据，在下一个请求中仍然可以得到）；
" w3 _! h% C5 g
        转发的页面只能是同一个Web应用程序的其他Web组件

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

( @+ Z: E7 d: O6 J! f    特点：产生全新的请求，（上一次请求中的数据，在下一个请求中不能得到）；
$ A) }+ o/ U: E% W' ^$ S
        重新定向的页面可以是任意的URL



( T# w( N' s* q3 d' s' m; g) K描述Jsp中引入另外页面的两种方法，并比较两种方法的特点？
<%@ include file=””%> 在编译期间把另一个页面完全嵌入这个页面,可以说是一个页面
9 @* H8 n, N( E6 P0 d+ U2 G# G
# k$ y0 I/ q5 @& {" ^  F& E在这里可以共享变量

; _7 x5 }7 g% m- }& {! P; C, W<jsp:include page=””> 动态的再运行期间把另一个页面加入这个页面,可以说是两个

* j/ J: z3 A* C& o4 ]页面，不可以共享变量



什么是自定义标记
自定义标记库是一个Web组件，

包括：
9 {" r& X4 d  M9 }1 r
$ x2 J2 ?  u/ X* ^' a一个标记库描述符文件（*.tld）
/ K5 }3 f7 I% N) ?2 I& I' m
所有相关的标记处理器类(*.jar)

0 \0 Y; \: j( R/ i7 Q& z

/ x1 l; s! x: C% S% F% C% J9 F描述使用自定义标记的步骤，以及每步详细的工作
使用自定义标记前，要拿到.tld和.jar两类文件
5 `# E4 O# ?, p1 t
( A) S, U* a3 B; w  Z( [把.jar文件放到WEB-INF的lib里面。
! w8 w7 q( I' G把.tld文件放到WEB-INF根目录下。
在web.xml中配置。
7 P- z$ G8 Q. f  i2 B. p! z<taglib>
9 ?$ `# @4 `% w5 a, l$ e5 @
9 ^( U, B1 l1 Y2 ?( A4 R<taglib-uri>http://java.sun.com/jsp/jstl/core</taglib-uri>

     <taglib-location>/WEB-INF/c.tld</taglib-location>
2 q/ o7 v' b* B" F8 G$ R( o0 ?
</taglib>

在页面中引用。
<%@ taglib uri=“http://java.sun.com/jsp/jstl/core” prefix=“s”%>
  U  d0 e4 S2 E4 e
uri必须与web.xml中的uri对应

prefix是前缀，用来区分是哪一个taglib
1 ^* o% p' g' x5 H. r
$ y! K9 b* F5 h" k! \6 C% e2 @6 Q使用标记
' L- \* y6 y8 t  ]0 p; _7 A格式：<prefix:tag名称 属性>

<s:forEach >

admin

在tomcat下配置数据源
' H9 u& n6 p) W( ^* y$ t- l, f1、服务器与数据库的连接
4 i8 f: g; s3 }
" I! G) u+ O6 t4 j配置server.xml文件
5 S* h' R7 F$ S1 y7 _* N+ F$ y/ r
1.oracle
9 b5 Y* V* A# |' {8 v
+ S0 X* c* F( ^; E3 i; E<Resource name=”jdbc/company” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”

; e! R) P2 I2 J" |$ _! L                        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”

url=”jdbcracle:thin127.0.0.1:1521rcl”
7 X5 i' [' R/ y7 {' f2 \( w
* D  {9 P& Z, ]5 |) ]) `* ?+ f1 jdriverClassName=”oracle.jdbc.driver.OracleDriver”
+ z& Q4 K1 a: p8 }$ `
' }0 U( Y' N! Dusername=”aa”
9 a5 K" Q  z5 J  h2 m
password=”aa”
* `/ ?# ^6 U7 J& E1 H& C
maxActive=”50″
8 b9 `* O& G% s% L
maxIdle=”10″
+ ]" m- t/ v9 e+ M, E  e
maxWait=”-1″

! {* P" G% l( h! H/>

4 |! ]  A3 N  F3 a0 B1 L+ W2.sqlserver

<Resource name=”jdbc/webpage” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”
1 v; |. i  k' C# s- h' W
        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”

url=”jdbc:jtds:sqlserver://localhost:1433;SelectMethod=cursor;
3 v7 K) z# P% [
DatabaseName=webpagetest”
2 C* y9 ^$ D( {0 K6 R- |  L. V
, Q* V; i1 A8 e, Q5 SdriverClassName=”net.sourceforge.jtds.jdbc.Driver”

username=”aa”
+ O- n' u2 t8 R; g0 t( v8 u
& f. m0 g! z$ S2 M- G( x$ cpassword=”aa”
( o. X& k$ b. r& S4 _
maxActive=”50″
1 Q9 f9 E3 I, H, f$ ]8 k6 a
; J9 Q) j- U7 i) X2 r: C$ Z0 fmaxIdle=”10″
. L6 ~! T+ p- X0 c9 F
8 _* J5 q/ H) I6 ~! ~7 GmaxWait=”-1″
* q7 {! r4 r% y- _" L: P) J% t
/>

. H$ k5 Q4 @( i: A) g2、配置自己的web应用的xml文件
3 g" Y6 D" e$ U$ l8 k" c4 f) {
$ x7 K& l2 Z1 J$ A
  v, L$ i3 E) a/ m9 F
<Context path=”/eb03web” docBase=”F:/workweb/eb03web”
6 r0 `+ t+ A8 h- P
privileged=”true” antiResourceLocking=”false” antiJARLocking=”false”>
: p5 o+ V) v& N6 h6 |
<ResourceLink global=”jdbc/company” name=”jdbc/company” type=”javax.sql.DataSource”/>
/ L: w% t  m+ Q: M- f
</Context>
1 i1 {# U5 M3 ?7 z# D3 }8 c( y$ E) R
  w9 k) q- `% G2 Z9 G2 f

1 U5 I* {6 }, L( j1 Z5 w/ w, s, k+ x3、配置web.xml文件
# N# i9 h  C! p8 [+ o. Y9 o
" ?8 J1 U( `* b2 H4 n) P% A. T与服务器建立连接

/ s0 F0 J8 A. L$ P0 I<resource-ref>

<res-ref-name>jdbc/company</res-ref-name>

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

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

</resource-ref>

4、在应用程序中不直接与数据库连接，通过DataSource连接池建立连接
, j! t1 b8 s( D2 ?* L
//1.在程序单独用时设置系统的属性，在tomcat下可以不用配置，
8 B) o$ f: k9 i
System.setProperty(Context.PROVIDER_URL,””);

6 ~* g' p" y* p: o9 NSystem.setProperty(Context.INITIAL_CONTEXT_FACTORY,””);
. L- K- E2 p; X1 s. A1 R
8 n! X$ U0 D8 _3 R# e- M7 ~//2.创建一个上下文对象

8 n& F. I3 w+ V& M% i; ZInitialContext context = new InitialContext();
+ g. J) z$ o: M& Q" u* V: g3 e
2 k4 h; Q% W# h  C6 }' v8 F//3.通过上下文对象在连接池中查找DataSource
" ^* D) o$ V" i* v$ m
2 p& \: T6 b. A) ^2 wDataSource ds = (DataSource)context.lookUp(“java:comp/env/jdbc/company”);

& x. S7 L9 X) d4 H1 S//4.通过数据源建立连接

ds.getConnection();

admin

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

一、映射的特点
' _: z5 z* i+ k8 g  @4 [& X
0 g# e5 l2 Q9 G. E: S2 w3 o1.一个对象可以对应多个表
1 ^0 \$ k+ i9 c9 c  q1 h; T. P! M
2.一个表可以对应多个对象

3.对象和表的关系不用完全对应
- c" z+ _* l9 u; A( y
, M" y5 k( T# h" y4.对象的属性的名称和表字段的名称可以不同
/ E3 r( o4 ~2 Y! D) D" Q
5.类型可以不同，但数据类型之间可以转换
! D5 u; L8 p# ]$ C
+ }5 i' {1 M: ]6 E) Y% C6.对象中必须有主键，数据库的表对主键无所谓
0 P' }- ?& h  L: e
* J/ M$ P( Z  k' s; c( b& R7.数据库中有主外键关系时，对象中可以有，也可以没有

$ u; `" x5 l/ F

: B- G8 A8 d8 `8 `二 、有一个映射的描述文件————>xml

/ k3 Y+ u% h& ~' I' O! \" w三 、怎样实现描述文件————>一段程序
: b# r+ N  c" S0 ?
对象 映射（mapping） 数据库
# q' F# i. h8 I3 u1 c! `& {
user
8 j9 _; n, e6 m, |( f- U3 H
id=11
+ a7 T+ [; h; o  u, N- N# r
  c- Y2 I9 G4 U8 jname=”张三”———— > (1) —————> tbl_user(id,name,age,tel,address)
& d1 v* i& R2 o( G
: o0 e. _; O  ]1 Q0 Lage=25 <————(2) <————

5 b: o: Q7 c# ^  T+ @) Y" Q7 n% _
2 b6 q* f+ ?+ G5 v
(1)从对象映射到数据库

$ H% }  `( a8 y; {% n' t1.JDBC
9 x- f6 C! m8 j! B
2.根据描述文件来动态拼接sql
* B* E: W, ~' u; V( N- t8 N
3.执行，添加到数据库中



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

1.JDBC
7 P  Q1 ?" w+ U0 _
2.拼接查询sql
+ p; X7 L# ?8 ]# S6 T; m- l5 K5 o
3.ResultSet
7 ^9 z# A. A3 d& `
4.Model


4 u" F- p7 G0 w! |5 H
hibernate
1 g4 Z! R0 g1 L开发流程：

是什么？
1 I3 L# n( `$ E; Nhibernate是一种基于orm 的轻量级的框架
4 q4 F& p' @/ _7 H' G5 z- s
, p- @% k  J' e: _- e5 {3 S4 I

有什么？
1. session 保持连接状态（依赖事务和连接池）
6 \+ w" }; E. |/ Q; n, w  u
2. Transaction事务
1 o* [: |  c* b0 t
0 I  B) \4 N; c+ |3 k8 _3.
Connection Provider 连接池
2 M9 Y3 F9 H6 u7 z$ ~1 {% a0 W: s& V
- i, S1 u. ?2 Y
! h6 {6 K! F5 n1 X2 m' R, W
, i; }* H  Q* Q/ G能干什么？
1.orm

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

3 o9 M  z" H/ f/ s! R. g

/ ^; f: K6 U- {" ?3 b4 e怎么做？
1.搭建hibernate的运行环境，将hibernate的包和hibernate所需要的包拷贝到lib 文件夹下

2.O（vo）
, n5 o4 @  I4 k$ u: p2 d2 p  h1 E
2 |- ^2 I1 U  f5 P8 {4 E! h5 n4 |3.R （关系型数据库中的表）

4.配置文件

4.1 cfg.xml 放在classes根目录下，默认名字为hibernate.cfg.xml
$ |8 ^  z( }2 d$ _
8 q+ G- B* U; D' Y/ b% n$ Ga.与数据库的连接
/ U, x2 t; @# Z$ [: l+ ?& x
  ]0 ^4 a6 j& V4 db.可选配置

c.映射资源的注册
, r# A5 E. K( H" O" V
: d' f6 k* k2 u' e% W4.2 hbm.xml文件 名字与类名相同 并且与类放在一起

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

b. 对象的属性与数据库表的字段之间的映射

c.组件之间的映射
$ O4 |$ \% s& [! G' a6 y) m% C' f# n- o0 `
d.对象与对象之间的关系映射
6 S0 B+ {% r: F* l, B0 C
" M. H( `2 O+ L* u9 O$ T' I2 i5、客户端

1.得到SessionFactory
2 k- s) ^1 T5 \+ f1 G% U9 Q
6 U$ _6 M# O, [4 S: {2.通过SessionFactory 工厂来创建Session实例
. j. j; W7 p5 F, X) H
! I/ i4 ?, Y! i3.打开事务
3 z* X# Y# [$ Y/ @8 M
4.操作数据库

5.事务提交
& h/ K0 s' v2 r
6.关闭连接
# z5 G. _3 y9 D
2 [, V" V0 w7 z( P/ i2 M运行流程：

  t1 A# t1 r  f# R. s* |整体流程
* N# ?* g9 r; l0 G1.通过configuration来读cfg.xml文件

7 u# w( B* E6 ~' V2 P9 J& f$ t. E2.得到SessionFactory 工厂（根据数据库的连接来创建sessionfactory）

# g  h; A# q+ }  H4 {1 p6 V3.通过SessionFactory 工厂来创建Session实例
& o- T2 x8 x0 d* {( n
4.打开事务
6 x  C, p& V1 p, I
5.通过session的api操作数据库

6.事务提交
) z1 a5 l" R# g
7.关闭连接

2 L* U) k) H+ }
6 @1 x5 N5 |9 ]9 M
$ N. ~& b; y: s8 O- P. X' s1 ksave
% m& D1 ]. n0 g2 f1.to—>po
' Q' @7 T1 {% h! T
# J  y' t. C- v8 ~& |2.根据model和cfg.xml中映射文件的注册来找到hbm.xml文件
: p6 }) b9 Q' L
3.根据hbm.xml文件和model来动态的拼sql
1 k1 ~. V4 q0 s  u0 M# G# T
4.客户端提交或者刷新内存
+ Y2 z. X7 b6 ]2 [2 Z
5.执行sql，值放到数据库
4 ^% \2 a5 e# F  D- t

& H! S; B, C7 C) \
6 s1 T, u( p9 C" Rupdate、delete
3 g" A  k$ K( G3 ]( C1.根据model 的id在内存hibernate的缓存中查找该对象
( \# c- j% c. `3 Z6 x) B5 y
如果内存中没有就到数据库中查找来保证对象的存在

( ?1 H" D  n* F, R' p2.根据model和cfg.xml文件中映射文件的注册来找到hbm.xml文件

3 n& u% w0 @, c8 a# Q$ A0 E3.根据model和hbm.xml 文件来动态拼sql

5 |9 @+ i& I2 [- J, Z4.客户端提交或者刷新内存
2 R* O; S' X. j& V
* c2 z, g% _, W' c) v9 e5.执行sql



Query
load
* L" X+ m. a0 x2 r+ ~
  F6 d0 C: h& d  F' o* d1.根据model的类型来找到hbm.xml文件

3 I/ A2 ]9 v" a* s5 N5 _6 x' L2.判断id对应的对象在缓存中是否存在，如果存在，就直接使用，如果不存在就进行下一步。
( ~; e: K$ c' G( R
, E9 ^7 N/ S5 f& d- t( p3.用id做为查询条件来动态拼sql

4.执行sql 查询（先在内存中查找，如果没有找到（会抛出例外），就去数据库中查找）
9 G3 w  g. Y& M
, K$ {/ T( n) y8 r, i: S5.返回一个model类型的对象

- g; K& t# N- b. N: Pget

    1.根据model的类型来找到hbm.xml文件
4 u# P( g( C" X2 U
% K0 V/ |8 y) M% Y7 {2.用id做为查询条件来动态拼sql
% O9 p) @( S" r
, C, E4 c& j; K. ^5 }4 k/ \! z3.执行sql 直接在数据库中查找，如果没有查到就会返回null

2 j8 B8 d. \0 c. `8 q: N: t/ @query
4 u5 n' H5 H$ `" S1 [9 o( |- K
+ _/ q- f9 M( J+ V) Y; I4 i( e1.分析hql语句，得到model的类型
- {' x' I3 s) t  G
. i& M5 z( t5 l1 x1 i( B/ C: z2.根据moedel和cfg.xml文件中映射文件的注册找到hbm.xml文件
9 D* y+ b% Y1 W3 u
3.根据model和hbm.xml文件来动态拼sql

$ [/ A7 L7 r( P4.执行sql查询数据库

" n) [' X' B( B0 K& a/ ~6 o5.返回一个resultset
4 r0 E6 H$ \7 y% m
+ m/ n5 T: m. C: a6.循环resultset的值，放到model中在放到集合（List）中

# Z1 M) P4 t; G! O$ v2 T- D
) F: j4 Q& G; z! z$ K( y( \
; B. _! o* v: p! |' |3 F/ r谈谈hibernate缓存机制

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



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

% V- L- D7 e+ E) Y
0 g! F9 X% h- \& a
对一级缓存中的session事务进行数据的预存取，数据在各个session的上下文中存在（单例），当session关闭时，就是session.close( )，整个所有session范围内的数据全部清空；二级缓存默认的情况下是不开启的，如果开启，数据库汇总的所有数据都先copy到二级缓存中，这里要注意的是，一级缓存是每个线程下创建的session缓存区域，可以是多个，二级缓存只有一个区域 ，画个图比较容易理解。
( e9 z" D: A( c% t$ e2 w
& E4 S* c) O% z+ ~0 C& z; B6 s) X
. k4 n9 Y' j0 @: w/ h9 _
| 一级session缓存| | 一级session缓存| |一级session缓存| |一级session缓存|

| | | |
) L, ^5 v1 E& L7 S1 {
| | | |
$ O$ H+ N! x- B* n. |2 A
. E% D2 ~$ {# c6 \—————————————————————————————————
& v+ X! u. a9 c0 @& U2 l8 T
6 t$ }* l, j3 K8 g1 ?sessionFactroy级别的二级缓存

# e- W2 \. C) r——————————————————————————————————————-
: n/ J" t2 m% W/ M5 Y* C
|
; [  C) u: j/ R& t) F
' v$ V  A$ [" {, j7 [$ ^6 Y2 M|

|

* W" L1 ]& S9 N, |5 J) U6 t2 f——————————————————————————————————————

# t1 v9 b8 N4 M5 CDB

# R! g$ \7 X* R/ f5 P0 u9 P$ F—————————————————————————————————————–

8 ~' X% a4 ?; x1 ?  {& C$ C

admin

Spring
* A3 @1 X! m/ |* g& l( Y

• 是什么？
  
  6 \+ q! k" ~$ z: K6 y  ?' r( j( m

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

• 有什么？
  " o. r7 N& `0 i, l- I  J
  

2 z% m- z. k+ m& d3 r

每个包的功能：

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

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

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

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

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

AOP ：面向切面编成

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

7 L& {, `. ?  A( E5 H

• 能干什么？
  ' E) M; y2 E' \9 _3 K$ [
  7 H$ K; i4 k( |& A+ ]% t3 M5 N" \

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

# }7 T7 u/ N' I9 x; q& R, }

• 怎么用？
  
  
  • 搭建web工程，引入spring的jar包
    
  • 在web.xml中添加如下配置
    % ?% r. N! [0 K: Z/ s! w! G
    
  
  6 B* e2 a: V& }4 k* j- Y
  7 @4 b, U) b# X, W4 O

            contextConfigLocation

            classpath*:applicationContext*.xml

   
* N. e2 s$ v2 `5 c

        

            struts2
" W& }9 T; N9 T% b2 ^% J

            
2 y+ D7 G( U4 O/ [: h- C

                org.apache.struts2.dispatcher.FilterDispatcher
" e$ I! E2 c/ H% ]( m& R

            

        

        

            struts2

            /*
9 B: c, Y- \( w- T9 T% \

$ ]. B+ O  ^% V

/ M* e4 `  b# [& J& X3 Y* m. h

            

                org.springframework.web.context.ContextLoaderListener

            
" O. u" {6 r' o6 e1 F; \1 g

        

• 部署
  1 X6 T5 O" s0 q9 o! X3 Q: W, R$ C
  

• 容器和bean
  4 b$ Y( Y5 e; ^

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

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

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

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

; X2 L' \3 F3 S" f# |4 \

• IOC控制反转
  
  ! M' Q/ c& o# h9 Q9 W6 v
  
  + o  l/ _& k) h- W/ X: U0 K1 J
  
  从前的应用程序想要得到A的实例他会直接主动的去拿，当用了sping后，应用程序由主动的去取变成被动的等待，由spring来控制应用程序所需要的对象
  
  8 \' X# ^  R2 U: P
  • IOC的优点
    . T* j1 O2 t$ R# R1 k# `
  1.可以通过IOC来获得实例
  2.可以通过DI来获取注入的资源
  • 配置IOC的原则
    
    • 一定是可变的资源才采用依赖注入
    • 一定是层间的接口或者是模块之间的相互调用才采用依赖注入
      0 |7 S% M- D: V4 W

• DI依赖注入
  % p+ k# p5 L9 c0 R4 E

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

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

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

例如：

在配置文件中

" h$ t3 v: {9 o" H, @% ]5 C

1 t+ A( Y" K5 [! Z* c9 ^! q' }4 N

在应用程序中

Public DBDAO dao ;

Public void setDao(DBDAO dao){

This.dao = dao;

}

3．构造器注入

" U  t' i! @$ y+ p8 T# L* _. G/ z$ E

4．ref 表示参照其它的bean

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

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

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

6.lookup注入

7.singleton

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

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

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

8.DI的优点：

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

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

• Aop面向切面编程
  
  

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

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

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

3.AOP 的概念

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

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

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

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

5.引入 ：扩展的功能

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

7.aop代理 ：实现机制

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

4.AOP的事件机制
  T6 X7 o) p& t. r  ]

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

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

3.找到切入点

4.确定连接点

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

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

$ W+ \) w7 O. X4 U, K


8 _* I7 U* y) A& x. m* ~" h, {

2 j) ]2 A) x/ _
0 P$ Q8 A4 v- E$ D+ q1 F. p! t$ w9 x

5. AspectJ
- J5 x! b+ y% p' X' d8 u: s/ `1 c/ [. E

5.1.在xml中配置比较烦琐

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

         
8 ^% I& P: q7 P' H% q( M! \
2 q% w; @1 ~7 @, T  q0 T# j9 I
; t' J" q0 x5 G, }7 U" A         
  a: ]+ }) d$ t9 i7 d

        

        

# g$ f* L( s$ w/ d1 s8 ]$ Yexpression=“execution(* com.javakc.aop.MyTarget.t*())”/>

        

        
" y' x# @" h. w

   

5.3.使用注解的方法相对简单
" `2 f* e1 ~4 L9 F

@AspectJ的基本语法
. f4 ?5 q# w$ I

1.@Aspect声明一个切面，将一系列的共同的功能定义成一个切面
8 t; o3 e) J- p4 y/ {

直接在类上定义@Aspect
3 H/ J' a6 g( p8 h1 c2 ^

2.@Pointcut声明切入点
' n, E8 {$ N/ k( s0 O) Y. @2 N( T

2.1、用一个专门的类来定义pointcut，类中的方法名就是该pointcut的名字
" @) o- b. K8 u; W; z& j% U

2.2、可以使用匿名的pointcut

2.3、执行切点的几种方法
3 [' g/ J, w. _2 d8 |* V+ L

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

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

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

2.3.3 this 指定到实现接口的所有的实现类
: P' w& r: j9 Y- ?# j

2.3.4 target 指定具体的实现类

5.4.advice的五种类型的示例
, t6 E' B& H$ D& i7 ]# S

　　　 客户端必须从接口走才能得到监控，实现想要追加的功能
6 N( _, Q% F+ ~" E

5.4.1.@AfterReturning(pointcut=”” returning=”retVal”)
9 K+ N7 r, E; W/ W4 j

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

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

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

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

完成追加的功能

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

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

(2).

     2.直接引用匿名的pointcut
. N+ O" V! S) F$ F* U, p

     (1).@AfterReturning(“execution(
) D/ j1 U7 Q5 }- w" g7 L1 U

* com.javakc.spring.schemaaop.Api.test4())”)
  C. h% }* H) S( H4 P" y

     (2).@AfterReturning(pointcut=

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

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

@AfterReturning (pointcut=”com.javakc.spring.schemaaop.TestPointcut.t4() && args(str)”,returning=”retVal”)

public void testAfterReturning(String str,Object retVal){
& H- v# v# |% @7 F# q  o

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

    }
9 K5 }$ v% n/ s1 U0 L; Q

5.4.2.@Aronud

     注解@Around环绕追加功能；

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

     必须有参数；第一个参数的类型必须为ProceedingJoinPoint；
6 \5 [4 z$ k' I  i

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

目标对象的方法

     1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
; x; w: G/ J0 ]# ]

     (1).@Around(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
0 z1 l" B) g4 t. Z& u4 W

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

&& args(str)”)

2.直接引用匿名的pointcut

     (1).@Around(“execution(
5 u" K2 P6 Z3 O5 d6 ^  r

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

     (2).@Around(“execution(

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

// @Around(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
* {7 s( O- _8 j/ {1 s. e2 e# s  a5 a

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

public void testAround(ProceedingJoinPoint prj,String str) throws Throwable{
6 F1 U; v8 z  K1 O$ o

    System.out.println(“around1==========before1pointcut==>”+str)
$ m3 C6 }7 q: N5 |/ ~% N, S

        Object obj = prj.proceed();

        System.out.println(“around1==========after1pointcut==>”+str);
/ y( K$ x, s0 i: _9 K0 O& U! U

    }
- |6 Y3 C4 D" X

5.4.3.@Before

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

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

(1).@Before(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
. }: I! v. ~! X' ]

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

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

2.直接引用匿名的pointcut
  j5 F- N  B* |5 m  P

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

(2).@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
/ c6 f0 x4 {+ A3 U# J8 u+ b

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

// @Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
$ P9 `0 C9 J) h

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

public void testBeforeParam(String str){
' p3 J1 A) I. ?6 a/ K3 f

    System.out.println(“before1=param=>”+str);
+ ], F% v, L) m; U" M% u

}

5.4.4.@After

注解@After在执行目标对象的方法后追加相应的功能
* \9 n3 v# _) u+ }, G) m  l! ^

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
# B& b; Q! M  `3 @) K/ o1 R$ T

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

     2.直接引用匿名的pointcut
* _9 ?9 w8 b6 X0 |9 X$ Z

     (1).@After(“execution(* com.javakc.spring.schemaaop.Api.test1())”)
1 I) ~& W6 |% W( u0 s+ Y

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

    public void testAfter(){

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

    }

5.4.5.@AfterThorwing
# b9 i* W; X! R2 T/ S- H; C

• 描述一下spring中BeanFactory和ApplicationContext的差别
  
  6 R: ^1 a  \! s$ w9 p7 I

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

0 U$ c4 v6 @" N) r7 Q

• 谈谈spring对DAO的支持
  
  

Spring提供的DAO(数据访问对象)支持主要的目的是便于以标准的方式使用不同的数据访问技术。
+ i4 N! f! }6 r$ p" U4 {

简化 DAO 组件的开发。
! b4 @8 O0 D* x4 T- |9 T" d5 iSpring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法，用来简化代码开发。
4 t7 W  h. x3 X+ P

IoC 容器的使用，提供了 DAO 组件与业务逻辑组件之间的解耦。所有的 DAO 组件，都由容器负责注入到业务逻辑组件中，其业务组件无须关心 DAO 组件的实现。
" e& v. d$ H: n1 \  {0 y$ k5 {

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

方便的事务管理: Spring的声明式事务管理力度是方法级。
8 ^( m$ X# w4 U2 m! W/ l

异常包装:Spring能够包装Hibernate异常，把它们从CheckedException变为RuntimeException; 开发者可选择在恰当的层处理数据中不可恢复的异常，从而避免烦琐的 catch/throw 及异常声明。
9 e8 K! I0 C  d1 E# }- z% m

6 h- T0 b0 o8 `3 ~4 q' J' D

• 谈谈spring对hibernate的支持
  
  

在所有的 ORM 框架中， Sping 对 Hibernate 的支持最好。如 SessionFactory 的注入、HibernateTemplate 的简化操作及 DAO 支持等。另外， Spring 还提供了统一的异常体系及声明式事务管理等。
# D2 m+ T( `5 T  {; h3 V

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

1、通用的资源管理: Spring 的 ApplicationContext 能管理 SessionFactory，使得配置值很容易被管理和修改，无须使用Hibernate 的配置文件。详细配置如下：
! \( \' C8 E, {' w5 q! d; t1 s

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

        

            oracle.jdbc.driver.OracleDriver

        
6 {3 _6 P3 a  _; H/ m* \8 k" ]$ N

        

            jdbcracle:thinlocalhost:1521rcl
. O$ k3 H+ G; m' v) }  J% O

        
9 f0 U& u7 I+ q% l  a  W

        
7 M6 V$ E* Y. D) h

            javakc2

        
+ b+ e5 ?) ^0 Z& Q1 U

        
- h" _, h. j0 j% u; T( Q2 l6 O! G

            javakc2
7 `4 U8 ~0 H+ u  V7 H" ]

        

   

   

        class=“org.springframework.orm.hibernate3.LocalSessionFactoryBean”>
7 k) n; `4 z" {: R% N. k% h/ e

        

        

            

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

            
1 U* h( ^2 V. V! H) M1 M8 Y

        

        
" r3 }  ]; d' ]( [

            
$ }+ F) W% R) K0 z: e: e/ ~; K+ l

                hibernate.dialect=org.hibernate.dialect.OracleDialect
6 m. g" b( ?  Q! C; z

            
2 C# J7 m2 ?, B5 o9 S5 ~

        

   
8 L% ^8 Z  R/ E( s7 t/ t

   
0 W# ~7 u1 _9 a/ ^

        

   

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

   

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

        

            java:comp/env/jdbc/myds
' r. p3 u0 f$ b9 |: I$ h8 x

        

   

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

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

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

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

   
( ~/ ^2 Y( B+ o7 F

        

   
, C' r* |/ d  E/ p

   
" p. F$ D  r  Y8 ^. r

        
8 p1 y  F' [3 y1 c) d7 a9 F

            
9 h" p; r9 G0 ~+ Y# l

        

   
1 E% F. W/ e# g/ ~# q4 I; v

8 [2 H- r4 w9 N9 L) H

   

        

        
) `/ l9 Y% l* B! O# G7 N; s5 I

   

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

Spring2.0之前事务的写法 ; ]9 q2 |' T- Q1 C- V* S" m* _         class=”org.springframework.transaction.interceptor.TransactionProxyFactoryBean”   b( [) N% y$ w* n0 Q8 k8 Z        abstract=”true”> * l! G; U3 I: K4 u 9 p; u. E1 Z4 @                PROPAGATION_REQUIRED,readOnly 4 G" j/ s, N  x% }& i                 PROPAGATION_REQUIRED " A, L' Z4 e3 f) o+ k4 j4 B$ h 1 }' @8 K9 v9 d " X+ F! w$ m* e0 h! B

9 R7 K9 J9 E$ j3 c

• 谈谈Spring对事务的支持
  ( b  ?0 I; @* y! H2 F; }+ }
  7 O9 Z# I1 J+ x, Q* i% M

1、声明式事务管理：

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

2.做法：

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

2.2

2.3 注入数据源

4 o  l( T6 V' e$ O) Q
" Z. H1 @. ^& u6 m8 _

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

( A! u- _# s) h- r% U/ `

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

: l- f5 ?& }  K1 m% D

  U, u1 c- p) Q+ G

; o+ ~, n8 Y0 L" U4 C2 V

2.6 定义切入点

6 L% v! h# i/ ]0 c: Q


& }3 @' O3 ~5 Y

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

1.注解@Transcational

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

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

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

6 }& D* n9 M! E* r

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

; A4 D: T' k. L

如何在Spring中使用JTA的事务：
! u  B( Y1 Y  I$ J

1 i0 ?( X" R; j  t8 k5 p. u" Q

admin

事务
ACID
（1）原子性（A）：一系列的操作具有不可分割性，要么成功，要么失败
' w' F) x0 K" k* U8 ]
（2）一致性 ：操作的前后满足同样的规则，保持平衡。
. n. y/ ?4 B0 b3 ^5 n% O* x1 K
（3）隔离性 ：在事务运行的过程中。事务内的数据对外的可见性和可操作性（必需由数据库的支持）

6 i0 S  r6 k% Q: C3 ?+ ~% h/ v; v8 h7 H（4）稳定性 ：保证数据在事务的操作的过程中不会遭到破坏，而且是永久性存储的

2 S! a# {0 \" ]3 j* e  G: Y5 ]
* U0 T: V0 b5 j8 N3 k; U1 L6 q& `( r
事务模型
（1）经典事务模型又叫平面事务模型（JDBC） 事务不允许嵌套
2 M, o# p* m2 u& U$ i5 z8 r
* V6 }( S  t: v+ d8 M4 x! B（2）嵌套事务模型
. o' S# |( m! h! L2 J$ O
1 N0 T. H8 H: z

事务的两种方式
* S2 K# [+ M/ H6 t; n7 r- d（1）声明式

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

（１）.required
" l6 V* p+ ]: }! x0 r$ \
3 s) g, I' C/ z* x- K" z# g$ ?+ V如果客户端没有事务　在bean中新起一个事务
" M% |, S( O+ ~6 i
如果客户端有事务bean 中就加进去
" ?& q# o# ^0 d
& v$ ?0 m- ~  i' n! E. F" s(2)、 requiresNew

/ D8 y7 G0 p  a. F; G0 H不管客户端有没有事务服务器段都新起一个事务
0 K! [! M. T9 T& l/ }; L
如果客户端有事务就将事务挂起

(3)、supports

如果客户端没有事务服务端也没有事务
1 P+ P& l( A1 B9 X4 P  b. [) r# k
7 f  L. j5 `# ]! V4 D如果客户端有事务服务端就加一个事务

(4)、mandatcry
+ Q7 V+ O( D( t
如果客户端没有事务服务端就会报错

如果客户端有事务服务端就加事务
# h$ \, o6 s' x1 M# @! T1 R
(5)、notSupported
$ b! I& m0 o0 O
- U. H- g" a9 t# ]: l& V6 C不管客户端有没有事务服务端都没有事务

# Z( R$ j& t, ?2 G' l2 d如果客户端有事务服务端就挂起
# y2 ?( n7 O3 O  p, q& p
- J- W# z$ X& ^5 i9 p9 E, t(6)、never
7 I6 ]6 ]/ m: ]5 C
, r- G) V7 _5 ~$ Z  A% O不管客户端有没有事务服务端都没有事务
( M, E8 Z  V* k8 ]& J& o
如果客户端有事务就报错

（2）编程式事务
3 S  Q! n# @1 @9 a
Javax.transaction.UserTranscation
8 r. T) k0 t) D" B* T$ [, f# {3 x
JTA 事务可以精确到事务的开始和结束


0 [7 L& T' U1 g5 I' y- a- a. R
/ ^9 Z1 Q4 q% o事务的隔离性
Read-uncommited
: o; U! {% e/ U
" G. G! r4 d, E+ W+ r+ x读取未提交的数据（基本上没有锁）脏读，存在不当读取的问题。
' a7 I; K, ?( T+ o6 V
% W9 K  v  X' x& J% L: ]8 yRead-commited

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

8 D# d' y# R; b& ^无法读取已经写入，但没有被提交的数据。
! P/ G: p/ u: E5 c# Z$ _
Repeatable_read

读取的数据不允许修改或删除

9 i1 F1 v3 j( _3 H3 s# c3 c1 Q不可重复读（行级锁+不允许修改/删除）
) |1 W  i% T4 `) a
Serializable
0 d& |' C- G- K' R' U
0 r$ m. C  N7 y' E1 f幻影读（表级锁）
! w6 q# d8 N2 @0 W/ ?


" v! @- {; o  `struts
2 K( r' V  h2 B/ h开发流程

1、创建表单

5 j$ C5 y, T- W+ A2、从表单中获得输入
+ K+ B$ }% C2 ~* N4 n# k
3、处理输入（业务逻辑）

$ h. T6 J8 V5 j- m0 Q4 W( b4、根据动态输入改变输入流
3 q3 z- r8 A; `, T' z5 J8 i- g
7 d" o" S. |- Z8 |  V- W- r; p; S要完成上述四步，我们需要创建

1、一个ActionForm

" k! e  O0 |5 R1 s9 V3 L* l9 K2、一个action

3、一个配置文件struts-config.xml

4、创建页面
# n& s' F2 q; g# t" c5 s: n
! m- ~  R% ^6 @2 C创建ActionForm

1、写一个类继承ActionForm

2、私有的属性

3、相应的get、set方法

& Y- p9 t/ `2 n0 r: @4、重写tostring、equals、hashcode三个方法

3 ~( m+ t4 e- f, b8 O创建action

! d0 Z( F# h% N( j- u4 o& u1、写一个类继承Action
9 G+ `% y0 M6 Y1 I+ o9 e
2、实现一个公有的方法（回调方法）
2 @( K5 ^2 u" M- j( I- l5 u. \
8 z$ a& o3 L6 opublic ActionForward execute(ActionMapping mapping,

9 r! t- J3 I4 \0 }! g) KActionForm form,

HttpServletRequest request,
0 Q2 }, F. ]4 m) x: E% r' r
4 \+ J/ T" }( v0 m" ?3 ]HttpServletResponse response)
7 R" k; c: P3 B, ?2 ^
. F. [& ]( S, S2 X/ H* i6 v# E{

//1.收集参数

MyActionForm myForm = (MyActionForm)form;
7 h- E4 P; j4 O4 E6 \" A/ \. a
9 V* h$ F4 ]0 C" P+ j/ t! Z7 G% `//2.组织参数



! B% S& r1 I% b" r5 D, d! W; ]//3.调用逻辑层

) w/ c( I0 f- y, {2 s+ r1 Eboolean flag = true;

//4.根据返回值来跳转到相应的页面
. f8 V; W8 O' D  q/ v7 w% T4 B/ a
ActionForward af = new ActionForward();

; w# S- k/ x" G6 tif(flag){
! }- o( Z* a: `6 G
af = mapping.findForward(“1″);

" @: f2 W7 P! @* |! L}else{

af = mapping.findForward(“2″);

}
$ |, u7 |8 J1 S  e) r# J* h* _
, K  ~. H& K9 F/ \% C4 Vreturn af;

( |* i" n/ \! C: a$ a}
' J& n6 S- r- k- b7 W
8 \9 x" B0 {+ I8 _& h- i' o# d配置struts-config.xml文件
. |- N! ^) n3 L2 r/ }7 A7 V3 u
1.<form-beans>

<form-bean name=”myActionForm” type=”全路径.MyActionForm”/>
0 D% s+ ~0 f' t
! c6 h' r; \; v3 q: h<form-bean />
# t3 Y3 c- G3 b
! E$ Q; Z) h  t0 m1 @, l0 j& m</form-beans>

2.<action-mappings>

<action path=”/sll”

3 k7 l1 \; M/ G; K: Qname=”myActionForm”

type=”全路径.MyAction”

+ K0 P& |) O3 V" ]: T. N$ p) r  Wscope=”session”
( p; ]" ?, n$ K& ]4 v/ }
input=”错误返回的页面”>

* F* M/ s- Q3 n8 s7 k( g<forward name=”1″ path=”/1.jsp”>
) P. p, u, x: [3 f
<forward name=”2″ path=”/2.jsp”>

</action>

, X3 J9 g7 [& P  q! ]" h, u) c' _</action-mappings>

, {# f  |4 ]. I+ `% m1 ?步骤:

$ Z8 o8 m: P6 Y  ^8 l) A0 Y( e1.创建一个空的web应用

& D! b6 c( f' P; W: w3 m2.将struts的包放到lib文件夹下

3.将.tld文件文件和struts-config.xml、web.xml放到WEB-INF的跟目录下
6 i! ?4 r8 G' V; I  M+ _- j
4.配置struts-config.xml文件和web.xml文件

5.在页面引入tag文件uri

- H3 \8 P# K; O+ j8 C7 pSTRUTS运行机制

1、界面点击产生请求

4 C! k6 Q. \! d- I- G2、容器接到请求

3、匹配web.xml文件中的*.do来调用ActionServlet

4、ActionServlet的处理
9 M4 f; |2 G( B( b! n5 z" K+ L
4.1 读struts-congfig.xml文件形成ActionMapping

4.2 通过path 来匹配Action类，通过Action的name属性来匹配ActionForm类
8 O! A! w" q( e& B% j
4.3 通过反射机制来给Form添数据

# R8 P; U8 V/ M& D7 w4.4 由ActionServlet转调Action的execute方法

4.5 得到execute方法的返回值，跳转页面

1 e" n3 z& \, o& Q! f1 D, z/ \# `% S3 R3 |4.5.1 RequestDispatcher

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

- K. \3 u6 N) A! p% X

* c# R* f$ F; @6 l3 p1 X$ R( o进入execute方法

5 T8 }, `" z0 Z( B1 k, x+ D' b& a1 收集参数
8 \* Z, r! s  ?6 F
9 N8 @% l9 ?  e5 H8 n2 组织参数
/ X% p1 h" J$ H' G
3 调用，逻辑层

* x) H5 k* y- }; s0 [& Q4 返回值

5 e5 P- D3 t5 ?! Z4.1 选择下一个页面 （ActionForward）

( v# v7 b. M* j  N# a4.2 把值传给下一个页面

1 b  j( x0 T/ B+ ~7 l& ~

比较struts和struts2的不同
; m2 N% N! r$ P! V& n
Struts
$ q, D+ m# N' Q) y, q
) B/ Y9 E: r( r, V) w' vStruts2

4 A$ }. F2 m$ z组成        五个部分：ActionServlet，ActionMapping，AtcionForward，ActionForm，Action        十个部分：AcionContext，FilterDispatcher，ActionMapper，ActionProxy，Configuration Manager，Action Invocation，Interceptot，Action，Result，Taglib
( I3 p; W3 F3 p+ ^2 Ourl        .do        .action
分发控制        AtcionServlet        FilterDispatcher
收集参数        利用JavaBean技术，将数据封装到ActionForm的子类中；
一个Action对应一个ActionForm的子类

. }( W5 t$ M5 r6 P使用拦截器将数据封装到值栈中。
使用域模型，一个Action对应多个值栈中的Model

读取配置文件        ActionMapping        Configuration Manager
5 `9 I9 G* s3 `; o& x( w5 K拦截器        无拦截器        执行Action前后有拦截器
返回页面        将字符串封装到AtcionForward，进行跳转页面        Action中直接返回字符串，通过Result跳转页面
页面跳转方式        两种：dispatch，redirect        三种：dispatch，redirect，chain
值栈        无值栈，Action通过在request范围内设置属性，向jsp页面传递数据        有值栈，Action和jsp页面通过值栈传递数据，jsp页面通过OGNL取得值栈中的数据
配置文件        struts-config.xml        struts.xml
中文问题        不能解决（需要使用filter）        可以解决中文问题：
1、在jsp页面添加Meta；

2、修改struts.properties中的设置。

admin

其他开发工具和技术
Ant
$ ?4 q: j' M& h2 ?5 R; g8 UAnt是基于java的批处理工具

7 ]8 M( p+ Y; k一、配置ant的运行环境

1.将ant的bin目录添加到path中
# w1 v' v' _  V
2.配置JAVA_HOME
3 [; R) d( w2 P, R9 Q9 C' f
3.配置ANT_HOME

6 n% a9 u0 |6 U) {6 n$ }二、配制build.xml文件，该文件放在应用程序的根目录下
$ T: ?/ ^' W' s9 Z( L0 i
编译java文件

( d9 U; P# d8 q$ Z5 ]& `# P执行java文件

copy
& k& w5 \! I, V5 i! N- C& Z. w( \/ E
- f* @$ _8 R, d( J5 _6 q删除

打jar包
: Q! N7 E' f" u+ m# g( [, r, u* m
, r" i7 w$ ^/ W4 a2 O根据注解生成配置文件

Xdoclet
通过注释生成一系列文件的工具（txt、xml、java、html等）
) d, |9 w1 M) v4 s; o3 z
3 }  G4 v$ _: Z: Yxdoclet本质是摸板技术+字符串的替换

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

5 D7 m+ B+ c- y' {9 D1.1 在类的上面 写与表的对应

1.2 将每一个属性的注释都写到get方法的上面

2 J, E# @. A* J2.在ant中引入相应的task来驱动xdoclet


/ p# `! ~, f4 I) c
' d5 d2 t* G5 G9 Plog4j日志管理
& q( z* ^7 M' Y, {1 f5 C. O5 {1、是什么？

' }8 x7 n1 a1 }) o0 O1 }( G( z' j. _# L在开发期间用来测试、对整个日志信息进行管理的工具

8 f8 Z" W$ u% M2、功能

1.控制输出的目的地
) K5 m' `9 j( S& @
2. 控制输出的格式
$ P) A# H0 }0 F+ K
3. 控制输出的级别
3 k; {  V. B7 O% E8 M
3、日志的级别
9 h; s1 I& B  X" `( J8 X3 t) l
8 s- _1 X' d$ T# Q1. debug 调试
$ Q* U% d5 a' }: }. L* x
2. info 给用户的提示信息
  t+ X# z0 N9 U
3 g: a  ~7 n  {. n4 Y* z, s6 H$ O3. warn 给用户的警告信息

4.error 给程序员用来调试
$ D& j- K) m, @7 I  ~* S
Debug—-〉info—-〉warn——–〉error
; c& v; V0 \6 g: n( c* D0 @( D
3 c5 }7 P6 |* U: z, r8 |, ]4、配置
1 P: T+ l  r% }6 D! L6 a
1.配置级别
1 }5 D. k: S& `
2.输入源 （控制台和文件）

3.可以进行分包控制
2 P9 n+ V" Y9 ]7 ]
Log4f.logger.包结构 = 级别
' m5 k$ A" f3 z: L! N/ B- @
- ?% X/ M, {+ ]# [* }5、使用

5 G# K& W; l' oLogger log=Logger.getLogger(Test.class);
# U- y6 r1 R/ }& C7 s( O
    public
: n8 e' B! x2 x7 g( _void t3(){
( H" v/ Y2 a: f6 _
; ]# ^* \# [  ?3 E! w/ e; {        log.debug(“this is debug”);
' w! g2 W6 }+ K: U9 @* X; F& C5 @
        log.info(“this is info”);

        log.warn(“this is warn “);
* ]5 i" O% z# D3 N
9 B% C) ~8 D; q' i6 ]. I1 ]+ {        log.error(“this is error”);
4 m/ D7 G; X$ U" V; D0 P
    }

8 f; D% C5 O' X5 @& y8 V/ VJunit
1.是什么？
& S" q0 H# \# ?1 V2 _
. i2 N( n% m2 J+ B$ w  V单元测试的框架
4 S7 H/ `4 T9 i+ b, i$ H' W
* R5 X! P: T/ L1 ^1 u9 Y7 B2.怎么做？

  y' h4 I6 ?) L3 \+ g7 y# r: q写一个类继承TestCase

测试的方法一般都以test开头并且没有参数

2 M: U; V8 J. y% I2 e/ g- h在测试方法前执行的方法public void setUp( )
6 x- J3 Y) d2 F$ b' _4 f- n! B; b
在测试方法后执行的方法public void tearDown( )

error和故障的区别
! A, f8 D" U0 p
error ：代码有问题

故障 ：逻辑有问题与祈望的值不相符合
: \. @! q) o3 A2 V1 t: B" j
生命周期

测试—〉SetUp（）—〉testXX（）—〉tearDown（）—〉结束；
4 c9 l, S6 o9 c) Z- @
TestCase套件

: F: y& ^/ k: jpublic class MyTest{
8 e% U. O0 C* K% k
0 F& s. J2 N7 o& r        Public static Test suite(){

TestSuite suite = new TestSuite();

0 W) h5 m7 O3 K5 Q0 ]suite.addTestCase(Test1.class);

: |  M! |* x$ l+ G" ]  Bsuite.addTestCase(Test2.class);

}
) C# x2 A' j. E9 A* _5 W' o6 l
}
8 ?! l4 a$ [( K


+ k3 u7 l; ~5 o- ZAjax
是什么？
! u5 Z; L! t9 T  f# x: V1 LAJAX即“Asynchronous JavaScript and XML”（异步JavaScript和XML)。是一种创建交互式网页应用的网页开发技术。

0 k6 w8 p3 e( U: `5 Z5 h无刷新页面。

有什么？
AJAX是多种技术的综合，包括JavaScript、XHTML和CSS、DOM、XML 和 XSLT、XMLHttpRequest。

能干什么？
使用XHTML+CSS标准化呈现；
使用DOM进行动态显示及交互；
使用 XML 和 XSLT 进行数据交换及相关操作；
使用 XMLHttpRequest 进行异步数据查询、检索；
使用JavaScript绑定和处理有所得数据；
* P* v/ u+ n% ]0 f
1 V- N4 o) \2 w6 B( M8 J7 ?% v1 B传统的web应用允许用户填写表单(form)，当提交表单时就向web服务器发送一个请求。服务器接收并处理传来的表单，然後返回一个新的网页。这个做法浪费了许多带宽，因为在前後两个页面中的大部分HTML代码往往是相同的。由于每次应用的交互都需要向服务器发送请求，应用的响应时间就依赖于服务器的响应时间。这导致了用户界面的响应比本地应用慢得多。

# }' c. Z& f; g4 ]$ F( r! W1 V与此不同，AJAX应用可以仅向服务器发送并取回必需的数据，它使用SOAP或其它一些基于XML的web service接口，并在客户端采用JavaScript处理来自服务器的响应。因为在服务器和浏览器之间交换的数据大量减少，结果我们就能看到响应更快的应用。同时很多的处理工作可以在发出请求的客户端机器上完成，所以Web服务器的处理时间也减少了。

, ^2 G7 X' e! z" i) q2 w使用Ajax的最大优点，就是能在不更新整个页面的前提下维护数据。这使得Web应用程序更为迅捷地回应用户动作，并避免了在网络上发送那些没有改变过的信息。

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

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

& ]/ h; v8 ^' u% K. \var req;
. \) W8 ~. ^! }2 L
' x( _* Z" M( Yfunction add(){
# e! Q4 T8 O, h% O7 b
0 U2 ]6 \( x# s& K- f. [//1:创建用于传输的对象
. P2 e, N9 M8 P( G; ~1 G
req=new ActiveXObject(“Microsoft.XMLHTTP”);

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

' c1 p- H  i0 F" Rreq.onreadystatechange=manage;
" T- M; i2 R+ f& U# [" A
4 ^+ ~3 k4 i$ l1 V0 V4 f/ H1 O//2:准备传输的内容
9 p. k& h3 g% j$ G
var str=”test1111″;
  @# W& m' \& Y8 b' V4 k( O
# Y3 H7 P5 i/ Z, F4 q' F2 u+ `9 A$ t$ L% q//3:发出请求

req.open(“GET” ,”/others/ajax/test/t2.jsp?str=”+str);
; d1 f) }. \' h$ p, }, n
0 r  h3 d" d1 Nreq.send(null);

}
! m7 }7 |) ?1 H$ C. M: m8 f
//4:接受返回并处理

& a& e& T1 {7 A  V1 Ofunction manage(){
. U; V% o3 Y* |3 e- l4 `
if(req.readyState==4){

7 Z+ ~) W- q) j( J" Salert(“r==”+req.responseText);
% i# [/ l8 P! j# u
! i5 X/ N( l2 H}

1 D9 C" e( j5 t4 L( Z}
7 @6 A! \+ q' z9 f( [. V/ d! G! i* @
</script>

readyState的取值如下：
: C+ G1 N$ m, N) L
　　0 (未初始化)
9 A; J/ U3 I1 U
　　1 (正在装载)

　　2 (装载完毕)
3 v: l- j& }/ R: t! d0 J, P
　　3 (交互中)
& M% A$ W0 Z' s* s8 t4 g9 C
0 Q  s# i( W) W* L. G+ O　　4 (完成)
' e' B. s6 _0 X  _. X; ?9 k2 R& R


原理
5 C( r9 a0 [) D3 v5 aAjax的原理简单来说通过XmlHttpRequest对象来向服务器发异步请求，从服务器获得数据，可以是xml格式，也可以是一个字符串，然后用javascript来操作DOM而更新页面。
. `; Y" b- g$ a/ x
Dwr
( s2 v& e, Q- T0 C是什么？
DWR（Direct Web Remoting）是一个开源的类库，可以帮助开发人员开发包含AJAX技术的页面。它可以允许在页面中使用运行在WEB服务器上的JAVA函数,被调用的JAVA函数就像是在页面中JavaScript方法一样。
% n; k6 k: S* K! u# ]7 d$ a
2 q6 o7 q' C5 v( l  ?, g2 X有什么？
它包含两个主要的部分：允许JavaScript从WEB服务器上一个遵循了AJAX原则的Servlet中获取数据；另外一方面提供了一个JavaScript库可以帮助web开发人员轻松地利用获取的数据来动态改变网页的内容。
" I) ]3 w$ z0 P. v: @& v: |

) `( {, \4 n% z! w$ f6 a) J: g& I
能干什么？
动态地把java类生成为JavaScript，感觉调用就像发生在浏览器端，实际上代码调用发生在服务器端，Dwr负责数据的传递和转换。这种从Java到JavaScript的远程调用功能的方式使DWR用起来有种非常像RMI或者SOAP的常规RPC机制。
3 A: F3 i/ l+ L9 B9 Q5 p* n( o

& K8 Z. |" X/ F! ?+ q
怎么做？
① 编写配置文件

web.xml
, s* Q: M2 w0 b" n2 L* D
<servlet>
5 Q9 j. `! b6 a' q) O
<servlet-name>dwr-invoker</servlet-name>

! J: g( H: M3 q+ K% W, n7 U<servlet-class>
! ~% d0 ?+ B3 ^2 U  J0 d' F* b
4 e/ w9 X% s; E& b- v! h0 |' ^; worg.directwebremoting.servlet.DwrServlet

' B3 g5 ?" d! |</servlet-class>

<init-param>

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

<param-value>true</param-value>
! K* V. m7 [, Q" \9 L- ?
</init-param>

# S2 l" }9 U/ z3 n* B" R</servlet>

/ G" b' O  h1 N% Y- o<servlet-mapping>
+ V! @$ J! b2 g: N9 V5 f
; R5 o3 a9 P4 g, j# {<servlet-name>dwr-invoker</servlet-name>

<url-pattern>/dwr/*</url-pattern>
4 e1 E4 n* W- P& ^8 i
</servlet-mapping>
% y2 p: J- N8 P4 F
dwr.xml
* C2 f+ d+ `$ ?- F$ T4 w3 E) H
$ J- h0 F7 N3 o% Q<allow>
; t6 \/ K8 m1 o) w8 W5 l. a/ I
! D. Z5 s) n9 }- c3 k' j2 {<create creator=”new” javascript=”kc2″>

<param name=”class” value=”dwr.Service” />

</create>
# Q% b, d- i' {/ g# R3 g# @+ D
1 E- M  `3 |8 |2 Y( [/ o/ I</allow>
& U! ?; H  m: K( @# ], `& C6 ^- t4 X
7 N0 `' a) u4 ?) P1 P②编写service
/ }% Z  ~! K* l, V
; b4 r& @8 |8 j% W# s; o6 Lpublic class Service {
* r% P9 L& i) a  _: H8 [
public String sayHello(String yourName) {
+ ?% W) }* Y+ n" O+ M% h
//可以是访问数据库的复杂代码
$ t, B9 n3 S; H0 j
: @& y+ ]" z! @* sreturn “Hello World ” + yourName;

" e/ o9 J1 A9 O4 ~4 j}

- q" `, `7 I2 R- O}
4 J6 N- m- R9 m- w: G$ K4 ]" L% W: A
③测试DWR

+ {" D' G3 B0 R# C2 ~9 Y! H  h8 q2 }0 ^将代码放入应用服务器（比如Tomcat），启动。

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

④编写jsp页面

1） 要引用3个dwr的js，其中engine.js必须要，如果需要用到dwr提供的一些方便的工具要引用util.js

2） 然后还要引用dwr自动生成的js，dwr/interface/service.js，注意js名字要和dwr.xml配置的一样
- A" s  P5 ~/ _
( \( {3 t9 A0 ^( ]) T+ z) K3） js里的service.sayHello和java类的那个有一点区别，多了一个参数，用来得到返回的数据