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

admin

JEE
$ }% J" w: w4 b简述JEE
JEE　： JAVA　 PLATFORM　 ENTERPRISE　 EDITION

JEE是一个规范集；

5 F. u. E8 o: T8 g! NJEE是一个框架集；
: ]# Z8 ~" B7 p; _% M4 p
' A0 _6 X: U2 c9 t' q8 {5 iJEE是一个技术集或API集；

适用于创建服务器端的大型的软件服务系统


, J, J3 C6 s. K" k* e3 p
! ?+ C* Y6 }8 D, XC/S B/S 模式
C/S client/server即客户机/服务器模式，客户端也参与程序的运行与计算（富客户端、胖客户端）
7 h0 L; U$ |4 d6 z* N' ^+ b% F
3 R* H6 Z8 z# z7 Y8 kB/S border/server即浏览器/服务器模式，又称为瘦客户端，客户端不参与程序的运行与计算


' ^0 S7 O/ e* b  v& k- S% y1 P
企业级应用（大规模的应用）的特点
1.生命周期长、稳定、可靠
" U" p# n8 ?% E! k/ g( E
& A2 e6 z3 \- u' i/ Y0 l/ X" `7 N2 E2.组件往往分布在异构的环境中，能够跨平台
, P  C2 B, t% m8 v  s& R' @% B" s3 w
7 [  U8 Y8 i2 @3.维护性、扩展性、重用性

4.有事务、安全、线程
3 a( g- A* H6 _- B
. p, k" `9 f& U1 r' S! Q6 G3 V

$ o" H1 J7 ^: l" n( `什么是业务逻辑？
4 j+ n. u+ s" i, j9 w; l9 O依照业务逻辑划分模块，
( ]! P( p! U2 D. V
所谓判定业务　就是具有以下特征：
- h8 t! I( W: D  Y* |4 J; M
# S0 D- ^* M" ]4 i9 u: [# s+ h1.业务流程

2.业务判断
. T4 {* o* k0 [$ ~1 B+ p  k
3.功能组合
- o7 Y: y- y8 |+ E5 [


7 ?- P" C1 f$ \0 H; k; F平台（角色）的划分
1.平台供应商。提供满足API集实现的厂商（BEA weblogic IBM webshphere）

( O; w0 J1 k4 S& V& _. d6 ]) N5 _6 h2.组件供应商
) c" `8 Y; M3 B, Q3 z
3.组件装配人员
/ f+ ~; T- Q; h$ o! S3 C
4.部署人员
& B8 U) t( c# \! f6 a  {% \
+ n) [5 v' s# }8 L( t5.系统管理人员
' v6 U$ a. z$ u, ^* j) e2 S
1 m: S/ k6 w: h. f6.工具供应商 提供开发组件所使用的工具（Jbuilder、eclipse）


7 t+ n) ^0 t+ j5 ^# u8 d3 U
java技术分布（设计架构 模块内部设计）
1.表现层 Servlet、 Jsp、 JavaBean、 Taglib

2.逻辑层 EJB(SessionBean)

. Y; t  K/ l. I2 ?8 S! u3.数据层 （　JDBC 　EJB（EntityBean））
) r* w% l: o+ L/ ?
' m7 w- m% H) ^0 c* T. f4.服务 JTA（JAVA事务架构） JTS（JAVA事务服务） JAAS（JAVA授权与验证服务）

5.分布式通讯 RMI（IIOP）+JNDI 、JAXP（JAVA 的 XML 架构）

JAVAMAIL（邮件服务）、JMS（消息服务）、IDLC、JCA（JAVA连接器框架 （成））

' {5 Q; ]- H. l% @0 x
. Y0 c& H3 [- I$ ]  _, r
2 e6 n) J( g1 I# R  CJEE的体系结构： 是一种组件的体系结构
( B, Q9 y. q* Y3 ~  @3 r! |& l1.组件 ： 能够完成一定功能的封状体（独立的功能的集合）
0 x" ^3 Q7 V9 f3 |$ Q2 v6 a$ X
不能单独运行，必须运行在容器上
7 O* S, H) D" O% h4 k0 d
5 v* ?& M" g3 d7 [2 A分为两类：web组件、ejb组件
  A& O9 s$ X8 F. m  Q
6 N, a$ H4 I) d: n% I2.容器 ： 提供组件的运行环境，并对组件进行管理（一段程序）
7 E9 v, \- c% `
# }& c  T$ a, W3 r2 a管理组件的生命周期

/ z8 K1 F6 ~) l/ g- X7 G不能单独运行，必须运行在服务器上
' n! ]1 h& l% g. _
程序（组件）通过上下文来调用容器（context）
/ {& {8 w* g  R' e; |" F2 z. v* T) `
组件通过web.xml向容器描述自己，使容器能够认识组件

, p# T! x& R  N% }5 B) ^容器通过回调方法来调用组件

分为两类：web容器、ejb容器
* v' P; x$ E3 q; t: O; A7 k8 ]0 R1 G
" a* _: z4 k/ ~7 _* f7 J$ h7 f% s  T3.服务器 ： 提供容器的运行环境，提供大量的JEE基础服务
  _1 p+ E6 |& P$ _( d) ~. n
! k/ h4 U: {2 tweb服务器（只提供web服务）

jee服务器（提供web、jee服务）
5 X1 Q2 P: ^- a/ Y: y8 ?
1 p% g' F) f( q3 ^6 n
# z; G" }9 _. r& A- m
# z6 Z" Q3 Q) ~- `什么是回调方法
& l2 S; H' m/ F由容器自动调用的方法，就叫回调方法。
3 ~1 T: X4 Y0 [1 l! I# E% O
% O# ~7 }* \$ r% @
5 [. x9 P0 _  }% i! z
ＲＭＩ远程方法的调用机制
例如：Ａ主机有Ｂ（）方法，Ｃ主机有Ｄ（）方法，Ａ　想调用Ｃ主机的Ｄ方法
( W& w# Y4 W$ Y2 B
) R. l, L* H" i. d( e& `! z

/ ?: A! H+ b- }& g( l: F1 @2 d* q

6 k! ]5 e! S' ~) ~4 b学习方法
1.规范（熟记） 2.熟悉API 3.多练 4.多想

admin

Servlet
6 }4 `- z# m( |1 q8 X- `8 p

•     描述war包、jar包、ear包的结构
  
  2 v( i& c; T2 w' g! a
  

war-                            web文档压缩包

—WEB-INF

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

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

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

6 T+ [8 C5 A4 U6 c3 ]! L' D

jar-                             java文件压缩包

—META-INF

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

3 ?7 {& q# Z/ _& r1 U+ c

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

–META-INF

—Application.xml 配置文件

–*.war

–*.jar

" Z" L! V9 d7 M/ N

• 什么是servlet？servlet主要做什么？
  ; Z1 W7 d2 Q, B: u+ |
  
  

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

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

' w+ Y  [* b! _' ]) F

• servlet 与cgi相比的优点？servlet的缺点
  + e3 _# [0 ]% f( X* Z: X& P
  
  * ^* G6 ?- k0 G- S

优点：

性能（线程比进程更快）

可伸缩

Java强健且面向对象

Java平台独立

缺点：

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

( i7 B" S- S9 z# e2 M+ ]$ O

• 常用的servlet包的名称是？
  
  
  

javax.servlet

javax.servlet.http

8 d; x8 e4 `4 `" A1 B0 i" a

• 描述servlet接口的层次结构？
  
  - S6 D( l& x2 ^. ?, ?
  

Servlet

–GenericServlet

–HttpServlet

–自己的servlet

ServletRequest

–HttpServletRequest

ServletResponse

–HttpServletResponse

2 r5 T6 D; N% R% F. Z& e

• 对比get方法和post方法？
  
  
  

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

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

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

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

% p7 k2 p( r6 U- y: g

• 归类描述HttpServletRequest接口都完成那些功能
  % j% o; R" K: a' q( k
  
  
  • 读取HTTP头标
    
  • 读取cookie
    
  • 读取路径信息
    , k* C' @+ i8 f
  • 标识HTTP会话。
    
    

• 归类描述HttpServletResponse接口都完成那些功能
  
  
  0 z& t0 l' t: A; N& o2 i
  • 设置HTTP头标
    ) v3 g! b2 e; [( I9 U
  • 设置cookie
    
  • 设定响应的content类型
    
  • 输出返回数据
    
    3 j- F- t9 b# a5 D* T7 W7 u/ d

• 描述service方法所完成的基本功能？默认是在那里实现的？
  
  
  . T* \6 C4 {5 r+ y; g

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

实现：默认在HttpServlet类中实现

4 I( N8 V: g* M; N

• 如何开发自己的Servlet？描述应该做的步骤和每步需要完成的工作
  
  0 U* z- ], Z$ e% a0 x
  - _% ^  S! Y: c5 {( `: z

1.引jar包

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

2.开发servlet类

1)首先继承HttpServlet

2)重写 doGet( ) doPost( )

3.部署

安装web服务器，例如Tomcat

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

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

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

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

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

4.启动服务器

• 为何servlet需要部署描述？
  
  , m6 [3 K( \+ a( J3 }9 [
  + b* p% ^1 d) b. j

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

0 x7 b0 }: j4 |; V2 J# J& T

• Servlet基本的描述应该是？请写出来
  
  
  

<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
  & p( u2 p) z$ S. i3 x  {
  / r' P/ M# y4 [* s/ O! S9 h
  . w, t4 j: H0 w3 |. A

FORM标记

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

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

语法：

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

{HTML form tags and other HTML content}

</FORM>

• 如何接受request中的参数
  
  - I6 b6 c) }- |; }% kString userName = request.getParameter(“userName”)方法
  $ S& O+ t4 K6 O% R) m( B
  3 {/ p6 ?/ T1 q9 L( ^/ N+ |% Y

• 如何接受request中header的值
  
  
  

request.getHeader(name);

request.getIntHeader(name);

request.getDateHeader(name);

request.getHeaderNames();

8 k1 t# k" N& Z7 \; b: [

• 如何输出html
  
  
  8 V& U- X* j  s3 g4 ?) J, T( c

PrintWriter pw = response.getWriter();

pw.write(“<html>”);

pw.write(“Hello”);

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

! ?/ c% W7 Z8 U) n

• 如何设置输出的contentType
  
  
  ; U# `' M0 J2 \% m3 b, N# g

response.setContentType(“text/html”)

" R1 X! S, w! I. [, {4 Y. v2 c

• 描述servlet的生命周期？
  8 I" }1 S) k7 F# l7 V4 J' J8 ]
  % H7 |" ~8 P: P4 K
  

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

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

# {. D+ W+ |! ^' }

• 描述init,service,destroy方法的功能和特点
  9 U6 Q  k# X% P5 R
  
  

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

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

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

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

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

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

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

/ W1 C: l. X0 B; D- Z# l  o! W' W

• 什么是回调方法？有什么特点？
  7 ]; s  H- y! R; @' Z0 p+ k
  5 y  W: L. k1 c; b: a" n6 y( |/ [
  , ~" t  H9 D4 ~, O

由容器来调用程序的方法

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

9 u- q8 J5 _$ g: X0 n0 J

• 如何设置初始化servlet的参数？
  
  + F( u5 N+ L) X在<servlet>中添加如下配置
  
  

<init-param>

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

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

</init-param>

' z  Z( c3 ~8 M) }

• 如何获取servlet初始化的参数
  & p! b3 ?5 K- N) B" T
  
  . D+ Y0 a9 }% M& L5 h+ b

public void init() {

greetingText = getInitParameter(“greetingText”);

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

}

• ServletConfig接口默认实在那里实现的
  
  
  

GenericServlet类实现ServletConfig接口

$ P0 |; F7 \) u  a8 ]" h+ R. |! {

• 什么是ServletContext？有什么作用？
  7 g9 G4 P" z- S5 g
  
  

Servlet上下文

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

• 如何访问ServletContext接口？是在那里实现的？
  
  
  & l: }- n1 n& X$ e* K% o2 X

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

GenericServlet类实现了ServletContext接口。

• ServletContext接口的功能包括？分别用代码示例
  1 h: I! Z0 P: H6 }$ B- F1 B
  6 ~# E4 e5 Y+ d5 i- p
  

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

. y1 P% U& y, f2 E3 |

• 如何设置ServletContext的参数？
  
  
  

<context-param>

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

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

</context-param>

• 如何获取ServletContext设置的参数值？
  * V1 c  r0 }4 m# `: t& `8 @9 X0 j$ ~
  
  

ServletContext context = this.getServletContext();

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

• 描述Web应用的生命周期？
  9 R( q0 M; ^0 L' J/ D& L
  
  

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

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

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

( R5 b7 I# X4 K1 L8 `9 D1 ]0 n# B) w

• 如何用代码实现监控Web应用的生命周期？
  6 v) M$ T; Q8 C$ j+ C
  , C9 q* f% j/ K/ g
  4 w- R: u& f; [/ ~4 R  Y/ c0 R
  2 z3 Y. m+ o6 U; |: }. Z

public class Test implements ServletContextListener{

public void contextDestroyed(ServletContextEvent arg0) {

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

}

public void contextInitialized(ServletContextEvent arg0) {

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

}

}

. V0 s! c& u. {

web.xml文件中的配置：

<listener>

<listener-class>

com.csy.Test

</listener-class>

</listener>

• web应用中如下错误码示什么意思：400，401，404，500
  9 s! {2 o7 a7 Q7 m4 d
  + p  b4 r/ P" L! b# f+ u
  400 Bad Request//错误请求
  401 Unauthorized//未被认可
  404 Not Found//没有创建
  500 Internal Server Error//服务器内部错误
  
  2 M1 c4 {# x1 O

• 描述Web应用中用声明方式来进行错误处理的两种方法
  % U3 L; k& x! {7 t3 e1 ^
  , ^) _! J3 r7 _  q/ J0 G( f
  . c0 L- ^& w4 S: Z; Y, M6 X

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

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

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

# R. G2 \6 Y" O- E1 Q8 A

• 描述记录异常日志的方法，都位于那些接口？
    v  y* h% r6 b4 w; L% U
  
  

GenericServlet：

log(message:String)

log(message:String, Throwable:excp)

ServletContext：

log(message:String)

        log(message:String, excp:Throwable)

• 什么是会话？
  6 k9 }+ D! J4 \, |
  9 w: T& _% X) O1 x  D0 h% X( L! R
  

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

* f- O& k2 F6 Q

• 如何获得会话？
  6 a; t1 X2 [( z
  2 _& c2 G9 p! [
  HttpSession session = request.getSesseion( );
  
  ! g. ^8 D7 f5 d3 {" a* |

• 会话Api的基本功能？
  & @5 Q- l7 `: v- d4 f! B* Z
  
  

getID() :String

    isNew() :boolean

    getAttribute(name):Object
! f, s' {4 j5 ^. N) \

    setAttribute(name,value)
6 S3 `" l0 s- W5 N! a, ?

    removeAttribute(name)

  D, [8 h  s7 d4 G

• 如何销毁会话？
  + M# \! E+ t3 u! v8 N: X2 C, H; m
  
  2 u+ j' O% c5 x1 z3 \0 S6 u

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

<session-config>

         <session-timeout>10</session-timeout>
; Z- i  J5 l% Q0 [$ b# Q4 [" ^

     </session-config>
7 [+ s: R  m4 h4 Y# i( U& N

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

invalidate()

     getCreationTime() :long
' g  Y' v$ Z  K( Z( c3 G

    getLastAccessedTime() :long

    getMaxInactiveInterval() :int
- y/ r, h8 Y" B/ l& G8 {0 O+ @" q

     setMaxInactiveInterval(int)

3 n! k; g; {& g5 K

• 描述会话保持状态的基本原理
  ) ^+ z4 b8 m, p  k; e; d5 L
  
  8 H9 F4 o& F/ D. q% a

1 Z! h+ L2 ^0 {

    client server

request
6 v% S5 Q( K# n0 h% r7 W( ~

response (sessionid)
/ y; G* Q6 }. [; q6 U- @

request (cookies)

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

• 请描述session和cookie的异同之处
  
  
  ; h1 A7 J+ S& T7 o6 F" J8 V; k: A6 S

6 E3 W3 f2 V7 ?/ w" ]
1 X% I6 F% w4 s9 m$ o6 O

• 如何读写cookie，代码示例
  
  6 W+ u0 @/ S8 C: Z1 z* w" \4 J
  : ]9 i- |7 K. X& F! x: r

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

response.addCookie(c);

读：Cookie[] cookies = request.getCookies();
. |8 `5 S4 E5 \. d3 J

        for ( int i=0; i < cookies.length; i++ ) {
* i# `; W, g2 C1 h- v5 f  F% G

            String key =cookies.getName();

String value = cookies.getValue();

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

     }

• 什么是URL重写，如何实现，代码示例
  / j  r, c9 i2 v5 D; Z# u
  8 q7 L' X+ L5 |
  

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

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

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

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

# C# ~$ p$ y/ [! F5 e( I, N0 Y$ ]* N

• 描述web应用的4种认证技术
  . n6 n5 }; v* t+ a" w/ t
  + E, }# W. o- q% R! n1 ]3 u' F
  ' q! H4 ?! W5 v4 P( N6 L$ M

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

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

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

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

# e6 s/ O. m9 s$ ?

• 什么是授权，什么是验证？
  7 W' ]2 K- a! q/ i) Q
  
  

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

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

: `- ]* g9 }: p. |8 l2 u5 m

• 什么是HTTPS
  $ n8 J6 h1 k  H8 d' |
  
  9 h5 n) A$ n/ O2 T1 r. N* ?, \

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

• 什么是审计？
  - z6 @/ z1 E2 P
  
  

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

4 v' v0 n. b' W

• 如何实现声明性授权
  
  , n( F( x. N5 u- Z
  

1、标识web资源集

2、标识角色

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

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

在 web.xml里配

; K0 M" F+ Q; b& D2 [( G4 q! b

• 描述servlet并发问题？
  * R1 M4 w2 e) }: i4 x
  
  

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

• 描述Web应用中的六种属性范围
  . q5 {2 o2 r7 J( g' y8 R2 z
  * v6 q3 z- ?' W( T! h
  

局部变量（页面范围）

实例变量

类变量

请求属性（请求范围）

会话属性（会话范围）

上下文属性（应用范围）

• 指出上述六种哪些是线程安全的
  
  
  1 K7 t2 Z5 v7 j* P

局部变量和请求属性

* v) X: x7 V; g( S. a

• 什么是STM？如何实现？
  / D/ a6 F/ f2 P6 {$ ^
  # P  L4 |: K! i
  , m* K, @1 R1 F% }5 ?

SingleThreadModel接口

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

• 如何实现并发管理？
  
  1 T/ l5 ~6 g9 `3 Q
  8 G; L( l* [7 h. l9 l1 a6 _

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

使用synchronized语法控制并发

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

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

admin

Jsp
什么是Jsp?
Java Server Page    结合java和html在服务端动态生成web页面的技术



描述Jsp页面的运行过程？
+ m/ i& z$ G/ T& a4 q) Z第一步：
3 j4 d$ Q8 k  w8 ^. i- s
请求进入Web容器，将JSP页面翻译成Servlet代码

) `- Y9 G3 \. ~, d" k& @/ J. |5 i第二步：

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

6 }3 t- L5 E9 ^6 p3 ]第三步：

Web容器为JSP页面创建一个Servlet类实例，并执行jspInit方法

第四步：

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

3 S, x; K3 Z$ i( d
$ u2 o8 Q5 w& T/ s2 o2 @) I
描述Jsp页面的五类脚本元素的功能、写法、并示例
4 b& z  U- C8 g0 Y5 A& y& N注释 <%– –%>

<HTML>

<%– scripting element –%>
. T. K, i& I- `
& N$ O! g' ?' b& i3 M, @& s% T, F</HTML>
5 u( G4 b1 c# [5 ~, V; X
指令标记 <%@ %> 指令标记影响JSP页面的翻译阶段

  ?* ?! l+ @) F& S<%@ page session=”false” %>
* o  \6 T1 r' E  z7 v; i% s
1 U) b$ q2 s( [( s- X7 u  q' z6 r声明标记 <%! %> 声明标记允许JSP页面开发人员包含类级声明
3 z& N! ^; U% Y/ s5 ^. }
<%! public static final String DEFAULT_NAME = “World”; %>
+ g2 m1 t2 W# o  ^
    脚本标记 <% %> 脚本标记允许JSP页面开发人员在_jspService方法中包含任意的Java代码

    <% int i = 0; %>

1 l- a: g, {) |- b- J/ f表达式标记 <%= %> 表达式标记封装Java运行时的表达式，其值被送至HTTP响应流 <B>Ten is <%= (2 * 5) %></B>


% _- R- h8 Q1 ~% Y+ |# M. k
描述Jsp页面中的注释种类和写法
HTML注释
& u4 o2 ~. I6 S
' A% H9 a' `4 ?1 V# T) W' y( ?<!– HTML注释显示在响应中 –>

, [+ b5 ?( N4 C- g* H& ~JSP页面注释
  E$ B, d, {' y+ ~( r
- n4 l% q( h7 V/ l, c2 k- g$ G<%– JSP注释只在JSP代码中可见，不显示在servlet代码或响应中。–%>
3 r! V! m- O* J1 z+ r
Java注释

<%

/* Java注释显示在servlet代码中，不显示在响应中

*/
( J  P( d8 x( R4 ^3 w6 o# u
%>
" S$ L9 k2 J+ a% m. Z
- m7 h0 ^" [" |8 ]( m) ^

" ]) k. E8 `- G描述Jsp页面的指令标记的功能、写法、并示例
; u( N2 b) h$ [6 H/ S2 H指令标记影响JSP页面的翻译阶段
; R5 F: M4 M) p
3 J1 C5 F" g, p/ h. `<%@ page session=”false” %>
0 E5 \! `# y8 E- S2 G
) c) y. P6 b# ?. S( ^; c7 e<%@ include file=”incl/copyright.html” %>
9 f- I% q0 K; O
% [! S2 ]- s8 W/ d$ v. q<%@ taglib %>
/ x7 D' m& S! p8 b# L0 d+ t

0 T/ x' Q7 a: u+ g  |* k* N) G- c
9 O: G5 }$ ^5 W( H: V' n8 }描述Jsp页面的声明标记的功能、写法、并示例
5 B2 U: \9 v+ b  R4 R; a声明标记允许JSP页面开发人员包含类级声明
' d1 p3 m" P. f( a7 }/ C" c
. H8 t7 r" {, O% n% J4 }0 a& S写法：
: _" ~& w! |2 l4 D
<%! JavaClassDeclaration %>
, H( c5 V& n: v+ O8 D+ F
例：
+ q6 ^5 o5 I% k: @/ W
<%! public static final String DEFAULT_NAME = “World”; %>

<%! public String getName(HttpServletRequest request) {

return request.getParameter(“name”);
% s( r2 h+ d" U5 d: o# W1 q/ k# B
3 q' l; ?( H5 a' ], a- H( K6 M}
  a" v/ d! v1 }7 o* Q
4 ]* r' v0 R7 t, A# `3 Y%>
, M# N. A% o5 ?- ^. \  R+ Q
<%! int counter = 0; %>

/ ?1 p7 n# u$ z; C! X1 q4 v

2 F: c; O3 F1 x9 W1 q# F描述Jsp页面翻译成Servlet的规则
jsp中的注释标记被翻译成Servlet类中的注释

jsp中的指令标记被翻译成Servlet类中的import语句等
1 l8 d9 a/ V, ]. j
jsp中的声明标记被翻译成Servlet类中的属性

jsp中的脚本标记被转移到Servlet类中service方法中的代码

jsp中的表达式标记被翻译成Serlvet类中的write()或者print()方法括号中的代码
. c5 {* j, W( q5 F4 j
7 C7 Q+ H# h  ?/ t* w: l1 `! T

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

response 与送回浏览器的响应相关的HttpServletResponse对象
+ O8 T/ v& `( E6 g8 w: T% r8 M
out 与响应的输出流相关的JspWriter对象

3 T" G8 f+ J& U$ z    session 与给定用户请求会话相关的HttpSession对象，该变量只在JSP页面参
( v5 D' d: F6 y5 ^
# _2 P0 ^( |" s) k) C/ M与一个HTTP会话时有意义

    application 用于Web应用的ServletContext对象

config 与该JSP页面的servlet相关的ServletConfig对象
( s5 {  i5 Q% L& r2 r
+ t' t% \4 a# y4 J- epageContext 该对象封装了一个JSP页面请求的环境

. |7 L# z: `& |. m/ m0 ]page 该变量与Java编程语言中的this变量等价
" F+ A5 \9 J0 E0 i+ c9 V
    exception 由其它JSP页面抛出的Throwable对象，该变量只在”JSP错误页面”中可用



) ^/ T% l+ W* Y1 c: |page指令的功能，写法、并示例，并描述它的如下属性的功能和用法：import、session、buffer、errorPage、isErrorPage、ContentType、pageEncoding
! `" o0 |8 r1 z" a7 g* X+ fimport import 定义了一组servlet类定义必须导入的类和包，值是一个由

逗号分隔的完全类名或包的列表。
- n. Z; E) `4 O! y/ N8 R( R
session session 定义JSP页面是否参与HTTP会话，值可以为true（缺省）
) `/ Y# X: m% ]0 S$ ?* K
或false。
' S; b/ ]3 w- P' x- f2 j
6 M2 e3 q' F5 a  jbuffer buffer 定义用于输出流（JspWriter对象）的缓冲区大小，值可以为

, o) T+ W& E: T, ^! Wnone或Nkb，缺省为8KB或更大。

errorPage 用来指定由另一个jsp页面来处理所有该页面抛出的异常

+ K+ _7 i8 n  ?0 B9 b# ?3 ^isErrorPage 定义JSP页面为其它JSP页面errorPage属性的目标，值为true或

+ i- G1 M: ^; ^2 Xfalse（缺省）。
1 ^9 J* [& k# q/ v4 ~: b! u6 {
- d# k0 j7 U# x6 ?9 n) y. XContentType 定义输出流的MIME类型，缺省为text/html。
* q4 l" c0 r( [! l4 O
pageEncoding 定义输出流的字符编码，缺省为ISO-8859-1


0 w& b" p4 s* |9 E# S
描述MVC各部分的功能？MVC的优点？MVC的缺点？
MVC各部分的功能：

( I  Z) P! X' n+ h" C! ]Model（模型表示企业数据和业务逻辑）

5 p. A: T* O" R4 M封装应用状态

! k; D8 W7 U1 _5 e/ w响应状态查询
* Z! y8 Q0 L1 V1 H6 o4 g6 J2 J) i
暴露应用的功能
( G5 t  L7 S* a* z# ^
+ z1 N1 G, r1 c' S8 O% u* b: U; ?Controller（控制器接受用户的输入并调用模型和视图去完成用户的需求）
$ [  K7 ^% G# `+ \* J* e6 G" ^; c
/ x1 B: X3 t6 e- Q验证HTTP请求的数据
- ^. F; h/ p. }0 b* w
% T# `) s3 c# C8 r* m2 w( L6 L* c将用户数据与模型的更新相映射

$ o6 G% B# R2 l8 `. B! a; T3 O4 f选择用于响应的视图
, c( H+ i) B5 z7 n  J
0 J0 w/ e+ Z' qView（视图是用户看到并与之交互的界面）
, m. `8 N* }4 ^! A
  b$ \6 w; F- Q  ^/ j& ]产生HTML响应
1 n  t/ z& w5 `0 u  c
请求模型的更新
& Z1 \/ t$ U, L; ~  l
* a  y' w7 T$ ]+ L6 ~5 o7 i提供HTML form用于用户请求
% v# P# ~" f/ H
MVC的优点：

        低耦合性：视图层和业务层分离

/ R* R' z& z! A高重用性和可适用性

. h2 E8 s5 \, n较低的生命周期成本

快速的部署

+ `3 ^8 |7 F- y% C7 r/ L" n可维护性
' x/ Q: ]4 j( Q& @$ A$ H' M$ }+ {
( N( R! M) l5 i' T( c) I有利于软件工程化管理

提高软件的健壮性

" D" o2 \5 }% wMVC的缺点：

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



" q, s4 }; @& J4 _4 @什么是Model 1结构，以及结构中各部分的功能
) W! m! ?: b1 z1 ?8 B结构：jsp+javabean
, K9 g& t! m0 N" F# D8 r# D
4 M& J6 `  \% _/ M# V3 d$ BModel1中使用jsp来处理web应用中的视图控制部分
. w; K0 Z* _- @
Javabean收集参数
% M1 O9 e% r/ P+ ^1 Z1 o


/ M1 P0 p" p, {7 S' I# f什么是JavaBean?
用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。

6 w3 b+ D- Z: r: L+ y, a( H

JavaBean的规则？
使用get和set方法定义属性

一个无参构造方法

6 |( r& v0 Q) r9 ?  h, e无public实例变量( 所有属性私有化)
6 V" _  @- V. P( p1 K
4 Q7 d/ d' `3 y# E: y/ J

6 W, U3 `1 e8 L! Q3 E什么是jsp标准动作？包含那些？分别都是什么功能？如何使用？
) c& i( F9 e9 R  _+ sJSP页面中使用类似于XML的标记表示运行时的动作

: S1 ~. ^6 R+ Rjsp:useBean
0 Q3 m5 |+ K6 h& z4 k, [7 u0 i& q
jsp:setProperty
7 Z8 V/ }8 T$ ~, c6 h$ m- ?- J
jsp:getProperty

jsp:param

) [. u& ?2 _- C0 Y+ Bjsp:include

jsp:forward
% j4 y* V" A7 r( w& P7 J
+ u( n+ }; L* C* F8 V3 {
+ `. [# R) C6 z4 U' ^( @5 b, ]
7 |' r2 o. I0 [8 a用代码示例如下标准动作的使用：useBean、getProperty、setProperty
. o# [1 N: F9 p+ I<jsp:useBean

id=”myForms”

class=”com.base.mystruts.forms.MyActionForm” scope=”session” />
3 c4 p! T( t& Y
4 W; s, m/ p! L. z2 Q  Q5 t8 C& R    <jsp:setProperty name=”myForms” property=”name” />

<jsp:getProperty name=”myForms” property=”id” />
. o# F8 H; f/ u4 i


: ?2 w7 |6 F# P" g% m+ k描述说明Bean的四种scope
page
# W. h9 F" ?# o. X
request
1 o4 A+ @0 r8 W% }
" ^  k# [: h: X, bsession

application
( z/ y# T2 ^. r, Y
3 p6 Q3 a/ T- P0 u5 I. s

描述说明页面上的字段和Bean中属性的对应规则
* A* l. \! m! vid 指javabean的变量名

. G0 v! @. {1 Z; R# _6 P! v3 ]% dclass指javabean类的全路径
% Y: n% g- U' Y; g5 a* y: z
! a' ^/ [; e& {$ Oscope指javabean的应用范围

name指所用到的javabean的变量名
, O0 b. A  L4 Z2 Y# ~( `4 i. m
" U$ f: \2 G) A. A7 I    property指javabean中的属性


' x- u8 E4 n& ~, l9 k; h
- a) f$ k( L0 A$ P8 H4 U6 n描述useBean动作的处理过程
使用id声明变量
; I: a, z: p! S4 N
试图在指定的范围内查找对象

如果没找到
) Z7 U1 }& w7 K& U. m; k
- _: N8 o; E, ~* y" l% }创建一个类的实例

+ {7 W# |) W2 t& y: m7 T2 b执行useBean标记体初始化对象

如果找到

     将对象转换为类指定的类型



描述forward动作的功能
: {+ B& j4 n, d使用脚本代码处理请求时，可用jsp:forward 动作产生一个不同的视图，
% Z5 y+ Y* A6 e
: Y5 p, p4 N' K  Q使用同一个request：


% Y9 T: A/ j* U" o% d$ y
; l) n  V! B& }. r什么是Model 2结构，以及结构中各部分的功能
0 U$ q% P# U! v  tjsp+model+servlet
% s9 Y' ?& r0 j9 D, k
2 V- u  G- Z- q* mModel 2架构使用MVC模式，JSP页面充当视图，Servlet充当控制器
" [4 J- N" g. d
Servlet控制器：

2 }: n0 v( ]$ A* d) J! {. b* N! i验证HTML form数据
) n( l: M3 ]/ ?5 N$ H
: K1 e8 {# I( c调用模型中的业务服务

* O6 h# a- ]4 S1 @$ r$ T. S' ^存储请求（或会话）范围内的域对象
5 g% t1 K$ q+ ^. H
/ r# h  C* x) Q3 l7 S1 e选择下一个用户的视图

JSP页面视图：

! N+ Q/ c9 U/ O/ w, U) Z  c! b使用用户界面（在HTML中）

        访问域对象



( p. ?' g# G& t如何获得分发器？分发器的功能？
上下文对象中的分发器：

ServletContext context = this.getServletContext();
. H/ {3 e" l3 U1 y4 |
RequestDispatcher servlet = context.getNamedDispatcher(“MyServlet”);
: `$ C) G7 F% R) F
servlet.forward(request, response);
1 M. w9 T) ]: F
请求对象中的分发器：

6 a& k$ j: U+ |- g  i/ @) o7 PRequestDispatcher view = request.getRequestDispatcher(“tools/nails.jsp”);
( J& m& D4 L" L" t3 s) ?, ]
1 o2 h$ c+ m! D5 Z/ Aview.forward(request, response);
* `! X& D4 `2 y7 K+ [
, I1 c  W; I8 c: Q9 C可以将请求转发到另一个jsp页面，并保持请求的传递性


2 K1 K3 U3 Y( [, V
5 E: @; ~& O% Z4 ^( I, u3 ~Jsp中页面跳转的两种方式？
5 i4 |4 a4 q! U* j+ Y6 P使用分发器跳转页面
2 D' u* }, d7 I5 f; q3 `3 A% _1 qRequestDispatcher dispatcher = request.getRequestDispatcher(“url”);

3 t+ n: E, U" ]0 c  Adispatcher.forword(request);
. n9 H. P$ ?" M& }& K! o. h
    特点：保持请求的传递（上一次请求中的数据，在下一个请求中仍然可以得到）；
, u. e$ @* {* |% h: \/ M
5 H3 S- O; I, D  S, o        转发的页面只能是同一个Web应用程序的其他Web组件

使用重定向跳转页面
response.sendRedirect(“url”);
, p( Z5 A: D- C- T. m. z# }0 O9 E# [
    特点：产生全新的请求，（上一次请求中的数据，在下一个请求中不能得到）；

        重新定向的页面可以是任意的URL
* W/ \, c" f5 ^/ i' w6 W


1 x$ _0 J& A* J" o: k描述Jsp中引入另外页面的两种方法，并比较两种方法的特点？
; k, w0 _3 O3 I7 v' F2 x  q5 h<%@ include file=””%> 在编译期间把另一个页面完全嵌入这个页面,可以说是一个页面
3 m7 B) L# G+ O' d! h5 P
在这里可以共享变量
) p! {; _7 c- N1 u7 V( @* W& p7 W
4 @' Q. x4 J. s6 Q$ w9 Y. @<jsp:include page=””> 动态的再运行期间把另一个页面加入这个页面,可以说是两个
$ u& H3 F0 L6 _& P- u
页面，不可以共享变量



, D3 [' [; F8 c' w, i什么是自定义标记
. M" B, \) S* l9 z0 l. q9 r( M0 Q/ c自定义标记库是一个Web组件，

* X! S$ F) Y/ _3 T1 a$ e: d2 O包括：

" i+ R8 [) C* K' F8 V7 B一个标记库描述符文件（*.tld）
; u/ d$ d1 ^8 u5 ?0 ^
所有相关的标记处理器类(*.jar)

7 m* B/ m1 Y/ Z4 N6 Z

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

把.jar文件放到WEB-INF的lib里面。
把.tld文件放到WEB-INF根目录下。
  S# R! Y8 k9 Y/ k% M6 f在web.xml中配置。
<taglib>

<taglib-uri>http://java.sun.com/jsp/jstl/core</taglib-uri>
% v3 R" r$ O; l
     <taglib-location>/WEB-INF/c.tld</taglib-location>
/ c' ?3 J5 @8 ?0 F2 s6 a% }& M0 {
( t* a, f$ O/ |( n) U- Y, @6 B: b, ^</taglib>

在页面中引用。
) O+ a* F- c% A8 L<%@ taglib uri=“http://java.sun.com/jsp/jstl/core” prefix=“s”%>

uri必须与web.xml中的uri对应
8 Y1 m0 C) N2 {/ w
prefix是前缀，用来区分是哪一个taglib

( \" t8 O, r- d使用标记
格式：<prefix:tag名称 属性>

<s:forEach >

admin

在tomcat下配置数据源
3 q% o. P7 ^7 v2 t5 `1、服务器与数据库的连接
$ j; R( L4 w/ G% p
配置server.xml文件

1.oracle
$ ^8 ^9 P% f# k3 Z% |1 H
" S- g# U$ T% a6 |8 _; }6 L<Resource name=”jdbc/company” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”

% N. ]8 d& W. `# n* }                        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”
. g% w- v, E8 _, C! t
" j& p7 \* i0 I7 qurl=”jdbcracle:thin127.0.0.1:1521rcl”

; Q. G8 m: R$ E0 ]+ [0 NdriverClassName=”oracle.jdbc.driver.OracleDriver”

username=”aa”

password=”aa”

% }6 X9 [3 R5 y6 S9 Z1 H+ }maxActive=”50″
" r; O; z  j* s/ x, \, J; ^
8 [: t+ u- Q- `+ tmaxIdle=”10″

maxWait=”-1″
3 t+ R. q9 G+ x4 y9 o3 N
. {7 y( W9 [2 g2 {; v/>
' U, q: b6 O3 Q) x% o- Q
4 G6 q1 a2 j5 q/ }" ]6 @& n2.sqlserver
1 o$ j5 s: j  I) N  ]' t* @
3 c/ D$ e8 T. `8 g* G/ Q8 R<Resource name=”jdbc/webpage” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”
' @) c" P8 r7 k2 e& G/ Z  c% K3 k
, X3 s, }- n  K3 ^7 ]        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”
8 T9 k8 \3 J  Q" D
. w3 [+ S; ?  [) D* b* Xurl=”jdbc:jtds:sqlserver://localhost:1433;SelectMethod=cursor;

* q8 l' F- f6 O+ {& ?$ F& yDatabaseName=webpagetest”

* ~- v3 X, T0 J5 m3 y+ O2 qdriverClassName=”net.sourceforge.jtds.jdbc.Driver”
  ?  U- [- Y8 w5 k$ ?  g7 [$ b, x1 E
username=”aa”
% Q/ {; _  n# v. E
password=”aa”

maxActive=”50″

maxIdle=”10″

; v1 Q. u6 u$ ZmaxWait=”-1″
4 Z7 V, M& @9 ?3 @) @+ _" D! C
# t" V* A* c' M9 X' C* f/>

2、配置自己的web应用的xml文件

! S5 m/ V5 V8 X4 ?6 N; E

<Context path=”/eb03web” docBase=”F:/workweb/eb03web”
$ c$ e0 z, p9 n  ?
privileged=”true” antiResourceLocking=”false” antiJARLocking=”false”>

8 o' y! M0 `$ T8 V1 i<ResourceLink global=”jdbc/company” name=”jdbc/company” type=”javax.sql.DataSource”/>

2 c0 l& D5 t+ s. r. t</Context>
( O# J! ^. C- s" M: W% w$ s0 @
  _( A  r/ k8 {, _5 m

3、配置web.xml文件

3 q0 \8 a" E6 o9 J+ t& l, g, `与服务器建立连接

<resource-ref>
% d+ }) K9 m$ L% J5 B
9 n& b8 @+ P+ x* G<res-ref-name>jdbc/company</res-ref-name>
) q6 N' n6 s1 m
<res-type>javax.sql.DataSource</res-type>

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

</resource-ref>

4、在应用程序中不直接与数据库连接，通过DataSource连接池建立连接
, n0 O# @  S& u+ |9 n' P
1 Y9 Z) \. Y) s0 E7 k; E//1.在程序单独用时设置系统的属性，在tomcat下可以不用配置，
& F4 o( b4 M  J+ x% c5 f
7 W% i1 p% J  A4 A7 f$ ~6 FSystem.setProperty(Context.PROVIDER_URL,””);
1 C# p) [8 j" u# y
( I+ Q7 Y; P; YSystem.setProperty(Context.INITIAL_CONTEXT_FACTORY,””);
2 N# `7 L9 i. j
//2.创建一个上下文对象

InitialContext context = new InitialContext();
# J9 O9 s* b) U; K1 q, B
. @$ U, @8 Z3 ?1 p  k//3.通过上下文对象在连接池中查找DataSource
5 ]# H5 U/ p2 [7 ]- \
* {- L$ k* n; \! \" yDataSource ds = (DataSource)context.lookUp(“java:comp/env/jdbc/company”);

//4.通过数据源建立连接

. f. c* f# u* E% E2 q2 _$ jds.getConnection();

admin

ORM对象关系型数据库映射
(Object Relation Mapping)
8 t' W, n0 j; S2 b
/ D6 g6 S4 _9 ~; f' Y一、映射的特点
/ U0 u  ~7 p) f' |; y, B) U
1.一个对象可以对应多个表
9 w. [  M$ N7 z
2.一个表可以对应多个对象
1 p  K# y8 c4 l' ^
) h) ?! d% C8 E5 p3.对象和表的关系不用完全对应
; {  r% a; i7 o# v8 F, l
4.对象的属性的名称和表字段的名称可以不同
; a# S* s' B0 [+ j+ |2 a
( ^* k9 N, x8 ?- r+ g, a5.类型可以不同，但数据类型之间可以转换

. Y$ X2 w/ W# }6.对象中必须有主键，数据库的表对主键无所谓

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


4 L, r( D- X9 O) q& O
! I; \3 e2 ^! r% H8 a/ q" H( ~+ ~" r9 d二 、有一个映射的描述文件————>xml
3 `  [# ]; d3 f; F
三 、怎样实现描述文件————>一段程序
0 Y! I6 B- H0 u
对象 映射（mapping） 数据库
5 S; T/ k" ]1 H  f
user
) o: N) s/ n  c
3 r/ J$ v% h( c. E; g9 [. zid=11

name=”张三”———— > (1) —————> tbl_user(id,name,age,tel,address)
2 g* ?' x7 s' R6 S3 L% D- |# N  {
age=25 <————(2) <————
( D; Y* r0 u+ ~


(1)从对象映射到数据库
7 F- ?2 e$ V8 c& }3 J  x
( m% H: R4 z! L& m8 c3 i1.JDBC
- t- J# X6 G9 W& H
2.根据描述文件来动态拼接sql

3.执行，添加到数据库中



3 p  F. S- h, N! t# P( I(2)从数据库中映射到对象

1.JDBC
0 J, e, \6 r( P9 l8 W' g& G: v
. q# U6 a& o, m0 r2.拼接查询sql

3.ResultSet
. m6 V, W- D/ Q. {
4.Model

" W, |9 t1 P- t2 [% }

5 J4 c! O9 x8 X4 h& Q8 d5 J+ Dhibernate
开发流程：
( a' b( x# a" _$ ]
是什么？
hibernate是一种基于orm 的轻量级的框架
; y* U2 B5 |" s$ s7 s. P9 Z
8 o9 B0 ~4 t" ?  ^0 ?0 x' B
6 l, ]0 s  M6 |9 I# k, ^+ f
有什么？
) B: C. I+ z: m" ]1 V' o1. session 保持连接状态（依赖事务和连接池）
- T4 U' f* ]  t* J  j. A
2. Transaction事务

- o% _- l! ?( P# k6 e. `! k* M3.
Connection Provider 连接池

7 }( ~" e) S4 [
! ^! V2 ^# o) j. V" D; ]
能干什么？
) V# ^+ i4 R5 u, N) J1.orm

8 h8 U, b8 X/ Q2.提供操作数据库的接口，简化数据持久化的编程任务



怎么做？
! o, L; B5 q" a4 C+ T, M9 r/ M" w$ |1.搭建hibernate的运行环境，将hibernate的包和hibernate所需要的包拷贝到lib 文件夹下
; F- Q, b% @/ F" g! C9 H+ B/ o
2.O（vo）

3.R （关系型数据库中的表）
, y% N8 v- ~( {+ K! {* g
4.配置文件

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

a.与数据库的连接

b.可选配置
1 O3 m5 w- z# [% E0 x
c.映射资源的注册

4.2 hbm.xml文件 名字与类名相同 并且与类放在一起

/ h$ }6 J6 D5 d. f6 z2 Q4 Ea. 对象与数据库表之间的映射
: i3 x* m- B. f6 V- j. d& b
5 G3 U( V8 y3 J6 V* Fb. 对象的属性与数据库表的字段之间的映射
7 M7 d) j* {& S* B0 E+ V8 Q$ L; M
c.组件之间的映射
0 }, ]" t; U, A
d.对象与对象之间的关系映射
  d& D: v1 S% H/ e1 h0 z" H
5、客户端
; D* k6 G" O1 Y# H
1.得到SessionFactory

2.通过SessionFactory 工厂来创建Session实例
8 C/ W. `& g  x
3.打开事务

4.操作数据库
' d, s, x* k( b1 U5 L. p/ S
  w, M) L% O2 O$ i+ R5.事务提交

9 _- Z+ b$ ]  b( g+ H6.关闭连接
0 A1 z$ v! N8 c
/ g  p; \. n( v( b. r2 b1 }" ~运行流程：

( s8 P6 K+ z9 s' ^* u/ U整体流程
8 r( n# V4 H& r/ \8 l' D1.通过configuration来读cfg.xml文件
$ p1 j% {' `! S' ^6 \
; D6 @3 l" D! m+ ]7 p2.得到SessionFactory 工厂（根据数据库的连接来创建sessionfactory）
+ P6 {, |2 [% Z0 |" Z! ?; U, ]3 U
7 Q0 W8 L- A7 S/ U! ~3.通过SessionFactory 工厂来创建Session实例

4.打开事务

5.通过session的api操作数据库

6.事务提交
5 z4 n$ A& C' G) f8 r. O2 t+ v' Y
: V3 g  o7 u9 _4 m2 v% z$ f, z7.关闭连接



save
2 ?/ `# j2 `" k  D% `0 S% a1.to—>po
1 H- A2 \2 @; \% {! L* L
4 _0 a: h  J+ Q$ ~* T! `2.根据model和cfg.xml中映射文件的注册来找到hbm.xml文件
; y8 b2 W7 l) g# O3 Y* s. J; o! F  X- y
. d0 k+ d( T+ h( L3 u3.根据hbm.xml文件和model来动态的拼sql

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

5.执行sql，值放到数据库
% u3 g% \$ H! e* m# K# S  X  I
/ `( r8 t+ E: z0 G/ G

2 [* U6 M5 G* R4 N0 a* P/ A/ Iupdate、delete
, K) z& p1 Y! B1.根据model 的id在内存hibernate的缓存中查找该对象
8 U8 w* Z7 ]! X' R1 L% j, c
. V2 M2 w% u) H. _. F如果内存中没有就到数据库中查找来保证对象的存在
7 _2 ~; b0 f( G$ l) D
2.根据model和cfg.xml文件中映射文件的注册来找到hbm.xml文件

+ Q7 E' H2 {$ t& m: |3.根据model和hbm.xml 文件来动态拼sql
# V0 [  H2 l. y) ?, ~" V  }. h
4.客户端提交或者刷新内存

5.执行sql

, N, a7 K# l3 z' j. ?5 b9 d# d

Query
load

5 W1 h8 F1 W4 o- D! ^9 T& z2 Q( P1.根据model的类型来找到hbm.xml文件
/ q  q  q; a$ h7 _
2.判断id对应的对象在缓存中是否存在，如果存在，就直接使用，如果不存在就进行下一步。
6 v6 ~6 Z! `5 j. U7 w' r9 ]
) P0 b9 B$ {4 B3 t0 X0 ^3.用id做为查询条件来动态拼sql
* f3 R2 M0 v; ~8 m/ ^) z
4.执行sql 查询（先在内存中查找，如果没有找到（会抛出例外），就去数据库中查找）
7 q- \) C6 E3 E
5.返回一个model类型的对象

get
/ h" S& w9 P4 }8 i7 p- p3 l2 p  s
    1.根据model的类型来找到hbm.xml文件
) l; M/ K& P4 |( [. J
" g6 d* t/ o3 B0 N2 t3 }2.用id做为查询条件来动态拼sql
2 H" X7 Q8 [5 d
  a. J9 C5 o+ H- f3.执行sql 直接在数据库中查找，如果没有查到就会返回null
9 r8 F# {9 V; X1 z( k4 X
query

1.分析hql语句，得到model的类型

2.根据moedel和cfg.xml文件中映射文件的注册找到hbm.xml文件
$ ]! k3 E1 Z% I( Y/ @9 V
- G% ^- _: C4 `2 A6 N3.根据model和hbm.xml文件来动态拼sql
, T" J. W# J  b) r' c
4.执行sql查询数据库
' Z& E) }$ j! L
* q8 ^' s" g$ S, T5.返回一个resultset

6.循环resultset的值，放到model中在放到集合（List）中


/ Z% I4 j+ T- q& }: p% k: s9 ^
- u: d8 ?/ C2 K3 w, l8 h谈谈hibernate缓存机制
! G! A9 m* I+ Y4 }/ R! [+ l3 O
缓存其实很直观的理解为放到内存或者硬盘上的一块区域，缓存就是一个缓冲的作用，有很多时候，我们的数据需要经常访问，如果放到数据库中，不是不可，只是效率上低，如果有了中间产物来代替数据库，就省很多事情了。打个比方，去买酱油，不一定一定要去酱油的生产工厂去买。代码中需要数据的时候，可以先到缓存中查找，如果存在，就直接拿数据，不存在就去数据库中取，也省了很多事。



( Q" Q" Y" g/ k" H/ c. r+ Qhibernate使用的是二级缓存，有两个级别，分别是Session，SessionFactroy级别，一级缓存是Session级别的缓存，Hiberante来管理的，这个我们一般不用管，二级缓存是SessionFactory级别的，可以进行配置和更改，加载卸载，就是我们平时用的hibernate配置文件中的配置SessionFactory的属性。
# Z) V9 u0 l, _* @* U* r5 l  Q& B" x( i2 b
2 p  e! }0 X. h0 M1 r/ X. v: d
. ?8 k! P! B2 x) P% N
对一级缓存中的session事务进行数据的预存取，数据在各个session的上下文中存在（单例），当session关闭时，就是session.close( )，整个所有session范围内的数据全部清空；二级缓存默认的情况下是不开启的，如果开启，数据库汇总的所有数据都先copy到二级缓存中，这里要注意的是，一级缓存是每个线程下创建的session缓存区域，可以是多个，二级缓存只有一个区域 ，画个图比较容易理解。

. d( i6 T. G- @0 B0 d/ K

: Z* z/ r% k- ~1 H( `* F| 一级session缓存| | 一级session缓存| |一级session缓存| |一级session缓存|

! ~5 t' z. a7 u| | | |

| | | |
9 X* w" \* }  ^/ U  K1 G$ d. F7 d6 Z
—————————————————————————————————
7 g3 S8 a. I7 V- r3 E9 H3 G$ B
0 E- K3 A, l2 j0 A5 R& e4 _sessionFactroy级别的二级缓存
- {% t5 D% E2 V6 v: G2 r
# J9 O* ~" ?& {+ Z! v——————————————————————————————————————-
7 {6 u+ B6 Y) M2 K) Q4 l, y
|
+ B( U' b$ C9 O; V
|

|
* C% U  @1 y' J0 b4 V% U
/ I+ d$ \) \" w( C# W——————————————————————————————————————
8 |; o0 f5 [9 x9 L
# N7 w, W1 P2 H. t6 d$ nDB
7 _; \* D) a, x
) Q: e$ l% u3 N: i—————————————————————————————————————–
* Z% W# f% u+ @1 W. l/ R! s
( S; N7 \" a" V4 X

admin

Spring
* {) j. y$ R$ R. I9 D; N! z

• 是什么？
  
  ; m# b. [8 x3 x: S6 B

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

" I8 a( |1 v, E/ N! q2 N4 J3 @

• 有什么？
  
  1 _. v$ b% c: C9 T3 X. q

% R$ d5 u+ z' d& g. r

每个包的功能：

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

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

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

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

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

AOP ：面向切面编成

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

• 能干什么？
  
  

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

• 怎么用？
  
  
  • 搭建web工程，引入spring的jar包
    + C( v* V6 y& T- ]
  • 在web.xml中添加如下配置
    % B; B; w" Z9 u6 B, k
    
  
  ( y& O+ u$ @$ ^& ~& Y  j. O6 e
  2 i" y4 K% N4 T: Q

            contextConfigLocation

            classpath*:applicationContext*.xml

   

        
" m; p. D, H- u2 M

            struts2
. ?( q. _9 T8 {6 y! ?8 K

            
+ u. e) n1 Y% M$ P: l

                org.apache.struts2.dispatcher.FilterDispatcher
0 Z* _/ ]! I9 x# [5 s* J7 O' L

            
6 ^9 d, N5 J) `3 C7 J  P, R+ c

        
* V' B, q5 H! H

        
" f% Z  @, i( m4 O  Y

            struts2

            /*

( J" s2 t& x/ b2 n$ n

1 s- `) q7 W: t$ P. r, g1 y

            

                org.springframework.web.context.ContextLoaderListener
" G4 l( T* P3 Q! ]( |9 |. {

            
1 o5 [$ R& z. `9 \, `

        

• 部署
  
  2 v% B/ C4 r* @* X. g

! u7 `* y0 y/ ?* g6 s7 W
2 p! |  B* ^& C) p( W1 p5 Q
1 v/ Q, Z  H4 O5 w$ B/ @7 V6 x, z% Z

• 容器和bean
  2 D: Y: J" V6 b" e/ a' q; v

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

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

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

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

7 W: p  s7 j7 {8 W6 E2 r: ]. p: Q( Z! m

• IOC控制反转
  9 }) C; I4 E2 h* P) i
  
  
  9 y0 M: f+ }7 o/ T
  
  从前的应用程序想要得到A的实例他会直接主动的去拿，当用了sping后，应用程序由主动的去取变成被动的等待，由spring来控制应用程序所需要的对象
  
  
  • IOC的优点
    . J  `" Q$ V/ K" z
  1.可以通过IOC来获得实例
  2.可以通过DI来获取注入的资源
  • 配置IOC的原则
    
    • 一定是可变的资源才采用依赖注入
    • 一定是层间的接口或者是模块之间的相互调用才采用依赖注入
      

• DI依赖注入
  * i  b5 ]: ~8 G; d: [8 \3 h  Y

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

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

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

例如：

在配置文件中

& J& Y' ~' @* v; Q. b+ V
1 S/ e6 w  a3 W, u

在应用程序中

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面向切面编程
  ' U" z1 q! ?9 z/ `& o
  6 y3 U0 R# I' E& Y

1.AOP面向切面编程 一些较好的模式或者是示例—-范式
9 N* y$ G' X+ }, _6 i% @% `

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

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

3.AOP 的概念

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

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

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

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

5.引入 ：扩展的功能

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

7.aop代理 ：实现机制

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

4.AOP的事件机制
" i( a0 K: R- N. d) [8 O+ b

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

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

3.找到切入点

4.确定连接点

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

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

! U1 s1 ^" a* `  N9 `5 ?; l; E5 s
' R. }" v2 h  P9 G+ C! B  ^
. t0 i) G- O4 B8 }% t* \" h' m- Z
! a& h- G9 e& Q7 e/ H


7 I* O% J5 z1 S6 m$ r0 h: e

5. AspectJ
1 j9 q% N! v. w% d% B7 A

5.1.在xml中配置比较烦琐
# e0 p) D1 N; P+ L; g

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

$ |% \0 N1 o: t' G, q

         
+ H$ P2 X- I$ H( n

; [" G% F5 L2 e5 F+ u: f; _         
: W, Y9 L0 i( I

        
! b% L$ C: p0 r" B) o

        

* ^7 F' N8 K* jexpression=“execution(* com.javakc.aop.MyTarget.t*())”/>

        
. J! m9 l8 h1 i& p* n5 U3 }( B/ f

        
. K$ Y& V4 Z5 M. {7 b8 f6 Y

   

* k  g7 N0 [5 M; p: l6 Q8 ~) x

5.3.使用注解的方法相对简单
: r) d. y5 D2 i  s6 _1 G# n, j- ^

@AspectJ的基本语法
0 t& t- o9 c. ?/ i# y# l9 t

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

直接在类上定义@Aspect

2.@Pointcut声明切入点

2.1、用一个专门的类来定义pointcut，类中的方法名就是该pointcut的名字
/ ?7 N' w$ \* j2 C1 P7 S

2.2、可以使用匿名的pointcut

2.3、执行切点的几种方法

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

2.3.2 within 指定到包，不能指定到类
, T% L- F  b3 n0 W+ i1 L

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

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

2.3.4 target 指定具体的实现类
9 k& x! Z  v0 a5 S( D

5.4.advice的五种类型的示例
5 [! ?2 N+ }$ m# i+ E

　　　 客户端必须从接口走才能得到监控，实现想要追加的功能
1 D8 r  A: \  w$ o) p6 |5 q

5.4.1.@AfterReturning(pointcut=”” returning=”retVal”)
2 M1 V" C, [: a8 t! l9 v+ W

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

在注解@AfterReturning中必须加上pointcut和returning两个参数
+ k3 B- O# ~) L( L1 k

pointcut指所要监控的目标对象的方法
# s% @4 U% `1 S# b

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

完成追加的功能
8 i3 u/ F& e, G

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
3 E4 e3 x+ R  d* r

(1).@AfterReturning(“com.javakc.spring.schemaaop.TestPointcut.t4()”)
* T1 A5 `4 D9 S: N* t& ?

(2).
* O1 u3 c/ C6 H) R

     2.直接引用匿名的pointcut
' F! g; b; A1 K- ?. k9 \

     (1).@AfterReturning(“execution(

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

     (2).@AfterReturning(pointcut=
: N* ]% W) S3 _. u5 c( r# t4 X

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

args(str)”, returning=”retVal”)
. L+ q0 E" ?" Z5 C" x) M

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

public void testAfterReturning(String str,Object retVal){
$ n9 D# a" S' Q$ j5 E

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

    }
7 A( I2 n3 I* E: U( L

5.4.2.@Aronud
$ J" {- Z# |( L" w3 Y

     注解@Around环绕追加功能；

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

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

     通过ProceedingJoinPoint的实例的proceed来调用所监控的
' U; Q. ^& l2 _, C+ _" l5 |

目标对象的方法

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

     (1).@Around(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
3 W. o- m' b1 B( e' c

     (2).@Around(“com.javakc.spring.schemaaop.TestPointcut.t2()
% e0 K8 e+ N+ _, `1 a

&& args(str)”)

2.直接引用匿名的pointcut

     (1).@Around(“execution(
9 U. U4 v, _8 p; J. F

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

     (2).@Around(“execution(
: \: {0 w9 j$ n# p

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

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

     @Around(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
  q# `) V1 B, V9 A; `

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

    System.out.println(“around1==========before1pointcut==>”+str)
7 ?' l$ m- K6 J, m

        Object obj = prj.proceed();

        System.out.println(“around1==========after1pointcut==>”+str);
# ~# i. Q6 u0 ~& i3 U9 W

    }

5.4.3.@Before
' Z! W! W. q  x# z$ D' m3 g

注解@Before在执行目标对象的方法前追加相应的功能
5 p! V  }/ U1 `, y! o2 p: m( e- C

1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
/ F! h0 y; p8 x# W! q2 g( j

(1).@Before(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
5 X, S$ o, z- r! g

(2).@Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
$ G- n5 \4 n" a4 Z! g/ ^

注意args后的名称与参数名相同
# A- W2 [( ?. S) L

2.直接引用匿名的pointcut
! G6 L* O: n- }/ K- ?# o

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

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

注意args后的名称与参数名相同
4 m3 y6 H  I8 ^7 _$ b; r( _  W

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

@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
, t% j2 r5 v7 m/ i# L

public void testBeforeParam(String str){
% ~( F' r# |1 J. B

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

}

" \6 F" S/ z7 J2 M

5.4.4.@After

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

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

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

     2.直接引用匿名的pointcut
4 t+ l. h, @" P- z& P7 G6 {

     (1).@After(“execution(* com.javakc.spring.schemaaop.Api.test1())”)
* @+ W  H& j" X% l- z

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

    public void testAfter(){
2 {/ \6 Q1 t3 _( l" A6 F

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

    }

5.4.5.@AfterThorwing
8 Y  ]  ~6 t% @8 F

: |% m4 y. f2 y9 Y$ E2 }; i

• 描述一下spring中BeanFactory和ApplicationContext的差别
  
  

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

3 Q1 d9 [! e% g

• 谈谈spring对DAO的支持
  
  

Spring提供的DAO(数据访问对象)支持主要的目的是便于以标准的方式使用不同的数据访问技术。
2 \% }) u% x! `( S

简化 DAO 组件的开发。
8 e* o, a/ Y5 p9 o& TSpring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法，用来简化代码开发。
- m: O. b# ?; g6 }

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

面向接口编程及 DAO 模式的使用，提高了系统组件之间的解耦，降低了系统重构的成本。
+ `( N6 e6 v4 O" E) Y

方便的事务管理: Spring的声明式事务管理力度是方法级。
6 g1 L8 A5 S1 U4 C$ V

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

- K) G7 g8 q- j" ~# R: f2 w

• 谈谈spring对hibernate的支持
  , o0 V8 Z$ z1 F$ W
  

在所有的 ORM 框架中， Sping 对 Hibernate 的支持最好。如 SessionFactory 的注入、HibernateTemplate 的简化操作及 DAO 支持等。另外， Spring 还提供了统一的异常体系及声明式事务管理等。
# R% T7 _8 u5 H' a$ U; R

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

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

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

        

            oracle.jdbc.driver.OracleDriver

        
( ~' A4 ~6 H0 W& `4 @$ t& V

        

            jdbcracle:thinlocalhost:1521rcl
* r( e( f4 I' \2 b

        

        

            javakc2
! J/ Z& G3 d* |. ?

        
( @' ?: ~) p/ M3 B  n

        
4 G& N( v( k. N9 h

            javakc2
3 Q5 ^; L6 b, ~/ |. U9 f* i7 p/ {- \

        
4 M$ t$ \9 L  B/ m3 }

   
! i* D) I  A9 J; @. p' O3 S

   

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

        

        
7 U1 O) h- q7 E; P# L. v% G

            

                com/javakc/spring/h3/UserModel.hbm.xml
/ u, ?7 }2 e' J9 Y

            
% z$ [6 y+ n$ V$ n7 t8 ]

        

        
) a: w# D! y- k. z3 d' w# }

            

                hibernate.dialect=org.hibernate.dialect.OracleDialect

            

        

   

   

        
: W+ ~$ y7 p* K8 r( t

   
/ R5 m8 c7 R/ n( l  F# B2 I7 r, ?

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

   

        class=“org.springframework.jndi.JndiObjectFactoryBean”>
8 P& W% _9 d: Q( w+ q

        

            java:comp/env/jdbc/myds

        

   

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

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

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

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

   

        
2 B' x* y+ h  {7 z) I. h) w9 [0 _1 \

   

0 `& l4 C3 {# q0 S& O, J" O; H! E: [

   
- O8 ~4 b* u+ O% r( r

        
- p& Y" p0 B+ f7 L- ?- V5 e( [

            
9 X5 ]/ D8 g3 U: e; o, ]: L

        
4 _7 [# H3 T' H5 B5 m1 ]; G

   

   
3 J8 H2 [- J9 d1 ~! Y( @' X7 X& t

        

        

   
. s' D1 H% q0 q+ N( B

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

Spring2.0之前事务的写法 6 N% |. u% A& {, \4 }% \% K ' d. ?) f) E3 m: I& x8 z" |5 X# z   u* ?1 e( ^& U- L        class=”org.springframework.transaction.interceptor.TransactionProxyFactoryBean” ) i2 y; E; B6 H! |$ Q" u. `$ T& O - d* c) S! K4 G        abstract=”true”> 2 w. d6 `3 N0 `5 f( `                PROPAGATION_REQUIRED,readOnly                 PROPAGATION_REQUIRED 0 g: s4 @, }. i9 l, |4 Z $ e# T& ^' y, ~% W$ F" b: |

* h  S4 B2 p( q  y

• 谈谈Spring对事务的支持
  5 x" n  v: v, u: ^  s/ `6 |' P
  

1、声明式事务管理：

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

2.做法：

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

2.2

2.3 注入数据源

0 j- u6 J( m0 P" ^) `$ z
! x# a% K* r7 v6 h% l/ t! H/ k% ?2 ^. g

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

& U% E) d& Z/ W7 z+ [- X
) a: j3 q2 W" O8 x& t6 r8 D2 m! h

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

( ?! q: L! D9 |! Y% ~/ t# U% l


5 K; t+ n: ?* m9 b3 w, u
4 [& L! O* D* ^& O% B

2.6 定义切入点

1 h3 a7 [) J, E5 ^
& F6 g" ]# Q2 H6 W  w# g+ [; ]

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

1.注解@Transcational

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

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

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

, l) n- I$ i0 D& J& X

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

, z0 `5 w# Y' C& d; t2 R- b

0 E# M; X  ?2 w" N$ @9 p$ E( k

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

admin

事务
& u8 h5 p: o1 F$ u. j4 |- D( DACID
; P- g/ S; R5 K0 b' H* k' A0 A% W（1）原子性（A）：一系列的操作具有不可分割性，要么成功，要么失败

7 I/ h( d' e! y! d1 y$ t（2）一致性 ：操作的前后满足同样的规则，保持平衡。

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

& a- J" S$ I' N( i（4）稳定性 ：保证数据在事务的操作的过程中不会遭到破坏，而且是永久性存储的



/ j$ }( R+ c+ Z" C事务模型
（1）经典事务模型又叫平面事务模型（JDBC） 事务不允许嵌套
) A. \# l( T7 p9 l5 p' U
（2）嵌套事务模型
- J: g+ J9 K* ?. Y# w6 p

$ s/ j" u+ T* j' g
' W/ s/ U& O0 b& d& l9 \事务的两种方式
（1）声明式
8 v8 {& L# h" s
# {5 C0 y4 |* Q9 t# b* W2 I2 S在配置文件中设置以下6项
% L' c; E9 O" `- Z% r4 [
（１）.required

如果客户端没有事务　在bean中新起一个事务
3 i" W$ F$ r  p" T7 u( K
如果客户端有事务bean 中就加进去

8 A4 y) z" V( c3 s" k2 Y(2)、 requiresNew
5 P  `- I3 @) H6 F, m/ c3 Y) w
不管客户端有没有事务服务器段都新起一个事务

4 x# S6 Z" \9 ~, C7 `# M如果客户端有事务就将事务挂起
  m% Q0 h; {! d+ j
(3)、supports

# B! u! e& K) J) p; y! d如果客户端没有事务服务端也没有事务
$ F6 A* F# D1 X& I. {8 |$ A7 b
如果客户端有事务服务端就加一个事务
7 q5 _8 o' g! n  @- |
+ M9 ~, A  ^, a% U: Q(4)、mandatcry

如果客户端没有事务服务端就会报错
7 }3 V7 r6 N7 j  U# N+ t( `; n" U5 H
, s" g! o1 \: v如果客户端有事务服务端就加事务
' I8 ]/ @" f( j8 c) Q5 d( |! [
(5)、notSupported

不管客户端有没有事务服务端都没有事务

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

) o8 @9 o: ]3 ~) ^1 J& O! L1 W9 V(6)、never

' _! K  T. ~! u) Y1 k1 R不管客户端有没有事务服务端都没有事务

1 t2 B% w7 ?2 f: |如果客户端有事务就报错
; [6 `$ E- v6 x5 c
" c; y, H; O- c/ ^6 p) [: H（2）编程式事务

9 w1 A1 E9 l6 O* D6 R# ^Javax.transaction.UserTranscation
, n- [' G: w# ]! E# s# F
JTA 事务可以精确到事务的开始和结束
4 K8 w4 V, S& J3 M/ {8 C2 C
) u  @( |% c8 ~/ M$ }( o
( k- _0 A  m- Z+ W: W9 Y- m5 B
事务的隔离性
Read-uncommited

8 t% J! n7 g+ u. {读取未提交的数据（基本上没有锁）脏读，存在不当读取的问题。

7 \% w: e! G9 Z3 d  f6 s$ B" [Read-commited

# @7 P8 }% x; t) f读取已提交的数据（行级锁）
7 w2 ?+ i/ K6 R. `3 G5 c
无法读取已经写入，但没有被提交的数据。

5 F) |* ^! @- o! r4 B+ q7 Z" e( JRepeatable_read

: z% a" d( f. r+ Q8 x读取的数据不允许修改或删除
3 Y" ~" `& S! j# {% |* x
不可重复读（行级锁+不允许修改/删除）
, y* j& _7 a6 g, U: B# l2 _6 K( ^8 o
* `- ?- X0 w! l6 M0 CSerializable
4 `( h. w, m% o/ H6 D7 _2 F$ U
( f4 T  ^% x4 `9 Z幻影读（表级锁）
7 u, W! p2 G/ q& K- B+ |: [
8 m" d' Q* a+ u1 }. a* \" G  ~

: x8 j% u- ], n0 q' f) {struts
" C( ?1 C3 W* {* w9 G$ T开发流程
# j& h7 r) p- e" D9 i7 U
0 v- N8 J1 a- N5 |1 K6 x! S1、创建表单
  W. N6 |+ [9 s4 D( B, N. m: b
: l3 f& U1 v) i/ U1 w7 {- ]3 [. I2、从表单中获得输入
8 Q0 A) h2 }4 L
% c% @% H' {1 Q3 z5 k$ c# ?" d3、处理输入（业务逻辑）

. d: P, y2 T2 D. K; ?$ _% ~2 n4、根据动态输入改变输入流

要完成上述四步，我们需要创建
7 J( Z! k6 l; ?- \' H
7 ]' ]- B' Z2 q7 C, i* B1、一个ActionForm

* i+ u0 M+ g5 Z' L) }' h2、一个action
' h- _$ E, z, Y- b, O
3、一个配置文件struts-config.xml
; K. ~/ l! b  ]' J2 A( s! _3 V
4、创建页面

创建ActionForm
- w8 ~, L& `$ n6 y, @
8 t" k3 U0 O9 g1 ^1、写一个类继承ActionForm
" ^# `$ ~1 j) x2 r6 U% S
% a" Z; c! |* q% {! I4 T( B" G2、私有的属性

. n" v6 Z4 }) t( D  T& l3、相应的get、set方法
8 z& F7 T' D! x# U! w% W" D7 T
& g; K! t- a+ T6 T+ n7 r+ D" t8 \8 `4、重写tostring、equals、hashcode三个方法

创建action

# {( R3 c" D- G! E5 y1、写一个类继承Action

2、实现一个公有的方法（回调方法）
7 @- ?4 T2 R" p! B3 k+ o2 _2 v9 R; ^7 r
; m$ n1 g2 T7 Z: A3 @public ActionForward execute(ActionMapping mapping,

ActionForm form,

" h+ p$ o+ R9 P7 G3 R+ qHttpServletRequest request,
- l. y( l4 F1 U, V  a
HttpServletResponse response)

{
0 [0 _8 _8 X7 t, Y& s
//1.收集参数
9 K6 R9 f0 w, c( d9 T: `$ E! f
MyActionForm myForm = (MyActionForm)form;

( e3 ~. _% F( e2 Y( U//2.组织参数


- V! Y, B$ T, r6 m) C1 M
//3.调用逻辑层

; |8 h& D( w5 Z# _3 `' X8 rboolean flag = true;

7 L1 f: u, N3 g" ]//4.根据返回值来跳转到相应的页面

; ?. t& ^+ P! jActionForward af = new ActionForward();

if(flag){
/ k( q# Z6 K9 K8 J* U, @
af = mapping.findForward(“1″);

$ f. b; \1 |( Q# n0 u" k}else{

af = mapping.findForward(“2″);
6 t! T5 N, H5 H1 D( a+ n
9 l2 J$ C/ |. }0 x}
9 C$ M0 f& ?8 P9 r8 {6 q
" M- d2 {% L/ A) @return af;
5 t. w) k+ Q( l' ^0 D
}

配置struts-config.xml文件
. G: u+ T1 F, q$ V; {; U4 L
1.<form-beans>
9 ~; c9 ~6 i2 R5 c  I- J
3 i/ A2 W3 `. Y<form-bean name=”myActionForm” type=”全路径.MyActionForm”/>

, \5 T7 Q, I9 ~, t<form-bean />

</form-beans>
6 V5 T7 n7 t' t
2.<action-mappings>
0 w, I! U$ k& A( W6 ^
<action path=”/sll”

3 W% T6 |5 L. m8 C  P" Fname=”myActionForm”
' z; w3 D% a" @
type=”全路径.MyAction”

' ?6 ^/ F; C( ascope=”session”

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

. J9 j: A! R2 j! C) K8 Z! p<forward name=”1″ path=”/1.jsp”>

<forward name=”2″ path=”/2.jsp”>
1 W6 k! [1 h5 H" a
* v- @4 T* m) n3 h* k</action>

' p& G6 ^* w1 J! Q</action-mappings>

步骤:
* D* O, w: E+ C9 H& V8 C
) z4 s$ g1 `* i* a+ z5 Z: B4 i/ |1.创建一个空的web应用
0 s6 e, L( q* X+ z' m  N
2.将struts的包放到lib文件夹下

) A9 j8 e5 O2 C" h7 ~3.将.tld文件文件和struts-config.xml、web.xml放到WEB-INF的跟目录下
3 L) e" |5 H! D3 w7 k, A
4.配置struts-config.xml文件和web.xml文件

5.在页面引入tag文件uri

! |4 H# Q) B) k) ^- `; _7 dSTRUTS运行机制

1、界面点击产生请求

2、容器接到请求
& ^2 h5 x, S4 w1 v1 V- c' d
3 z# W4 Y+ d4 {1 C) R3 U2 b3、匹配web.xml文件中的*.do来调用ActionServlet

4、ActionServlet的处理

4.1 读struts-congfig.xml文件形成ActionMapping
# P8 @& w7 e/ T  z: A1 F
  @# Q7 Y0 t, U4 A5 o# E4.2 通过path 来匹配Action类，通过Action的name属性来匹配ActionForm类
. `+ Q8 U% @- f/ ]9 P/ k
4.3 通过反射机制来给Form添数据

4.4 由ActionServlet转调Action的execute方法

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

* V2 \* ^- ]1 z1 g" z: @4.5.1 RequestDispatcher

$ }8 M: B6 ~2 r# e. d/ X2 s* ~4.5.2 response.sendRedirect(“list.jsp”);
( _0 C& D' j2 u* B) D
8 a9 o' Q/ a7 r# s
, Q7 @. l# r/ S9 o9 k5 J5 A
进入execute方法

$ T1 Y6 t1 |& T+ S. H; c5 b1 收集参数

2 组织参数
2 o& G8 P& S' u% {
. w& D( n6 B$ s# V7 K3 调用，逻辑层
) W8 n% V1 V$ A! y- w
) i$ w% B. {7 g' v. K$ s. A4 返回值

  s6 Y* @8 ^" q4.1 选择下一个页面 （ActionForward）

8 A+ _, k1 F8 @4.2 把值传给下一个页面



比较struts和struts2的不同
, C# O' f8 z* w
Struts

+ v8 Y4 \3 E( T/ j9 NStruts2
/ H; o! q) z; h7 [, q
组成        五个部分：ActionServlet，ActionMapping，AtcionForward，ActionForm，Action        十个部分：AcionContext，FilterDispatcher，ActionMapper，ActionProxy，Configuration Manager，Action Invocation，Interceptot，Action，Result，Taglib
  c( y6 c7 ]$ X1 W  K5 M' vurl        .do        .action
6 B" Q% ?5 r& L分发控制        AtcionServlet        FilterDispatcher
收集参数        利用JavaBean技术，将数据封装到ActionForm的子类中；
9 A; e" t- j* ]  Z# ~9 ?一个Action对应一个ActionForm的子类

使用拦截器将数据封装到值栈中。
使用域模型，一个Action对应多个值栈中的Model
+ ]) _" P5 Q2 m- v2 f0 T+ k
1 ]3 b; m/ C; K* Q读取配置文件        ActionMapping        Configuration Manager
拦截器        无拦截器        执行Action前后有拦截器
返回页面        将字符串封装到AtcionForward，进行跳转页面        Action中直接返回字符串，通过Result跳转页面
页面跳转方式        两种：dispatch，redirect        三种：dispatch，redirect，chain
6 [3 L( l5 E7 N+ f2 |值栈        无值栈，Action通过在request范围内设置属性，向jsp页面传递数据        有值栈，Action和jsp页面通过值栈传递数据，jsp页面通过OGNL取得值栈中的数据
配置文件        struts-config.xml        struts.xml
中文问题        不能解决（需要使用filter）        可以解决中文问题：
1、在jsp页面添加Meta；

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

admin

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

一、配置ant的运行环境

) x$ v  Q+ v. h  @& k" G1 t& t0 i1 ]& [, Q1.将ant的bin目录添加到path中

0 w6 h+ _# I4 T6 I1 q/ c) ]9 D2.配置JAVA_HOME
8 h8 x0 A' _, Q! A
3.配置ANT_HOME
* \2 _3 w6 N7 B4 J
二、配制build.xml文件，该文件放在应用程序的根目录下
  b9 M% E5 w  Q6 H, H% }
编译java文件

执行java文件
5 l1 M* p9 C0 ?3 \! U! b
copy

删除

打jar包
) b/ A% O* _( M. A2 e7 d1 Y$ Y
/ z- a: O" Q. c根据注解生成配置文件
5 Y! J9 _# L. f. {- f3 p
Xdoclet
1 k' X1 \0 f* M7 i通过注释生成一系列文件的工具（txt、xml、java、html等）
1 b9 e1 l" |6 B2 Z% |7 `
xdoclet本质是摸板技术+字符串的替换
9 Q3 C0 r7 v( L7 U
1 t  V& ^9 u/ W5 q* Z+ U1.在java文件中写符合要求的注释（将hbm.xml文件的内容搬到java文件中去写）
$ p5 j' H/ w0 q7 a$ N* j
, Y5 [/ Z% e! [. }4 v% }1.1 在类的上面 写与表的对应

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

2.在ant中引入相应的task来驱动xdoclet
/ J2 Q. Q9 `+ M& b$ Y5 R1 R/ ^

+ M/ i- h7 [% a, `
log4j日志管理
' ?4 }$ B, ]7 ~) {" R1、是什么？
# t! s- Z! B# i# M, [
在开发期间用来测试、对整个日志信息进行管理的工具
+ q1 y! }, h. t# e
2、功能
  [6 J$ V7 S; {) K
1.控制输出的目的地

2. 控制输出的格式
/ Z8 ?: S; Y" E. b
3. 控制输出的级别

3、日志的级别
9 i1 ?' }( T# {4 l4 Y
2 D# H9 R  z) e+ y+ J* y1. debug 调试

2. info 给用户的提示信息
1 k: ]8 C) _4 X4 @1 x& X7 s
3. warn 给用户的警告信息
( C9 A, G& d/ _; Z" ~
4.error 给程序员用来调试
+ t) l) j% Z8 V. c( ?+ S# S) i
- X$ ^4 N, V/ @# y, b5 |% fDebug—-〉info—-〉warn——–〉error

: d+ i) P6 `, X; r4、配置
) f5 C' J" l" {6 D7 `' u
1.配置级别
6 j* }3 h2 |+ K6 A5 W# N1 S
+ h2 l4 k3 E3 D# G: D; {- P2.输入源 （控制台和文件）

1 p2 h% {/ R, G% m3 I% Q3.可以进行分包控制

3 W& l) Q. J# q% wLog4f.logger.包结构 = 级别

) x0 Y- s" D, O0 w6 j1 X0 k' W5、使用

Logger log=Logger.getLogger(Test.class);
( E& o  |% X* K+ j+ M6 G' x
# c% ^) r* \% j+ z: {2 ?7 ?! u' i- m    public
void t3(){
1 f2 Z) m- \- {7 ^( I1 c
        log.debug(“this is debug”);
( N# f* x' [( h6 X
, s, b! F* R" s7 W6 _; x        log.info(“this is info”);
1 C& X$ q- k8 C  C) B
        log.warn(“this is warn “);
9 F5 V. F+ \: v+ `3 E. E4 Z) b
2 ^( Q  p) Z' V. O/ H3 G+ r        log.error(“this is error”);
" @; C7 a* u4 W3 h) \* D
    }
$ J1 S, S* W4 S' E8 ]- ]; S6 u6 Q
Junit
1.是什么？

  `" j  M* w$ V% w) D" m$ p5 ?单元测试的框架

2.怎么做？

写一个类继承TestCase

: h" ?( [* _7 ^. @+ l3 x测试的方法一般都以test开头并且没有参数

在测试方法前执行的方法public void setUp( )

0 D9 O! t( m9 d) q4 n$ K8 X在测试方法后执行的方法public void tearDown( )

error和故障的区别
( ?: `/ @/ e! }" R3 E
error ：代码有问题

故障 ：逻辑有问题与祈望的值不相符合
1 i5 `# j( B: b
: ^" K& x$ J. R2 a; R$ p生命周期
/ Q# m! p1 ?' ]% ^& p
  [' T2 p/ O7 _6 s2 d测试—〉SetUp（）—〉testXX（）—〉tearDown（）—〉结束；
1 C: J/ D  y3 Q$ x
) s/ I( U6 I- V4 I, YTestCase套件
# e: Q  O: `1 y% P6 Y% O- h
: ]  X+ b( f# \public class MyTest{

        Public static Test suite(){
" u! Q6 a/ j& \/ V; y: i8 W. z& W
TestSuite suite = new TestSuite();
: J  Z9 T5 x# i8 ^3 Q) X+ s
( n+ J3 _% R2 L7 bsuite.addTestCase(Test1.class);
5 C4 K( k" G8 q" y/ y6 }  F2 X! H5 N
suite.addTestCase(Test2.class);
% s0 F' v/ I9 f
}
  d+ _5 B# U& W, M! T
7 a4 L, {& A* s}
. Y2 O. z6 H8 O7 b: p

3 u. V8 T# Q2 T+ G; M
Ajax
是什么？
AJAX即“Asynchronous JavaScript and XML”（异步JavaScript和XML)。是一种创建交互式网页应用的网页开发技术。
- P% o$ m* h- Y( P$ v
无刷新页面。
4 }/ G. m: |! v' Q, n$ {
有什么？
% l: \* q! Q/ c# i4 R. Z- d* u* dAJAX是多种技术的综合，包括JavaScript、XHTML和CSS、DOM、XML 和 XSLT、XMLHttpRequest。

/ U9 o4 {' ?. r4 R0 p. d- n8 f能干什么？
使用XHTML+CSS标准化呈现；
# O  F& V( Y  p使用DOM进行动态显示及交互；
9 A( O/ A4 X9 n使用 XML 和 XSLT 进行数据交换及相关操作；
5 w2 Y. g5 K  j$ W/ }使用 XMLHttpRequest 进行异步数据查询、检索；
使用JavaScript绑定和处理有所得数据；

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

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

! j  U( [- h" N. I+ y" C- C# j使用Ajax的最大优点，就是能在不更新整个页面的前提下维护数据。这使得Web应用程序更为迅捷地回应用户动作，并避免了在网络上发送那些没有改变过的信息。

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

怎么做？
<script language=”javascript”>
/ b7 j/ l' W2 w% y
var req;
$ ]& K/ Q. c% P+ ^
! a$ D9 I! R' T+ H1 ]5 cfunction add(){
0 Y6 `3 d( m4 `9 c% U
6 ^5 U. ^1 _) n" \//1:创建用于传输的对象
4 [2 C: F$ j, @& S/ E
req=new ActiveXObject(“Microsoft.XMLHTTP”);
  ?, g$ P- N/ m2 q% W
// 声明返回后，处理数据的方法

req.onreadystatechange=manage;

0 B6 _: \. F+ J; v) H; {* r- g//2:准备传输的内容

var str=”test1111″;

1 H3 _' H' f% L$ H# `//3:发出请求

req.open(“GET” ,”/others/ajax/test/t2.jsp?str=”+str);
0 B( a1 V5 `6 c( `% x0 N/ P8 a
req.send(null);
( @. _/ Z) }4 D& W' v* o2 `& Z8 g
' G& w; r3 h% a# P}

//4:接受返回并处理

7 H# F& z2 y7 Vfunction manage(){
' g# P9 P. N5 x) f- o
if(req.readyState==4){

alert(“r==”+req.responseText);
9 k- n* |. b- Q: y3 u
& O. T% w) l, t8 h2 {}

$ p( G+ s4 D" n- ?! s& }! @# m. v}
7 o, H3 s3 |  Q/ y
  G& z  s+ ~- j3 h7 T4 ?* g</script>
; C2 g  {  B& |4 J/ t- D
readyState的取值如下：

# `( T: b. C/ z! Q  y, q) a　　0 (未初始化)
, G. u& X' Q5 H4 G9 [
! _  G/ t( M; o. v7 _　　1 (正在装载)
7 c7 V" d+ ?7 k$ {/ ]: p
2 {* B0 ?' w1 r, n4 N! K　　2 (装载完毕)

; I6 @& Z# k7 j. g, u, o　　3 (交互中)

* ^( a, p  U' n1 `2 d% z8 ~3 a7 B. Q　　4 (完成)


. |; t; \1 ?% W  j7 h. t
原理
Ajax的原理简单来说通过XmlHttpRequest对象来向服务器发异步请求，从服务器获得数据，可以是xml格式，也可以是一个字符串，然后用javascript来操作DOM而更新页面。

4 J* i: q& T' oDwr
9 M& x2 n" J( C' y1 C, U是什么？
DWR（Direct Web Remoting）是一个开源的类库，可以帮助开发人员开发包含AJAX技术的页面。它可以允许在页面中使用运行在WEB服务器上的JAVA函数,被调用的JAVA函数就像是在页面中JavaScript方法一样。
8 \  R3 V: c" B6 v3 v; j& E
/ U: T" \2 |: m$ k8 v) L- p有什么？
/ o: B  K4 m$ {它包含两个主要的部分：允许JavaScript从WEB服务器上一个遵循了AJAX原则的Servlet中获取数据；另外一方面提供了一个JavaScript库可以帮助web开发人员轻松地利用获取的数据来动态改变网页的内容。



能干什么？
( g% H' y1 _" @/ X' H动态地把java类生成为JavaScript，感觉调用就像发生在浏览器端，实际上代码调用发生在服务器端，Dwr负责数据的传递和转换。这种从Java到JavaScript的远程调用功能的方式使DWR用起来有种非常像RMI或者SOAP的常规RPC机制。



7 o& ]3 Y$ y& P怎么做？
+ |  X* k1 ]  Z1 [% A① 编写配置文件
7 J0 p* g4 o" A% w* K. E9 ]2 I
web.xml
& Q5 L2 n6 g1 l4 @7 ?
' }! ]! q/ X- H7 d$ z  N5 _) ~<servlet>

- p8 M( Y8 M2 k# W8 c7 O. D$ F<servlet-name>dwr-invoker</servlet-name>

% j* J: `' I6 p* ]<servlet-class>

org.directwebremoting.servlet.DwrServlet

2 N2 M4 a$ S; }5 V</servlet-class>
% C9 H  x8 a8 X, K6 }& k
/ A+ F5 G$ j$ I" U" w$ o& D" W<init-param>

5 @$ C- V8 g; y! A<param-name>debug</param-name>

( w5 x" W! M- a<param-value>true</param-value>
9 G/ _# s$ C2 M( E5 I, \
</init-param>

4 i  V2 u, Q; x</servlet>
1 r; ?$ W  h% @+ W5 x! P
; Z$ }2 P: p% X$ i<servlet-mapping>

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

<url-pattern>/dwr/*</url-pattern>

; }' d: `1 A5 Y</servlet-mapping>

dwr.xml

<allow>

! g) v8 Z* w# }<create creator=”new” javascript=”kc2″>
- U* l! m6 J, d1 o  w' K
<param name=”class” value=”dwr.Service” />

  j# D( ~6 X/ N$ U" f</create>
' j6 @1 z3 E  _2 F8 D9 v. U! w, `* U
</allow>
' @2 m' ?4 O/ w) [; D* d+ P' i" Q% I
②编写service

6 J$ t4 D# L+ m# ^# k7 d( o; mpublic class Service {
# U9 h! _5 x/ X4 q
$ I; S8 j+ k* z/ m4 e+ Wpublic String sayHello(String yourName) {
: [- p3 m8 v, `6 I4 |2 e6 U" _
//可以是访问数据库的复杂代码
0 O9 ?% z  m3 m$ ?1 c# D6 l
2 B# Z# L% t) I+ F9 |, R# ?return “Hello World ” + yourName;
- R' z- m5 a% V
- ?( g2 I" b7 w6 k. ~2 i5 Z}
6 O8 S5 K/ S' H; r! ?8 Z4 u
}

③测试DWR
% F7 }" l) U1 @+ E! C; k
将代码放入应用服务器（比如Tomcat），启动。
% I# p' s$ W" u) G$ r5 c6 ~
然后在地址栏输入http://localhost:8080/你的工程/dwr

④编写jsp页面

1） 要引用3个dwr的js，其中engine.js必须要，如果需要用到dwr提供的一些方便的工具要引用util.js
( V6 I: c. k6 Y9 M/ d0 ]
/ b# o1 P# [2 ^: O8 o& w  D- z2） 然后还要引用dwr自动生成的js，dwr/interface/service.js，注意js名字要和dwr.xml配置的一样
' @" w0 P' B5 o' f) J
3） js里的service.sayHello和java类的那个有一点区别，多了一个参数，用来得到返回的数据