我的日常

登录/注册
您现在的位置:论坛 盖世程序员(我猜到了开头 却没有猜到结局) 盖世程序员 > Java初级程序员面试必备的基础知识总结
总共48087条微博

动态微博

12
楼主: admin

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

[复制链接]
admin    

1244

主题

544

听众

1万

金钱

管理员

  • TA的每日心情

    2021-2-2 11:21
  • 签到天数: 36 天

    [LV.5]常住居民I

    管理员

    11#
    发表于 2014-12-03 12:43:50 |只看该作者
    JEE3 k; ~1 a) G$ W
    简述JEE  m1 x8 L* _- v
    JEE : JAVA  PLATFORM  ENTERPRISE  EDITION) J5 z/ N) O6 q4 O3 c/ H

    ; ]. U4 b/ d, J& }JEE是一个规范集;
    : q0 ^# {! Y7 w' `# `( r0 h# z% W
    JEE是一个框架集;, `% ^6 P. W4 |6 n& _  G6 K1 h

    3 k8 B1 X* I/ t' u% B1 s# hJEE是一个技术集或API集;$ w( r4 J5 g' Y( `
    8 J  d4 e7 M( B( @
    适用于创建服务器端的大型的软件服务系统0 K9 G1 d" y1 u: K5 ^1 Q

    ; p" Q( ~- ]( p7 v
    " o6 H7 Z# J0 t# U6 p8 S# M' U( {. |% s5 s
    C/S B/S 模式/ B" W* M: {  e5 W- I) |. v* R8 p
    C/S client/server即客户机/服务器模式,客户端也参与程序的运行与计算(富客户端、胖客户端)
    0 |$ m( h' _5 \' v
    . {; |7 J5 E$ D3 p( J* X: `B/S border/server即浏览器/服务器模式,又称为瘦客户端,客户端不参与程序的运行与计算
    - u1 m' d* v" L* j' B: `6 R6 r* B; R. m: w0 A2 i
    & \, O0 N) w; V0 p

    ; x5 B6 \2 U. @. |  g企业级应用(大规模的应用)的特点
    6 g: |; L' _2 S6 d; i. A1.生命周期长、稳定、可靠: b# V  r9 U# Z

    - q2 U5 e: G! Z2.组件往往分布在异构的环境中,能够跨平台
    ! z7 a1 N( f, f7 w* s2 O* H4 W
    + H$ N+ }$ d" g' }3.维护性、扩展性、重用性3 K" {2 i2 U; \2 d$ {7 l3 i
    8 D3 _8 p0 a' Y. y, n! Y
    4.有事务、安全、线程
    7 n9 C2 i- }2 I1 z) Y1 k
    ) d# q% J/ \; f) @$ y- k* }& H
      ^& Q$ M; V6 ]* b" |9 p3 N6 K
    8 _, s4 P/ `* g5 [2 G( \( a  R什么是业务逻辑?
    - }5 d3 S8 D( }  Q2 {依照业务逻辑划分模块,
    ) c( [! @$ E& f/ z
    7 s* ~5 a# a/ ?3 q( w) b所谓判定业务 就是具有以下特征:
    . y" e+ p1 s* l& d  o. B
    ( i, }$ G/ n/ O" g) \# e$ u: `1.业务流程$ \% |/ v/ P, |! c7 x

    4 I' D4 X" W, B; K! Z" O2.业务判断
    ' e$ |! r- m) \& m- z
    # A( p; N( {7 w3 w( {3.功能组合$ A0 @) h2 n3 x. t3 }
    1 W& E5 N2 P/ h$ b6 r6 C5 O* q
    ( L8 q& A3 c2 N7 a; q

    ( c4 N: p: V/ ^平台(角色)的划分2 K/ X( l9 d/ A7 ^( Y* B% y
    1.平台供应商。提供满足API集实现的厂商(BEA weblogic IBM webshphere)* Z3 P4 }# M' C) ~
    9 E+ T1 ^6 n5 L3 _# |: E+ w
    2.组件供应商) P1 A& w9 |) I5 H* n: r
    2 i( z( ]7 A5 u& ?+ e2 A/ i7 N4 I
    3.组件装配人员' y* a# I" j: C8 K& F. p. M

    ) `  j: r: u' [$ l3 w7 k! p: `* \4.部署人员' ?( a4 G7 g7 P8 t# `

    ( R' {, l% \/ c' h7 j5.系统管理人员- R8 s) _  r' c; S
    * [# t1 s+ {- n6 H; ?1 K% B# J  J
    6.工具供应商 提供开发组件所使用的工具(Jbuilder、eclipse)
    6 {7 F: r) {  @3 m/ [: k! G# {0 a+ r
    9 e. ]$ i8 c3 q4 h
    ; {$ ~# e) r  r  @0 v6 h( V
    java技术分布(设计架构 模块内部设计)2 V+ q5 D' J. t/ U* r2 L: h
    1.表现层 Servlet、 Jsp、 JavaBean、 Taglib
    $ P7 v0 n) }- g9 F! w5 @, g. o5 q& E/ p% Z  _
    2.逻辑层 EJB(SessionBean)
    2 r$ R  ?: B: s( w
    & D/ j5 B2 X. i8 G* c3.数据层 ( JDBC  EJB(EntityBean))
    / O3 Q" H, P( o) S7 }! M
    & p, v6 r; L7 b* y# U4.服务 JTA(JAVA事务架构) JTS(JAVA事务服务) JAAS(JAVA授权与验证服务)* W( b. H8 a0 y* S8 J( s4 @
    - r/ K0 U  P( `9 V$ z5 C
    5.分布式通讯 RMI(IIOP)+JNDI 、JAXP(JAVA 的 XML 架构)) L1 T% ~- }( w$ R) @) o

    8 w5 Q/ j6 N: b$ `1 ~JAVAMAIL(邮件服务)、JMS(消息服务)、IDLC、JCA(JAVA连接器框架 (成))
    ( y% \  ~1 ?) i, b$ k( d1 ~
    ) L  S8 [' G6 `3 Q
    * p, K0 Z0 p7 U' |$ W" W/ q5 Z: p8 m5 i/ e
    JEE的体系结构: 是一种组件的体系结构1 F( \" S& T0 h6 }
    1.组件 : 能够完成一定功能的封状体(独立的功能的集合)
    0 }1 P. t+ B: t! L0 V- b9 V
    " W$ i6 [4 t" y不能单独运行,必须运行在容器上8 J1 d4 l% ?7 H7 V1 E# p6 i, M, ]
    , u* p/ J0 u" l9 Q& Q3 o5 j  O
    分为两类:web组件、ejb组件
    ( @  _# h9 L, i. O9 y  F
    # Q* n6 D8 G& V7 r' N# f2.容器 : 提供组件的运行环境,并对组件进行管理(一段程序)
    7 E. J5 s0 ^4 D
    0 A- w, l2 U2 |# _% Z$ c管理组件的生命周期  `- D& L+ G# P* Z; K

    " y7 m: }$ C! z7 `不能单独运行,必须运行在服务器上
      N2 N% M* y3 Q+ ~2 T' Z& x+ ?8 y5 ]+ H1 H, ?
    程序(组件)通过上下文来调用容器(context)) u/ F3 l+ W1 F: k

    2 W5 S! C. `7 V5 M! l组件通过web.xml向容器描述自己,使容器能够认识组件
    + \; x- W  v. m# Y( m* s+ O- d3 o2 x! m
    容器通过回调方法来调用组件
    / \5 @4 r& s- v4 |/ g
    5 m+ ?9 b0 e9 X$ s& y2 y分为两类:web容器、ejb容器# [; e2 m* l" t1 M/ V

    . P7 w2 s( {2 t5 e; y) g) f; Q( t; f3.服务器 : 提供容器的运行环境,提供大量的JEE基础服务( o  n" Z; K* X/ z' F
    ! }1 Q0 K) Z: d8 Q, ~# D
    web服务器(只提供web服务)
    7 n  x& N2 {, L1 P2 u3 J9 Y$ p0 _' a9 |% c9 m9 k  w8 z! r& Z
    jee服务器(提供web、jee服务)3 k# V$ J. O2 ]" O9 `

    8 X# d  b6 u( f4 n, J5 d& z
    $ i& Q; }5 I; I- s- i0 ^3 F! o6 Q8 a6 }4 M6 X
    什么是回调方法
    . L0 y" r3 Y( L$ Y. c2 V% ~" X由容器自动调用的方法,就叫回调方法。5 X- z$ J$ k+ Q" X1 U1 Z

    - n- p3 H. ^; U/ V' ]9 e! ?
    - ~& X2 v& }* a- ?5 R: t
    4 a; Z+ W7 d  Q8 O+ p: i* x! a$ K; p' PRMI远程方法的调用机制
    4 T" Z% Y1 V& s: U& z, s/ `例如:A主机有B()方法,C主机有D()方法,A 想调用C主机的D方法5 V1 O* A. J2 K* w# ?, C
    $ |* Z0 X$ @' I  P! D
    ( }9 e, {& _- [) F; X+ W

    ; w* v0 `2 q( |( T+ ~4 j
    0 t0 _8 o# _. z9 Q3 \/ a' V
    9 }: m) q( j4 v/ @学习方法0 |4 U% s( E% W# H: w, z1 P, o
    1.规范(熟记) 2.熟悉API 3.多练 4.多想
    回复

    使用道具 举报

    admin    

    1244

    主题

    544

    听众

    1万

    金钱

    管理员

  • TA的每日心情

    2021-2-2 11:21
  • 签到天数: 36 天

    [LV.5]常住居民I

    管理员

    12#
    发表于 2014-12-03 12:45:29 |只看该作者
    Servlet1 P" W3 j! f; N
    •     描述war包、jar包、ear包的结构6 j7 C. u* v0 @8 B% }8 M9 F
      6 j2 X% u$ l' Z; O# t
      ! C6 g0 `$ S3 ~# T

    war-                            web文档压缩包

    —WEB-INF

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

    —-lib                本web应用需要的jar包(可选)

    —-classes            本web应用需要的类文件(可选)


    4 ]- b6 [) u& s5 P; V7 h

    jar-                             java文件压缩包

    —META-INF

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

    + H$ @1 M) B# H3 Q

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

    –META-INF

    —Application.xml 配置文件

    –*.war

    –*.jar

    ; a/ d0 w9 W+ x! ?+ y, m( s
    • 什么是servlet?servlet主要做什么?* c& E9 g: L& \9 g8 S8 ^1 ?
      / X8 Q( i' ]0 j. g4 k

      & V9 K( q1 N$ F" {) R* u" x

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

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

    4 x1 Z2 ^/ X7 e* {+ R* H: q
    • servlet 与cgi相比的优点?servlet的缺点- ~- ^# F, g4 B4 g! k( F& O5 d3 F

      8 f3 `: q" V" d$ h- Z' |
      3 b3 A! d  h/ D$ A' X

    优点:

    性能(线程比进程更快)

    可伸缩

    Java强健且面向对象

    Java平台独立

    缺点:

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

    1 m% @$ }( Z/ J6 _
    • 常用的servlet包的名称是?: o, h$ q6 ?" v& z
      3 o& z- V' G$ V( ?! p6 D2 J4 F
      ; d4 Q+ h  u$ Q& |' w1 H" u

    javax.servlet

    javax.servlet.http


    - @- U3 V, u+ b" E# u/ \* v- M
    • 描述servlet接口的层次结构?  p5 |/ A" {. U% E
      & I/ U( p1 Y/ ]* z" N( V/ ?8 E

      : v- h' V7 V8 i* }, l( ~* x

    Servlet

    –GenericServlet

    –HttpServlet

    –自己的servlet

    ServletRequest

    –HttpServletRequest

    ServletResponse

    –HttpServletResponse


    + C* G* i/ T$ o
    • 对比get方法和post方法?6 h' j" b; A$ T0 ^# R; P$ ^2 W
      " }) G$ q5 C( V5 n! \7 x  t
      1 N0 W( Z' a: l" }! q+ \

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

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

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

    中不可见,安全度高。可以传输中文;


    ! \0 S& T8 j9 O1 `& j, ]
    • 归类描述HttpServletRequest接口都完成那些功能
      8 I+ f% w0 `9 p% H" c1 `

      & b- D/ T, R: \3 l1 D3 y( i
      % g( _# G% o& P7 Q* W
      • 读取HTTP头标7 x" i7 J5 _% Q1 t5 V; y
      • 读取cookie. G6 `6 D- {+ r( x
      • 读取路径信息
        . r6 ?  K: }4 R- {9 a( y
      • 标识HTTP会话。
        7 {$ o* m  M. ^, g0 i
        : ?- _  t3 A* F
    ; a/ M' z, k& S4 _- n6 E" ]1 V
    • 归类描述HttpServletResponse接口都完成那些功能) q5 E9 c2 Z3 q* Y$ N
      0 y; E1 w9 P9 z) a3 A4 u# F! l
      * x& z: h$ d5 _! _0 a+ o* G7 D
      • 设置HTTP头标
        ' I  x" A2 V7 ^" O! ]: d  L  ~
      • 设置cookie
        * ~1 V! n( @" W! k( p( s" c
      • 设定响应的content类型
        % {& Z( |! p( ?  v+ J1 n/ h* o
      • 输出返回数据7 j3 l( @3 U  Z- u% E- [' w+ Y5 X

        7 L1 q9 m* q3 i0 U( i

    7 ]# J* q6 _/ ]$ D
    • 描述service方法所完成的基本功能?默认是在那里实现的?
      $ q+ i; ^3 Q% g

      ! [7 S( F" @7 A4 Q* b9 D" {. L. M8 A- g: w; N

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

    实现:默认在HttpServlet类中实现

    3 v# O) o$ m, f. O& `
    • 如何开发自己的Servlet?描述应该做的步骤和每步需要完成的工作
      3 U8 p( F7 b  n2 e$ F

      ' w* N" T1 l, x3 N
      2 T4 ^- V; D) x  v

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

    ( E! r) M6 [7 @
    • 为何servlet需要部署描述?
      : K/ ~/ R- ~2 N0 O% n5 s/ S5 M/ y

      # O: l8 _7 S+ t( J; h5 c, @, x
      ! N- s/ J8 w7 T  H/ a

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


    ; m$ r' H3 m) P( g: S: k6 ]4 @: b
    • Servlet基本的描述应该是?请写出来# R& c$ X% b. C5 k; q/ ?
      # g4 b* T' M/ [- O5 @& X: r5 E

      . n" N1 ~. ]. P" Q6 @( j. f8 t( n  `

    % [& ~' L+ i3 P5 J

    <servlet>

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

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

    </servlet>

    <servlet-mapping>

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

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

    </servlet-mapping>


    3 [- \; O, v; d: m  Q
    • 如何在html中使用servlet9 J2 H6 o! _( f4 f; k# {( ~( r

      + v3 Q# V4 p/ ?( \5 m1 |
      ' ^6 Z- {  D% ?  S7 M1 L/ O8 \! }& v

    FORM标记

    ACTION– 指定form信息的目的地(相关的URL)

    METHOD – 指定HTTP方法(GET或POST)

    语法:

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

    {HTML form tags and other HTML content}

    </FORM>

    # C/ n0 b( A" Q1 ^! @7 a! A
    • 如何接受request中的参数
      ! b* O/ p/ w% }* l$ \9 C9 {

      & w& |* ~6 w: a( |0 p6 UString userName = request.getParameter(“userName”)方法
      " V% \1 F  q* w, ]6 C5 ^! _( k! u$ Y
    6 e* F, q" o4 j/ L) i; c* I  b
    • 如何接受request中header的值" k# w2 r# C+ X# }/ b* m- r3 U
      9 M- o# c5 v3 @9 g
      ' ]7 K6 R' f5 M% {  g" U; j

    request.getHeader(name);

    request.getIntHeader(name);

    request.getDateHeader(name);

    request.getHeaderNames();


    * Z9 Y: X2 l" \3 f' r
    • 如何输出html) J# z. _' ^/ l( _0 P' A- h
      + v3 Z! u" O% {3 T0 v4 @+ y

      5 s+ S, y' o6 l9 i  N

    PrintWriter pw = response.getWriter();

    pw.write(“<html>”);

    pw.write(“Hello”);

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


    $ m- F9 x% c5 [3 y% Y; [1 X' s. o
    • 如何设置输出的contentType4 d* e) ~/ p8 Q

      ! ]) }9 ~( |- S7 M4 W" ~( a! G# O& T' f2 G

    response.setContentType(“text/html”)


    + A/ R7 {2 k& E, Q' x" b" G% u; j
    • 描述servlet的生命周期?+ K1 ~7 B% X0 ?+ q  Z& P
      8 l6 f' Z" A/ X6 ^5 U7 z! r* Q

      & R( G/ o$ A/ x$ p* [, J

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

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


    8 j8 Z) Z7 }$ B9 {
    • 描述init,service,destroy方法的功能和特点
      ' w3 |  P! L) \8 c
      * W: X$ i! |9 N; l! V" W6 F
      ; Z& K9 R: s  `3 a

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

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

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

    根据HTTP请求方法(GET、POST等),将请求分发到doGet、doPost等方法

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

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

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

    . T" _  ?, V% q( d1 O
    • 什么是回调方法?有什么特点?
      ' V) O4 f) @  Q
      & M+ S( r/ \8 j) u

      - k1 Q- o" ~7 @$ a

    由容器来调用程序的方法

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

    ) Z" R0 _! x/ O& S: s
    • 如何设置初始化servlet的参数?' ]1 J. r; |0 T+ a  F6 s/ n' F
      8 R/ S' o9 a( Y& P3 p/ t* e2 V
      在<servlet>中添加如下配置
      # K& r# z9 K1 s% e8 i3 b/ ]3 B# O& I/ g( V

    <init-param>

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

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

    </init-param>


    1 r, X5 S8 }) ^6 C7 {9 V1 f
    • 如何获取servlet初始化的参数
      - Z0 t# u5 |" v
      0 I  j, y  e* K; F2 v
      0 a) N9 K: y8 g# ^- X) k  q4 B4 ~

    public void init() {

    greetingText = getInitParameter(“greetingText”);

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

    }


    3 f4 u+ m9 h0 E1 j
    • ServletConfig接口默认实在那里实现的
      4 Q2 u& U% V  ?( r+ @; n8 K9 p

      ! T4 ~  j6 g* ]3 l6 i6 Z. [
      % F1 h# ~# @0 K/ u

    GenericServlet类实现ServletConfig接口


    ! a1 K" \0 [2 k
    • 什么是ServletContext?有什么作用?9 [" O+ U. Q% c6 z+ v' k- L- y

      ( g5 p1 F( A) m0 w4 ]* V, H$ V( |! i, K0 A2 p8 Y

    Servlet上下文

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

    - P8 D) J9 p5 y& W5 q! ]
    • 如何访问ServletContext接口?是在那里实现的?. I1 H( S7 I0 l% a% [$ s

      ! B/ }; q) E6 `$ r/ o
      5 ?  g3 I; v( U0 o& Z

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

    GenericServlet类实现了ServletContext接口。

    ! O/ k& e, c0 J  Q6 X1 l( L5 s
    • ServletContext接口的功能包括?分别用代码示例
      - `: }% ~  S3 N/ ^
      # I8 \5 b) e. X/ c6 V

      * N: ^' v, ~* J

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

    * E$ |9 r% U* [( A3 \0 b/ f
    • 如何设置ServletContext的参数?
      4 b4 m4 O2 P, ^3 \; v/ j/ a2 e: _
      ) ~  g' s4 u4 F' H; e: T/ J
      $ \* c5 E' y' K; U% a/ x3 f

    <context-param>

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

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

    </context-param>


    6 @8 q/ H( K$ w5 m
    • 如何获取ServletContext设置的参数值?! u% l2 |0 h' M, b* D

      . j  J4 ~* {9 L$ K+ e4 u. c% w5 N* O) y1 O

    ServletContext context = this.getServletContext();

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

      h+ _5 S' v3 P2 ?+ J
    • 描述Web应用的生命周期?
      9 ]. A" ]# i' f9 [9 a/ ~* O
      # t% [# U! }% p& r3 A! x# K

      4 G# [8 H; R6 f

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

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

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


    5 e+ g/ ~- X/ V
    • 如何用代码实现监控Web应用的生命周期?. s  L& d8 V% M0 s; d+ t
      0 d; |& g  e, f4 u, W

      8 k. O4 G- h( e% @" |. B6 g5 u. W3 L9 D& I4 B* H

    public class Test implements ServletContextListener{

    public void contextDestroyed(ServletContextEvent arg0) {

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

    }

    public void contextInitialized(ServletContextEvent arg0) {

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

    }

    }

    ; U( P: ~- q5 ]

    web.xml文件中的配置:

    <listener>

    <listener-class>

    com.csy.Test

    </listener-class>

    </listener>

    # C9 U4 q$ D( [. h. N7 ~2 c7 j
    • web应用中如下错误码示什么意思:400,401,404,500
      ' `- U( \& H2 \; X9 L" B* e+ `
      1 Q- k; R0 r. V) L) C& D* T/ m
      400 Bad Request//错误请求
      401 Unauthorized//未被认可
      404 Not Found//没有创建
      500 Internal Server Error//服务器内部错误

      2 M" K5 H9 _2 G
      P/ |# ~1 ?& H- J7 F- c) t" A
    • 描述Web应用中用声明方式来进行错误处理的两种方法% A; Q7 O2 {) W& y% I
      / V/ O, D7 p  H! _, u% ^
      & G7 U8 N# r6 B/ b" O

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

    <error-page>

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

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

    </error-page>

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

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

    <error-page>

    <exception-type>

    java.lang.ArithmeticException

    </exception-type>

    <location>/error/ExceptionPage</location>

    </error-page>

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

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

    - `( A5 x( R3 B# ?* X6 D: m
    • 描述记录异常日志的方法,都位于那些接口?9 ]5 B& M& C4 t: i
      ( D! r9 z9 u. ]+ ~) D) q: M

      $ t; h& K2 g( N0 I% D# t% F

    GenericServlet:

    log(message:String)

    log(message:String, Throwable:excp)

    ServletContext:

    log(message:String)

            log(message:String, excp:Throwable)

    9 ~  [* ]! q9 A: T$ [/ `5 z
    • 什么是会话?
      ( Y* ]  l) i( J6 A

      ; V* X& s) H: O2 z% h! F1 m) t5 d
      3 C, t4 I& N: `# o

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

    , r; [+ K, Y- v8 O5 F9 |' e
    • 如何获得会话?. k3 c/ j& Z9 ^) M% s# G" m' Q

      , r0 N2 M# d. O& X7 i- u
      HttpSession session = request.getSesseion( );
      ' b) v/ p; |( {% p# E

    3 ]+ {# m& P; c  r+ H
    • 会话Api的基本功能?% E# }% }( I# O4 C0 w

      0 H7 Q' q: g4 q; `4 D9 [2 b5 R% |2 n# s

    getID() :String
    . ?5 P9 n: I) r6 [$ d7 R$ z4 W

        isNew() :boolean( j7 B0 V- u+ @6 i# I

        getAttribute(name):Object1 F. H$ j9 C- f( j+ f# Y

        setAttribute(name,value)1 R9 ?2 A% R$ r, b

        removeAttribute(name)

    # D% l% I! W" q- ^
    • 如何销毁会话?( k; A: \1 E. S1 H* @6 r# ]. x
      $ H2 P. P' c2 P) r4 ]9 T+ d

      1 p" K* U; B1 ^, J

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

    <session-config>% G2 X) P% o9 M" h, a! a

             <session-timeout>10</session-timeout>
    6 S2 k& t5 i( b6 E& y) A) X/ c

         </session-config>' W' ^! A1 L1 U' A

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

    invalidate(). W% D$ I6 l' Y3 J

         getCreationTime() :long. j. y) G; N. t, |& G

        getLastAccessedTime() :long( h+ {. U( b6 @0 H, O3 k  l! E

        getMaxInactiveInterval() :int' T% k/ U3 n. {: a4 V

         setMaxInactiveInterval(int)


    # C* N9 T7 R7 l- ]) I0 R- a
    • 描述会话保持状态的基本原理
      ( l* J2 N! K2 ]; C, e! U
      6 G0 i1 {2 F& }& U
      8 Z* s* Q( G8 K' A% P9 n0 D
    & j) L; q" p9 c% \# S

        client server
    - M" N5 z8 T- Y9 I. e

    0 i# t$ E; n$ Y# n- A: C

    request; [2 U& H/ O- r$ Y

    response (sessionid)
    # P/ M0 Q- u9 m* T" ?% S

    request (cookies)
    # ]" [# E, h2 d

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


    ; G2 u# U. x: ]6 u. `+ a
    • 请描述session和cookie的异同之处
      $ E* e0 J" h1 @, h' Q5 M/ j

        G# x! W/ K1 K+ D- L! E/ ]) a4 n& b
      1 }* _& X# G# |

    4 ~6 r) j5 X! N) V3 |- [( E* U$ U2 R* r1 {2 v0 A# z! D6 J/ q  A; Z
    • 如何读写cookie,代码示例% W6 ~  y1 c3 I

      - N& `( F. F  x7 a2 V3 z
        B$ Z, ?6 l1 x2 b- A0 p( H

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

    response.addCookie(c);

    读:Cookie[] cookies = request.getCookies();
    4 X7 K) c# i, P! n

            for ( int i=0; i < cookies.length; i++ ) {! i7 D  v5 A4 }4 V3 l

                String key =cookies.getName();
    ! V6 U  o( V( `7 W, t

    String value = cookies.getValue(); : v  D. K1 p2 @4 w) i

    System.out.println(“cook”+i+“:key=”+key+“,value=”+value);3 d0 d( N/ M9 q) r: ^5 c

         }

    ' Z! l3 ]% ^, u  y! p) o
    • 什么是URL重写,如何实现,代码示例
      4 b) ^: P+ q) t' c( V3 L
      # n. a7 n+ y5 b' Z0 c
      9 K+ G+ |# X/ ^: h. i. \) i

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

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

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

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

      p9 w& J& c+ Y8 P
    + ]$ R  [. ?7 D; f+ }
    • 描述web应用的4种认证技术. V1 {( B2 L' g- c9 W

      ' k9 O! h) ], A' T! Z: |/ w  v& S, w9 p& r9 J/ t

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

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

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

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


    * R  ?2 V  P- E5 X! t8 w
    • 什么是授权,什么是验证?0 z9 Z0 g* a4 b6 P
      * f, q& g1 t. h+ f( G* j, }
      2 K" @  o# N- n7 Y0 |2 e! j

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

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


    ; C% c% Y" k2 C6 f, V: T1 Y" n
    • 什么是HTTPS* _; R' q) j' I% ]  S2 S

      # I0 x! H4 `4 j( I4 A
      " {1 b/ i! T- l7 y

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

    0 D$ H; P; L5 X7 `' r- T9 k
    • 什么是审计?9 U6 O# c, K! A8 Z
      2 O; ?% E* c0 }- D

      3 B- B0 T4 ?, `% L

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


    7 u$ K" ~* \, X( w
    • 如何实现声明性授权
      , _5 H" [& ]' o: _+ _. h( s6 U
      # m- t' W* {$ Y& s$ u% \+ ]7 s
      $ D- h8 F0 B  M, R9 ~6 S: ]9 p" l7 }% P6 `

    1、标识web资源集

    2、标识角色

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

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

    在 web.xml里配


    " z9 w" {$ r( A+ B) H4 a
    • 描述servlet并发问题?
      * ^( M5 R* `- l* _3 w3 t3 V7 t
      3 W+ l9 d7 {; b$ V
      ; H7 ?8 ~' J1 x' S" ~4 c8 [/ {

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

    + f( O6 b# Y; ?3 t0 x: @2 K
    • 描述Web应用中的六种属性范围
      & b# Z5 e( F+ K) O

      $ c) o) D' P, v6 O4 C/ q( U1 M8 Y* I  A/ r0 `! W/ M, Q

    局部变量(页面范围)

    实例变量

    类变量

    请求属性(请求范围)

    会话属性(会话范围)

    上下文属性(应用范围)

    9 b* E/ |: Y0 K( D2 u
    • 指出上述六种哪些是线程安全的( r, G! R! E1 J3 C% w

      , G* ^4 P5 ?) s3 f8 B
      2 L9 N9 W) i% ^' d

    局部变量和请求属性


    6 Q& Z2 w2 `/ K7 t7 W4 q
    • 什么是STM?如何实现?
      4 K9 X7 V: s/ b( Y
      ! Z3 `4 w  h+ X  H9 w

      : Z6 M8 h7 Y8 R# Q. M4 d

    SingleThreadModel接口

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

    7 N; f0 w. ]- I2 u1 k5 k
    • 如何实现并发管理?
      ' W) n$ q- K9 M6 e

      2 K/ k( H; ]$ L, o& l* i8 g2 B* \! {$ V: h

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

    使用synchronized语法控制并发

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

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

    : o' X! {  N4 l
    红红火火恍恍惚惚
    回复

    使用道具 举报

    admin    

    1244

    主题

    544

    听众

    1万

    金钱

    管理员

  • TA的每日心情

    2021-2-2 11:21
  • 签到天数: 36 天

    [LV.5]常住居民I

    管理员

    13#
    发表于 2014-12-03 12:45:45 |只看该作者
    Jsp5 W. o' Z1 m6 y: G( c. A& g4 Y
    什么是Jsp?
    , i9 ^9 p3 N4 ]Java Server Page    结合java和html在服务端动态生成web页面的技术
    7 y6 `+ g& Z0 m, y+ T6 z1 A
      {3 K6 \; p7 ?  D. Y ; u( A; ^1 r( o5 t. |! \2 r1 T
    5 F' a& q! X/ o' u  H
    描述Jsp页面的运行过程?8 }: f$ a3 e5 Z, l
    第一步:* f/ P6 ?1 u" f0 M
    6 f. c) s6 D( p" G
    请求进入Web容器,将JSP页面翻译成Servlet代码
    2 \( i6 Q7 F; ]% H
    5 q$ [" g; S/ ~: r4 f: g第二步:+ n2 _3 V3 U3 W: C
    $ p8 }) H5 R; c/ q! w7 H
    编译Servlet代码,并将编译过的类文件装入Web容器(JVM)环境
    ! R( i9 T" |# T4 }4 @0 B; k- x& o, K2 h# S& b$ U; G
    第三步:! R. L0 ]+ ~, |2 U! }$ [6 I0 ~2 H
    4 u9 @, e0 ~; C0 Q
    Web容器为JSP页面创建一个Servlet类实例,并执行jspInit方法: J# |, P* W# B+ O. @' e

    ! s& [8 a" @1 S7 b+ e! [第四步:/ P; J$ |8 a* R8 H  W5 A% D4 y- N

    5 K3 {& F' `2 g: e! ^Web容器为该JSP页面调用Servlet实例的_jspService方法;将结果发送给用户
      d3 M0 R3 i' S; r
    ) `% p# t/ W3 \8 Q
    0 B5 K9 @8 @7 E% Q+ t9 @
    * w) y- P  v* M  m7 g- Q# f- G描述Jsp页面的五类脚本元素的功能、写法、并示例
    ( }; T/ R7 @: e/ H  y/ m: c注释 <%– –%>
    + m1 Q+ G6 `" [. s& B; R3 K; g* X! Q# w% z4 M& C6 A1 Q; E
    <HTML>: F3 L2 J* P% r! Y

    ' J  A* u  A3 u+ j3 q<%– scripting element –%>( I' z& s& Z( _* ^) w! O+ v; T& Z
    ( b0 V+ u# I: c: F" m. g+ P* j, x
    </HTML>
    9 [  J! p2 R5 \3 K. x# l/ D3 l2 a* w6 A8 M/ j3 H
    指令标记 <%@ %> 指令标记影响JSP页面的翻译阶段3 W+ H; o: Z7 S* e

    $ ^- |" L6 J( I* l: F+ B- s9 C<%@ page session=”false” %>
    " S+ ?/ L& \2 d6 @+ o
    % n. L8 o6 \' f; g! f1 d. L声明标记 <%! %> 声明标记允许JSP页面开发人员包含类级声明
    8 `5 y* s" z* e+ E* r7 |
    * k8 P) d4 S7 v6 M  Y. q<%! public static final String DEFAULT_NAME = “World”; %>
    6 T5 y3 Q7 B8 P# ^. x" r1 i$ @, l1 m/ ?1 Q6 u) W' s
        脚本标记 <% %> 脚本标记允许JSP页面开发人员在_jspService方法中包含任意的Java代码
    ; t0 V; w9 Y, P6 b; G; ?) l6 r: C6 y8 y  X+ m, S# F/ g0 N
        <% int i = 0; %>: X6 \6 O# I* `5 f$ e2 D& a3 ~# H

    1 h1 J0 g: f" d表达式标记 <%= %> 表达式标记封装Java运行时的表达式,其值被送至HTTP响应流 <B>Ten is <%= (2 * 5) %></B>2 w+ l) v2 D9 S6 f5 p8 Y2 ]
    - C2 |" J" x  f$ Y

    3 H3 g8 E. M% B9 a  M: [
    & |; A+ i; K" s. Z* v8 f描述Jsp页面中的注释种类和写法
    7 J6 M* z. H1 m5 L- E: R. Z3 t/ [% HHTML注释
    / W2 `; H8 O& T2 K! e3 B
    1 c9 r9 R' u) Y: B<!– HTML注释显示在响应中 –>3 i! `! T8 L( m
    # D' R' g2 @1 U0 X$ f9 @2 a% q
    JSP页面注释
    # R* E- m. O) m: K' D7 \5 b6 ^( e7 m9 [! j" a" i$ s' g
    <%– JSP注释只在JSP代码中可见,不显示在servlet代码或响应中。–%>' d) A" U7 ?, y/ S/ z4 K" h6 _& V

    ' S! C+ a1 k+ O/ _& ]Java注释8 q/ a+ }/ Q4 Q0 j: e
    9 l# a# g9 K' A/ X( x
    <%+ f9 p% z, O- h  y" x& i. Q
    3 c. q5 @1 _& ]8 D5 E+ Q0 A
    /* Java注释显示在servlet代码中,不显示在响应中
    ! l! Z, _; L4 C- V5 ?
    # U( G- t; Z" t4 b, X*/
    0 Y1 ]# `! _! F: @1 G: q' v. G8 t2 e; A& c8 Q$ t
    %>; f& j- I) y5 X2 o6 N  A

    6 ^! F: w; z+ a/ P" x 5 T$ S/ J6 @$ Y  ^
    1 R- t1 S1 L7 w
    描述Jsp页面的指令标记的功能、写法、并示例* p# M( G/ r2 C" M$ `# Y$ y4 ^3 Z
    指令标记影响JSP页面的翻译阶段* Y8 b! ]# n1 E* Q, f* l

    - j* c1 R7 }% a. ]5 K% E5 _<%@ page session=”false” %>
    / P' F" X0 r8 W8 r9 ?8 }% F. X: s8 h" p; z) T5 r
    <%@ include file=”incl/copyright.html” %>
    # z3 _$ ^( a6 m8 |; r4 c# }. [9 M7 R+ p2 l
    <%@ taglib %>7 F0 T& b7 Z1 D/ ?# J) [$ W0 o

    1 y- x$ F0 ], y7 s- t* Q. F
    9 B; Y/ W1 Q8 _0 @6 r- z- m; f. I2 @, T+ F- o+ N
    描述Jsp页面的声明标记的功能、写法、并示例7 L/ I1 s2 j. l9 w/ n  V' D+ S3 s
    声明标记允许JSP页面开发人员包含类级声明
    : P2 s5 H! Y) S9 i8 L
    0 _, m* B  C! j& W2 K写法:2 L- s" P, J, d

    ! C( [4 h% Q& Y% n6 @3 u+ {2 o<%! JavaClassDeclaration %>
    - ?7 V: T( W4 i6 T3 l' l* ]( x7 l- c7 S' O& J) `: y
    例:5 E) c; x7 _7 m! P1 J2 |2 ^) Z8 E& R

    $ Y2 n* V) ^1 p% g) v$ u<%! public static final String DEFAULT_NAME = “World”; %>& a$ C' E8 C0 s& K
    6 c2 T- Z5 ~! q, d3 c
    <%! public String getName(HttpServletRequest request) {
    9 Z; L8 O0 P. Y/ f7 s3 z
    . I5 D( }! j) _6 o! F4 V5 wreturn request.getParameter(“name”);
    + D8 [+ T  j# M- m8 O0 ^" |! u5 b* w. t3 [1 q
    }
    " B; f# |# d1 A! ?: ]6 Y- {' p( B; S2 [2 ~0 a; l
    %>
    * n) W/ _( F  \8 Z1 |, J: H9 W
    , P9 a. R4 w: d+ A" j! X9 j<%! int counter = 0; %>
    % W: ~. `0 M( \: _( A, ~8 Z9 r& h! C/ c# C$ o7 Z* T
    . E  `# {& n8 m3 @7 b/ T, a

    ( v- `  T9 P$ G6 {, t9 q! J/ L1 t8 U描述Jsp页面翻译成Servlet的规则2 I- c( R- K8 d0 e* u4 @. }
    jsp中的注释标记被翻译成Servlet类中的注释
    ) G, ?: F% e2 g$ q) v
      u: _/ ]  h) P# S, d) Njsp中的指令标记被翻译成Servlet类中的import语句等/ E) T& d0 |. c; X8 `
    " C# e' V/ y; Q' J4 q/ E
    jsp中的声明标记被翻译成Servlet类中的属性3 g2 P# N. ?- D

    , H% x7 x/ x  l( Tjsp中的脚本标记被转移到Servlet类中service方法中的代码
    # [$ E/ S. E  ~! ^) a1 l( R) C
    jsp中的表达式标记被翻译成Serlvet类中的write()或者print()方法括号中的代码$ d/ c  q9 V; I8 S' `$ K
    6 `* J2 t. }7 a, Q3 h; z  D$ x

    ) R0 u2 c8 V$ Q8 V3 a; V$ e
    ' o* j; w  l: s' ^6 N6 n描述Jsp页面的九个预定义变量的功能、用法、并示例
    % M6 _1 h2 i5 L0 Crequest 与请求相关的HttpServletRequest对象
    ! a7 v$ O9 h. H# @6 }' l# ~& ?6 L
    6 t- P0 t3 z3 n7 H; b- jresponse 与送回浏览器的响应相关的HttpServletResponse对象
    5 r0 W) w* U2 J  B: d( S/ t2 ]: Z! u! [; h7 d
    out 与响应的输出流相关的JspWriter对象
    5 G2 D. k( p. m" m5 @! S
    9 J) S+ a! S* l( ?    session 与给定用户请求会话相关的HttpSession对象,该变量只在JSP页面参; y3 c+ }/ U( k% h0 ~8 C: n
    2 \) {' x, f" O9 z) G! V2 E7 m8 j% N
    与一个HTTP会话时有意义
    + |% T+ H) g' b. A5 R: a7 N! P  E$ U' b$ {/ H
        application 用于Web应用的ServletContext对象
    " k+ x/ b, [& G2 N8 {9 ~. B
    5 N8 c' U$ m8 `- B- Zconfig 与该JSP页面的servlet相关的ServletConfig对象4 T% `0 r+ _% r
    & |$ \& I) S+ f: G7 k
    pageContext 该对象封装了一个JSP页面请求的环境
    , f. o. C( p6 s. P5 r$ I% p! f2 n+ n) M5 \$ ^' q/ _$ o
    page 该变量与Java编程语言中的this变量等价, f6 G4 @! {8 ^( k% l9 ^! y  O# I
    7 k# ^) Z7 t; B0 B
        exception 由其它JSP页面抛出的Throwable对象,该变量只在”JSP错误页面”中可用
    ! K6 B7 L- J" e
    : j0 A: O% ]2 r1 S! G
    % I7 i4 X* s" ?+ ^  t+ [# s% Z3 J/ n# U1 K5 K: `
    page指令的功能,写法、并示例,并描述它的如下属性的功能和用法:import、session、buffer、errorPage、isErrorPage、ContentType、pageEncoding
    + v/ C& F$ t0 ?% c0 o) l6 Pimport import 定义了一组servlet类定义必须导入的类和包,值是一个由) @: `7 k* ~1 Y6 q) ^2 m' S
    4 l' i( {# I" t5 q6 d! L  v6 r" C
    逗号分隔的完全类名或包的列表。: s7 P+ t1 B2 f7 i1 {- I, |/ @
    5 r2 g/ V  F$ q, {
    session session 定义JSP页面是否参与HTTP会话,值可以为true(缺省)( N- ^5 w3 ]6 G# Y5 E0 N
      }' H( o& Z( X: H" ]
    或false。' ^, W* _! n. F5 W; x
    ; v  {) X/ H' a9 [5 [
    buffer buffer 定义用于输出流(JspWriter对象)的缓冲区大小,值可以为
    ' Q8 e$ A" B4 y0 \5 m& _2 d* y; X8 a9 a; W! X! ^& p
    none或Nkb,缺省为8KB或更大。
    $ Y! \9 U. L6 ^- u' z
    ( w4 I0 ~0 @- B* `. D3 P) z0 yerrorPage 用来指定由另一个jsp页面来处理所有该页面抛出的异常
    9 _7 n8 }8 f& H! \/ W& D% D2 O6 U) M8 h
    isErrorPage 定义JSP页面为其它JSP页面errorPage属性的目标,值为true或
    8 J* z( W) O% b
    , _9 @( J+ K: F* I+ kfalse(缺省)。- j4 d% N' [" K/ ?) j) h
    . Z/ o, r" d# b: h: m6 L
    ContentType 定义输出流的MIME类型,缺省为text/html。8 b4 d, I& T7 q1 J. _4 b
    + H0 N! W! S/ B
    pageEncoding 定义输出流的字符编码,缺省为ISO-8859-13 W0 y& Y! l( `# p7 b4 U

    - d' _7 q2 I7 p3 f4 P 7 `2 w2 H6 {* j) _/ g
    $ v" X. B3 R9 L9 M6 k/ g
    描述MVC各部分的功能?MVC的优点?MVC的缺点?1 c/ N. _4 ?+ F- ~! c8 N
    MVC各部分的功能:+ O* c* j* H( P( h4 ^3 u
    # D$ z4 v1 R& A: v' N
    Model(模型表示企业数据和业务逻辑)5 _/ @( L8 }0 S. L: i# Z
    % f6 C% J- ~. C% B: y$ y( Y0 K
    封装应用状态
    + Y. T+ G- T0 ?2 E# m9 L7 \( @, v$ ^; \0 P" }& i: x' U
    响应状态查询9 S$ T9 |1 O5 w$ `' F
    4 o( `* \) c* c5 e, N/ u
    暴露应用的功能
    . X; F) c5 _  E- L: S
    % O  A* p* p( u+ V, @Controller(控制器接受用户的输入并调用模型和视图去完成用户的需求)1 n7 I1 n) V) M7 h7 o' R

    / O) u) k: `7 ]  W验证HTTP请求的数据
    ( |# w, r% d+ T- j, N6 s
    - W8 a* m/ u8 u8 }1 r# L将用户数据与模型的更新相映射8 D0 g& e5 v* ^
    1 \( y  w8 ]; u
    选择用于响应的视图4 @3 J* o6 E. L( S

    6 g: o9 p( x2 v) d, k4 i& s& \) j. wView(视图是用户看到并与之交互的界面)& O* r1 L: O3 z, A0 f
    ( U9 O# A; q, v
    产生HTML响应
    " {; c: U7 t/ Z- f3 A; c6 T7 w: W
    ( S6 i! h# Z2 V请求模型的更新3 W' |5 @" @0 ^1 N  t5 j% ]& P; l

    + j, Z; N2 V4 _* l( ^提供HTML form用于用户请求/ V3 M3 j% a! {% m) f2 t" j

    3 r  t& m$ n0 d- y# T+ v. n- C) [MVC的优点:% u& |; C5 [. y- y+ p& {

    : q! s, x, u- g- x        低耦合性:视图层和业务层分离! b0 s- p# k% d  l3 S' m  }6 ]

    8 k( v' c' j& ?- y* Y高重用性和可适用性8 ^& G1 g# [6 u3 @5 N
    ! P! r" D9 a' T0 k
    较低的生命周期成本6 l+ d, d3 \) G3 C8 V
    8 T9 j, }, x( A; L, z5 ]3 H) x
    快速的部署
    ! B5 T0 ~4 Y0 v& B' w# Q' S0 z8 J! Z& c& `
    可维护性
    . w: b) }- J' F$ h, [$ }; q5 K; j3 O: V
    有利于软件工程化管理0 H" ?5 f/ `  ?; Y6 |3 W& r
    / I% r% p" [/ K; s6 E
    提高软件的健壮性3 g* u: T! g2 _# B+ ^0 p0 ]
    * a% A, c5 n4 Z- }: h6 ^& `$ j
    MVC的缺点:! g+ a# v8 K" N& J6 I
    9 g9 b! D& f# S4 u
            工作量大,增加工作的复杂性,MVC不适合小型甚至中等规模的应用程序
    . W7 z" ?3 f9 T, u2 h" F  z9 F4 g, v* w0 `
      U  N; b3 k: l: Y2 [- C6 R
    ) v6 J  G' N% j2 {
    什么是Model 1结构,以及结构中各部分的功能
    + C* ~7 L7 V# i* a$ Y  m结构:jsp+javabean
    ; S: `- k  v4 Q7 |% r. E9 Y( @7 h
    , s. ~" z- }( Q1 h: q% EModel1中使用jsp来处理web应用中的视图控制部分. \/ y0 K$ x: i/ `* B& Z) p* c7 V

    1 ]- t' T' K3 g* d9 PJavabean收集参数
    4 {! C, f1 W8 K8 ~9 b- q; _( S6 O3 y- |

    . I- H  ^) ]; E0 J' o3 X2 H5 g# e! d) s! S4 s1 V  b
    什么是JavaBean?
    , q" J! n7 A* z( V# }1 \0 H用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包,并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。
    $ T1 X- u; u& C; H/ _1 X
    3 a+ q2 [$ h8 U7 r7 Z) Q2 R' D. L7 S
    # x0 f; N8 V; W
    " J1 J  F3 x; t5 [JavaBean的规则?
    0 W  T% E9 L0 o" @  F& e使用get和set方法定义属性
    ; Q& q8 @6 Z3 H
    3 h/ q; S: R1 f. a$ W' N一个无参构造方法
    8 a6 C1 K/ p6 }/ B0 E! s) @) {  d( [8 o
    无public实例变量( 所有属性私有化)
    : d* i9 W8 l' B# B# D- e5 P
    4 x0 o* \) |8 ~2 q; e  l ) E! e1 I" @8 W% A, p  _! `7 b% O- ~
    , S( |- B4 u" y: R) V
    什么是jsp标准动作?包含那些?分别都是什么功能?如何使用?, o0 t$ D8 O$ z' `- B8 L8 Z
    JSP页面中使用类似于XML的标记表示运行时的动作
    8 q$ g: b3 |  C( I
    ' ]! b) b$ ^8 g+ h7 Djsp:useBean9 [1 P% k( ]) x; l6 R6 L$ K$ q

    ; s- z( Q* C: J' `* @& @6 sjsp:setProperty
    $ ~/ y* z3 h  }; C3 q
    . v& c% g, [  \. Wjsp:getProperty
      q  Q+ Y* N% ^7 g
    ) z0 w- J# o) G# ^! [5 Y7 h3 xjsp:param7 t8 y' i! d0 U; H% l3 I

    ! {) T- m$ a  M6 a; ?6 x  }jsp:include
    8 q3 d2 ]+ A0 @4 `
    5 q' S. x" q5 m/ Xjsp:forward
    & o; F$ Z# [3 l3 X, D4 f2 u: \, _
    0 h7 k: N& P- ]" h3 K( e' T 3 J- p1 x# S  o! p
    8 o$ G9 V* K( |. h2 I
    用代码示例如下标准动作的使用:useBean、getProperty、setProperty
    ! |, O  {5 m' s  [( q2 }# S<jsp:useBean
    9 S/ P% K! e% a! H( m2 b
    5 z: V; G  N: q4 }% `4 ~, H9 tid=”myForms”" R& a9 A1 n/ ?. g

    & E+ x" ~& W+ Q/ ~% {class=”com.base.mystruts.forms.MyActionForm” scope=”session” />& X, q7 H$ n; T5 N8 n, u

    ; j# p5 W" r3 _0 ?: v) O8 f9 E; u- ]    <jsp:setProperty name=”myForms” property=”name” />! o3 R9 k# g) P' i

      a# {) s& m+ V( h& g<jsp:getProperty name=”myForms” property=”id” /># I" S) a6 T8 l; J1 \- |" W1 W

    ' P) i5 T$ J. C' d6 L& s + t. n$ f: \4 R
    % [, L# y1 n! j. L1 K
    描述说明Bean的四种scope
    ! |' m" L. T% dpage
    ) J* K" T* b: t) d2 D# J( L& x" E' Q% q+ i8 o+ c  l: ~1 s
    request2 h* ~  Z; P: R$ x" h4 k2 t# l
    * L* D4 c# @2 o$ y# r3 H" q
    session0 X( g4 t/ p- Y+ j9 d" p
    5 g' A) [+ t. J5 Q
    application. N9 ]( ]9 F1 J$ c; d: Q) d

    + P( j1 s% C" W8 @; `8 I
    2 [+ i- c- k0 M1 t% O  t
    9 w) ^' x6 t# O+ Y: @0 Q4 |7 {描述说明页面上的字段和Bean中属性的对应规则) z  J7 T( W# A+ G' p3 h
    id 指javabean的变量名' f' B8 [( d5 {" Q1 q5 U4 F6 M

    & z0 j# t3 E# ^2 v" v3 @9 Oclass指javabean类的全路径+ h% h, ]# j, H$ o2 x9 B' s
    ( M. M7 M4 V1 T% S" F1 T5 p
    scope指javabean的应用范围9 M' q6 z7 e+ M( q" p" J: s" L
    , ~$ H& Q6 g: S9 c- _
    name指所用到的javabean的变量名- Q1 h7 m% f9 W  w

    - N( j4 y8 A6 \+ D- T    property指javabean中的属性
    4 I( Y  {$ f" h4 K8 c
    1 n7 {4 E9 z( T 5 ^# s0 ]' w& Y) r1 i5 r) z7 _' t
    ! k: j6 f( L1 f0 u: w
    描述useBean动作的处理过程
    7 a8 ^1 @8 V" I4 x) B% Z. I7 r使用id声明变量& y6 b& Z) u& k" V2 C2 b

    " V2 z. P" _/ O6 O试图在指定的范围内查找对象9 v4 u$ v- g7 T
    $ B  f. y# R% l/ k% X
    如果没找到1 m4 Y8 @" S2 I

    ! ]+ i9 w$ z- V' A创建一个类的实例" K3 Q& R7 t9 R& d% k6 b

    $ d: }6 {3 S6 H* s0 z' S执行useBean标记体初始化对象
    $ q2 D9 I( s- j. `9 P1 g
    - \) w1 @6 b% G8 f  s0 V  A$ u) e如果找到4 i9 z+ o3 B2 k5 W8 c# g+ O" m
    # \) T4 ~& ]# N+ b! N; |' {
         将对象转换为类指定的类型+ A3 {  O. w' ]' v5 v  j
    + ]8 z; `+ x" P( i

    3 q5 S$ o5 {! @, J+ r# K, N" z  F" ~0 V. S' K9 C* m
    描述forward动作的功能
    . W( `/ O9 X3 J" n* q3 \3 V使用脚本代码处理请求时,可用jsp:forward 动作产生一个不同的视图,
    & O6 \! Q/ Z" P7 _& b9 |
    2 z4 U  }# J( G& N6 |7 I使用同一个request:7 m) m' N7 G# g9 v/ Z

    ! a# z& W/ S/ J! i* V6 V
    ! ~2 ^+ l' w# `- Z  N
    ' f, {, a$ ]( G! }+ d" J什么是Model 2结构,以及结构中各部分的功能$ Y% ?8 b/ C5 W
    jsp+model+servlet2 @" Y, c" l1 B# ~. l* ~' O9 U

    % ?6 t! y5 X* I, oModel 2架构使用MVC模式,JSP页面充当视图,Servlet充当控制器3 F1 W4 w. E; f! E* S6 Z

    & u3 A( L1 I' C9 kServlet控制器:
    $ U2 F% o4 S. `2 a' U: k
    / t8 S1 p; [$ i/ N+ d验证HTML form数据
    6 h- U& j+ o  ]. R9 l
    9 M5 g, @1 u7 Y. l& r& G$ A& l4 b2 y调用模型中的业务服务3 H2 t3 Q8 J6 C: k, ~

    - y' @  J. \, y6 S9 a) j1 s+ J存储请求(或会话)范围内的域对象8 c$ K" R3 h! b0 D

    % W! g" Y" e# z3 F4 r$ j* Q选择下一个用户的视图8 E- A" {- [% a# m: k. z, b
    3 X$ Y& F' g/ e& m3 `6 B
    JSP页面视图:$ U7 N. Y& g* _9 K( u: }  G
    0 q% s$ y' j% c; s2 K
    使用用户界面(在HTML中)( ?  h! Z5 l0 n; {' a6 j+ q
    % c9 ~! m- c, f) l9 T4 w
            访问域对象! ^+ `, w8 m- ~: Z3 W

    8 W2 i3 Z. p# n' ~# a3 w1 [, Q 1 a2 f5 R  W" |! l3 R9 P
    ( @( \+ O8 ^: F$ L  z3 |1 m
    如何获得分发器?分发器的功能?
    + _- _  R. @( [' ^2 B上下文对象中的分发器:
    7 `+ t' O0 Z* m  l- _% x; z1 z' N: _7 t
    ServletContext context = this.getServletContext();
      ]8 B5 n$ ~' P7 F3 r% Y2 j& ]/ @  K, U4 {
    RequestDispatcher servlet = context.getNamedDispatcher(“MyServlet”);
    ' `4 x; \. _' V6 _5 w2 N& T# j5 F
    2 Z" j2 e* {9 a- Nservlet.forward(request, response);6 _, ~% n% m' i, ^; V3 n3 O

    1 A. k: R) J( q请求对象中的分发器:
    , M5 R& T( w- y$ j: Z, D
    ! ~9 B6 X4 R# M2 w- kRequestDispatcher view = request.getRequestDispatcher(“tools/nails.jsp”);9 S8 d1 V- \5 s3 _& m+ Q  X0 e
    5 [. t. \3 F. Q  }
    view.forward(request, response);
    ( O$ e3 r7 k5 o  Q) a! Q' v2 x! u7 V0 e( l, R* ^
    可以将请求转发到另一个jsp页面,并保持请求的传递性6 x2 Q# J3 t+ N) J# E; i
    % L+ U! z0 b& B, K  k3 e

    # _; W  O; U1 o" P# J+ ?$ N. b4 k9 a. W# `( Z$ o$ ^* y6 F+ p7 k- c
    Jsp中页面跳转的两种方式?
    ) M: A' n% G( l2 M使用分发器跳转页面
    ! Y2 Y( q8 ~: M% u* X6 [% dRequestDispatcher dispatcher = request.getRequestDispatcher(“url”);
    # j+ |3 s" I0 n$ B9 B  i# A3 [3 m8 B
    $ n# V/ B% b/ ^: M2 G/ Kdispatcher.forword(request);. z& l5 t$ u5 Z

    ! A( I+ Z/ d  T7 {; ]8 S    特点:保持请求的传递(上一次请求中的数据,在下一个请求中仍然可以得到);
    / S6 P( x6 [& W* ?) v6 p' _  s/ ]9 [3 X$ r& K
            转发的页面只能是同一个Web应用程序的其他Web组件& R) m6 {; k, E2 A$ ]! n6 L4 _
    8 y/ b& c/ s5 Q5 a; a0 v
    使用重定向跳转页面
    7 P! D1 O8 ]0 J" i3 s3 z: L0 z4 ]response.sendRedirect(“url”);
    " z( @8 X7 r" W7 K. k3 D  d* a5 q8 I: t
        特点:产生全新的请求,(上一次请求中的数据,在下一个请求中不能得到);
    . b/ Y3 @) F  t" N) O2 r) w4 [
      t1 [& |/ n& @3 ^3 f- h        重新定向的页面可以是任意的URL
    5 ~6 B3 k3 E. `2 j+ h) d
    % H% N& Q  r$ O
    3 I  X" _7 M' e  l: s+ s
    4 n7 C1 k( Z7 P# S# E描述Jsp中引入另外页面的两种方法,并比较两种方法的特点?
    ( w8 |6 B6 K( w. N  O<%@ include file=””%> 在编译期间把另一个页面完全嵌入这个页面,可以说是一个页面1 V1 _- j$ i4 m

    # j0 S, b2 n* y; C# ]0 M- ?在这里可以共享变量
    ' o0 x' y) O- ^3 r" V+ v) u
    & I: y3 y$ r" {<jsp:include page=””> 动态的再运行期间把另一个页面加入这个页面,可以说是两个
    % t% D$ h: V# u" o. O' h: [  `# g" h2 V* U' _! ^0 Y
    页面,不可以共享变量
    # V& S: S8 r! Y& ]$ C  c6 [5 G
    & Z4 w8 S6 h' p) U# u $ R' A' _0 F0 v# [

    ) ]3 Y1 y* i* T% }$ I什么是自定义标记( _6 W, T( N9 Z3 g% ^" ~# t3 G
    自定义标记库是一个Web组件,1 h- ~2 m8 B" Z5 J# n! J
    + @; M6 f& u  A  F3 k' _6 k- S: R1 p
    包括:
    7 s: Y0 z8 v* v" O7 J2 ^4 D  m0 y# @7 O! O/ [2 J7 y8 V
    一个标记库描述符文件(*.tld)0 [5 K: c6 K0 h8 \) i

    ' t' Z# X0 \. y' j所有相关的标记处理器类(*.jar)
    1 G- L: X" b  w1 Z- U; b0 g
    2 y% \: y0 g& K& P 4 z' h  I7 T+ f  u" d

    ' p# C1 k$ b1 Z% p; @) N描述使用自定义标记的步骤,以及每步详细的工作
    ! L( B' Y* W; _使用自定义标记前,要拿到.tld和.jar两类文件
    : l( N, a' \* h5 r- u3 Q
    + w; I2 I7 h1 j" k9 j7 ?8 d把.jar文件放到WEB-INF的lib里面。: D% _' {9 E8 b+ W$ t$ q  S
    把.tld文件放到WEB-INF根目录下。
      h& c0 f. `8 y/ r* B在web.xml中配置。
      Z4 c9 C% }2 D4 C3 L* R$ h<taglib>
    - l' P+ t% x# Y+ I
    8 X! l1 a5 v& A: j9 V/ G; A# l<taglib-uri>http://java.sun.com/jsp/jstl/core</taglib-uri>0 b8 Q* M1 M6 v
    , ?$ Q% c7 [0 C
         <taglib-location>/WEB-INF/c.tld</taglib-location>
    - Y7 H) P  I0 L3 x5 [* r
    7 p4 \9 p. J# J. A& |- R8 Y6 n) q</taglib>
    . J7 g, j/ k) x( o( j5 E, f! R7 H  D9 w) O
    在页面中引用。: w( n6 O1 K: o  ?0 I
    <%@ taglib uri=“http://java.sun.com/jsp/jstl/core” prefix=“s”%>
    6 l' R2 U1 G. Z5 l9 s
    , i/ u) [0 y. r3 x/ `" puri必须与web.xml中的uri对应8 B9 O* T; B3 q3 \1 P7 A0 s

    ! Q1 J' Q1 p0 vprefix是前缀,用来区分是哪一个taglib
    ! D( h7 {4 m# O( A6 ~# c' M  U- ?
    使用标记- g' O) I3 W4 v8 L. G" o
    格式:<prefix:tag名称 属性>
    - [9 O1 `1 f5 ]& Y% Y" V# d" |+ Q3 j# K
    <s:forEach >
    回复

    使用道具 举报

    admin    

    1244

    主题

    544

    听众

    1万

    金钱

    管理员

  • TA的每日心情

    2021-2-2 11:21
  • 签到天数: 36 天

    [LV.5]常住居民I

    管理员

    14#
    发表于 2014-12-03 12:45:59 |只看该作者
    在tomcat下配置数据源7 B" u$ v# G1 [- K! D+ F
    1、服务器与数据库的连接1 E; ?! _* l( \' c
    & F/ X2 w( E+ H7 @1 T
    配置server.xml文件" N. u4 c' X; J$ Y9 W

    " |& e* b2 r. d9 V  _8 _4 c" h1.oracle1 k) H# |! D9 b: s& H

    9 A9 [, q% G2 J8 {<Resource name=”jdbc/company” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”
    / K/ R9 x) _8 m0 B) s# j* F: R' t$ G! h) t+ A
                            factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”
    , ^9 F* u; Z1 E6 D2 v8 X% c+ j% [0 M7 |- h. G
    url=”jdbcracle:thin127.0.0.1:1521rcl”
    5 Z$ L5 }+ x$ n) I/ ~) E0 [# |# h* ?  S
    driverClassName=”oracle.jdbc.driver.OracleDriver”% y# _$ q% Y5 Y+ ~2 e$ ]4 ?

    # l6 \: {/ n- \% O3 {* b7 Zusername=”aa”* p# g* t7 j) K0 f* p0 j
    1 F+ Y5 F+ E0 g2 f& t3 J: j8 v
    password=”aa”6 Z7 a4 A& m3 v6 V3 k' @7 v
    & s$ s2 p4 r+ a1 T  t
    maxActive=”50″" I$ Y+ t: G" m! F
    0 r  v6 N) S& W8 n/ e  {
    maxIdle=”10″
    & }8 a, Q% K% E3 b0 q9 W2 [: L  R8 v& }) P$ Q" X( C2 P
    maxWait=”-1″
    & Y$ A/ V: ~9 J- d
    , k8 I# h5 `, A! F3 K$ ?* {/>
    7 V$ M/ k9 {# _# ^! a" d5 J3 Y5 M. _2 C$ |
    2.sqlserver
    ' f9 [# X; p/ O0 C7 \7 \# E: m0 t5 g# Y' l) g) U
    <Resource name=”jdbc/webpage” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”8 u! l& @2 X7 ^& I

    6 S; Y* H0 L9 q: {        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”
    % ~0 @+ y" J, `& G( S& v7 n
    5 a! t/ G* z/ J6 T1 E2 \: Surl=”jdbc:jtds:sqlserver://localhost:1433;SelectMethod=cursor;
    $ O$ }% S$ V$ _  E" [* p# K6 ?6 U# v
    DatabaseName=webpagetest”' r9 h$ G) b6 q6 f7 u' N

    0 C% E! {- \* B& zdriverClassName=”net.sourceforge.jtds.jdbc.Driver”5 A' p' P: m- v% b6 d9 ^: Z

    ; ~+ m1 W) C- u. A9 Kusername=”aa”
    . e- _* ~) V  E2 v: F/ V1 `# m4 Y
    ! W8 A3 V8 F. }' a& h& jpassword=”aa”
    ) K, O+ d( s7 U
    # q, T# p# X. f9 a8 fmaxActive=”50″
    2 T5 Q# p$ w9 g& I) q1 W% l1 c+ a" L6 q" N
    maxIdle=”10″
    * k2 L: m: k( h# L: @9 }5 T7 K
    ) X5 l) o. q* s5 M  B$ _7 Y/ rmaxWait=”-1″
    - M, }7 h1 ~$ i
      z# Y6 H* j  j$ {6 R# Q' i/>
    7 H( Z, o9 ~, p) B& _8 s+ k0 C  n! ^% w. n) D. _& Y- _
    2、配置自己的web应用的xml文件
    % o  ~" f! N5 P6 R! p& N) p+ D4 n' H- k& Z% ^' E

    3 a/ [- o6 k9 N0 Z
    0 H- n' R: j1 j3 f1 W# \' c<Context path=”/eb03web” docBase=”F:/workweb/eb03web”
    $ v7 t  J. i1 P( f
    * ^" W. Y' A2 z! I  wprivileged=”true” antiResourceLocking=”false” antiJARLocking=”false”>' g" J) I5 ?1 L7 Y3 G
    & Q. W1 I! p; v. t% O7 `3 }& l
    <ResourceLink global=”jdbc/company” name=”jdbc/company” type=”javax.sql.DataSource”/>
    ! n1 x3 q8 i+ x/ R9 y, E6 d8 U$ w6 ^7 B5 q8 Z0 t( A. a( j  V
    </Context>6 H1 `  t) T& @' I
    4 m& H6 R! _( n+ K0 v

    8 w. `2 P/ H9 E4 ?  W/ J; \' o( s0 a' v3 \2 \6 K) M$ i1 O
    3、配置web.xml文件
    . S% C- P' C9 G! G8 j! Z$ e, _
    6 f( J5 `! ]0 j; [' s% P与服务器建立连接
    0 w# O, t  w* T. t8 C* O4 N3 k9 k4 f# j
    <resource-ref>: p; r- w/ y) r3 l
    4 k0 A& _6 K* Y0 M
    <res-ref-name>jdbc/company</res-ref-name>
    : d; J$ c- b6 B# U% ~/ H( H8 i' N- i4 Y2 Q
    <res-type>javax.sql.DataSource</res-type>
    2 e8 `; f4 [9 S6 T, c: }" }# |2 T- k& _; z
    <res-auth>Container</res-auth>& \4 I1 ?& @# D5 S/ h1 R

    * u% E- R8 Z" z/ i# N" t/ f2 B</resource-ref>; M. k: ~" G& ?! V

    . S+ r$ ^0 r; C2 j. i4、在应用程序中不直接与数据库连接,通过DataSource连接池建立连接
    : }( e6 n: y% L1 C3 X7 ~8 R& [, U: c+ N$ ^6 f
    //1.在程序单独用时设置系统的属性,在tomcat下可以不用配置,3 U& N' F/ s$ {8 s2 _) ?: U

    7 o2 B! B! m; u% k7 _( gSystem.setProperty(Context.PROVIDER_URL,””);
    3 @9 @, L! i% C5 G2 R; a
    3 N5 ]* T/ O! xSystem.setProperty(Context.INITIAL_CONTEXT_FACTORY,””);4 r9 ?5 C. p7 N7 J) d2 i

    # k/ J+ c9 y8 N; ?: w//2.创建一个上下文对象
    " V- U% A3 s# f# z. \" ]' A) m0 U3 I
    0 _& P( n9 X- OInitialContext context = new InitialContext();% ^. \6 F7 ?6 s; h
    ' P7 X" d' I3 N9 x
    //3.通过上下文对象在连接池中查找DataSource
    4 s5 \( o0 {+ t
    7 r. u5 Z- P( }" S  pDataSource ds = (DataSource)context.lookUp(“java:comp/env/jdbc/company”);* M! n0 q& U* X, x$ k/ X1 F. c

    6 n4 O* _5 F6 w# L+ F; |//4.通过数据源建立连接, {* h2 @( U8 u9 \  ?# C" T

    1 N* X6 `+ [# S7 v% I, Jds.getConnection();
    回复

    使用道具 举报

    admin    

    1244

    主题

    544

    听众

    1万

    金钱

    管理员

  • TA的每日心情

    2021-2-2 11:21
  • 签到天数: 36 天

    [LV.5]常住居民I

    管理员

    15#
    发表于 2014-12-03 12:46:30 |只看该作者
    ORM对象关系型数据库映射
    7 P' ?& w7 @  g2 p! y1 y0 ?- G(Object Relation Mapping)7 j, @: w; U/ o% p9 H

    7 }0 b& M/ q6 r6 W! R: P一、映射的特点
    4 r% n) F' i4 S" I1 |0 j" T- R5 O9 ], d, q
    1.一个对象可以对应多个表9 r# C  |) n2 T' y8 A  V- y

    / P7 U# a! l1 L. b' k& x2.一个表可以对应多个对象
    & N3 Z& g5 _6 n, ?1 d2 h$ a9 W* S$ \5 p4 m" `% H
    3.对象和表的关系不用完全对应- w+ m' G/ U( }

    / z. c5 d$ o, m9 v5 V7 E4.对象的属性的名称和表字段的名称可以不同
    6 ]; h$ M6 z% F; T. G; M9 h/ [/ p7 g( g
    5.类型可以不同,但数据类型之间可以转换" `/ Q# T# ?! ]/ m$ U8 S0 y
    - Z) M' @! Z9 R0 b" g+ q# K# h) Z7 g
    6.对象中必须有主键,数据库的表对主键无所谓  V, {, p+ D; m
    ( q. }( L# R! z" [2 [+ U* l
    7.数据库中有主外键关系时,对象中可以有,也可以没有2 n! D4 e. X: b2 E/ M+ |7 v5 c5 A

    ; z$ v8 p* `6 t8 R* @# k; \2 @
    . R* L- I' N+ n0 F/ O+ ]! w6 N7 g  W" @0 D( d3 @3 W9 T
    二 、有一个映射的描述文件————>xml+ |9 X; e: K+ M3 ?

    5 h2 q& H" r4 X5 d2 E% w4 D- @' U三 、怎样实现描述文件————>一段程序
    " ]" b+ w; ^; f- ^
    2 v$ u; Z/ ?4 ^1 {2 s  F2 w9 q对象 映射(mapping) 数据库
    9 v/ f. D+ q6 t) z* T: _: v$ Q/ Q. i& Z: G
    user4 f0 v9 z) o! C% T6 j' y

    0 {, ^+ ]+ h" A6 kid=11
    + N1 i/ g# L) h
    . @3 h0 A/ i  B  G0 Y( v8 L6 Iname=”张三”———— > (1) —————> tbl_user(id,name,age,tel,address)# g( J) m; Z$ H$ O
    ' m! `6 d3 c3 l4 i6 [0 X
    age=25 <————(2) <————) T' g- Z: s9 R5 z* {8 m. F
    0 f$ l& Z* Q+ C1 `6 L" Z$ W. X

    3 ]7 m% _3 E' d
    2 [  k) \$ n& N5 l(1)从对象映射到数据库# ~# ?5 v. ?7 }" `6 y' V/ y
    / ?* _! b4 ?/ v" s& m
    1.JDBC) u: [' H% a4 w0 g, p2 a7 G

    , A! {/ x1 G2 s5 Q2.根据描述文件来动态拼接sql
    . e' o4 e2 G& Z
    # T8 A) I. E2 k" [- i3 R) u3.执行,添加到数据库中; c) n( q/ L( |6 v* m

    ) y4 j& M* i4 q2 @' _ " X( E8 Y- }9 |

    % F8 n" K7 N# C6 [(2)从数据库中映射到对象
    3 |5 S1 E# i; g* z7 G5 Y4 x% N0 n0 e1 ^; H' m! r  R3 C
    1.JDBC
    ; u' u" L' G. z
    % L+ f# O! @) O( v8 q0 U8 m2.拼接查询sql
    7 G8 w: U( G/ j) _* q
    3 |% M0 g- V* `3.ResultSet
    6 `' }, a) D; U- c" x$ X
    & L, t: E9 B) F; l7 C8 ?3 K0 c4.Model ' E9 m5 G* Z4 h
    ( G0 f9 ]/ G% D" K4 P

    " K& k  Q* m8 t' r, K9 q& f  M; L/ `( i$ ~1 f7 W
    hibernate
    + l- D8 o2 P# V8 }; [3 f开发流程:! ], K+ w# W8 o" [8 T) B
    : s( I1 V$ E+ G& A
    是什么?
    4 C: _" O  }# T7 a+ d/ a2 ^hibernate是一种基于orm 的轻量级的框架
    . u& R" k% n& G$ F
    ; l' k% H, \6 X" A" X1 w! K 2 e- b& R6 p9 B- @9 {3 O5 Z1 y6 v

    + k* H+ b0 }( t4 `有什么?' ^9 H8 x6 d" V8 j6 J0 v
    1. session 保持连接状态(依赖事务和连接池)
    * Q+ m, G# g0 {  O0 E
    8 R& B6 n1 G3 W5 _8 W, s. C! Z2. Transaction事务
    6 `  q& k. G$ M/ `
    * P5 k  D5 b3 W* T3.% {( W; J9 _4 y
    Connection Provider 连接池
    1 _: h. Z, p- W+ b' b
    ( R9 D* F" ]5 U  t. w% B
    : {4 k6 }" t5 I5 r
    ! {2 X9 x9 U/ z0 p2 x能干什么?  ^" i& I; {6 Z& O; Q' O
    1.orm, v+ `5 P1 R6 \

    $ T$ X* q( i* c. U2.提供操作数据库的接口,简化数据持久化的编程任务0 W/ C! y% V9 H2 ^' i
    - q- s# E' @* i7 l% T! D2 G
    : \  w. C% g; x2 {

    - {$ B5 n; o# B" K% W. V7 w1 I" t怎么做?. J/ T6 {7 F! o# ~+ D( l' v0 p. C
    1.搭建hibernate的运行环境,将hibernate的包和hibernate所需要的包拷贝到lib 文件夹下
    8 r$ p2 P( j3 o# \0 `2 ?  x+ e  a5 `1 u$ D9 L* g7 r/ G
    2.O(vo)
    / \, Z" w* {$ P7 x
    9 a# `6 _% Q7 J. X) s- p0 A3.R (关系型数据库中的表), F! i" y) t9 C0 b% I: U

    3 `9 h, C. g# M0 R7 I! z8 J5 r3 i4.配置文件8 K2 `6 V6 F) V& u! O4 V- t- F

    . \9 @! N3 ~0 a. m! P+ Y; {3 k4.1 cfg.xml 放在classes根目录下,默认名字为hibernate.cfg.xml3 G. L- _' x5 K6 z* t! F1 z
    : g' c5 J+ L. ~: `4 }, k1 s+ D2 ?
    a.与数据库的连接5 K- n7 C. b8 c& x( y! F

    6 F+ R. [/ L) {, Z& Ub.可选配置3 @3 Y; X+ n$ k8 w5 e  k& P
    1 ^4 u8 [0 @7 J1 @, I7 ^0 u, b
    c.映射资源的注册
    ; ?1 c$ Q6 A: |6 ?9 X/ |  ^! `0 }7 C* v$ R7 `9 H
    4.2 hbm.xml文件 名字与类名相同 并且与类放在一起, p9 c5 \7 s% B3 k( I* V+ {. {

    8 ?! r: X% i+ H* N) da. 对象与数据库表之间的映射
    : D6 q* F( h7 M& j7 I" n5 ~# X5 ?' P8 s$ ^! f
    b. 对象的属性与数据库表的字段之间的映射1 g$ q0 N4 @0 i. Z* P& C: x
    1 c$ ?0 O3 v. f( e' s& p
    c.组件之间的映射/ B! a& ~& t! K/ P
    / P4 I( o/ M$ ~
    d.对象与对象之间的关系映射1 B0 l8 {. `# J0 t' j7 i
    2 t( K6 o) }7 q6 D
    5、客户端, m* f0 j* [1 R  `. ^0 N4 L8 H
    $ }- j/ H7 U  H9 a, U" Q
    1.得到SessionFactory
    2 q$ O) N  g7 |. \0 l
    " P% G" c8 M4 N1 x9 G2.通过SessionFactory 工厂来创建Session实例
    2 @  K& {: c( p' v
    3 O, D  B- f1 P5 L+ w! P: N% ^" H8 e3.打开事务
    5 \0 n' o; O) |! ]( q0 Z# {
    5 D/ E8 F2 D8 p5 X3 ~2 c0 X4.操作数据库# e, ^+ z' |/ X9 A

    / X9 V3 Q$ _; C- L) J; n& ^. f5.事务提交" s9 q2 s  E4 p  U! T% H9 f

    + D3 O1 f  x6 ?4 T6.关闭连接, x# i/ Q% w+ c. e0 E

    & J+ k7 [1 c; e2 m" D$ y运行流程:9 `; W+ I( i+ g. _& L; b
    . b" m, q  X. O. ]+ S
    整体流程2 ?8 h: `6 k6 Q, F
    1.通过configuration来读cfg.xml文件
    $ M0 b: L8 q/ \. w! a" d) H/ C. d( G; v( x6 D1 N% ]; u" i
    2.得到SessionFactory 工厂(根据数据库的连接来创建sessionfactory)
    * |; x. Y& k% q8 _/ g1 U& X+ Q
    5 o& O5 _6 V+ C7 t, n& \0 S3.通过SessionFactory 工厂来创建Session实例
    / Y+ n" ]! [2 f4 b- m8 A& K4 h) K- Z# I5 W( _' }3 j8 d
    4.打开事务$ z( I% \  _; s& s, s
    1 a; N8 f' o  g' H5 l1 l
    5.通过session的api操作数据库" i7 ~% H7 V1 w; Y, Y' Z2 T

    ; I9 \' L# U7 {: C) E6.事务提交
    1 u% o) u' Y& ?8 N3 k7 U& c# l5 I4 V* @: c0 L- q. f
    7.关闭连接
    ( m- K4 t5 F: H8 o5 e! r6 d
    & }# c0 m/ g7 k1 z: m
    / i2 j6 O( F0 t
    * G5 j& E7 u0 ], n0 r/ S0 |6 Ysave
    : N4 i  Y1 w) H: J1.to—>po
    + D( c9 ^4 G  [# o3 H, h0 `( ^0 ]/ K2 T
    2.根据model和cfg.xml中映射文件的注册来找到hbm.xml文件# b0 z4 x8 U* g
    , K, E* b. n0 U( m6 C
    3.根据hbm.xml文件和model来动态的拼sql" C/ |3 V; D5 `( F% ?
    ) K" U- i4 M9 ]9 {6 g( O4 H
    4.客户端提交或者刷新内存2 w4 H  _1 d. ?0 k% Z
    : |1 v- q' O2 A. H) r) y
    5.执行sql,值放到数据库3 G/ m' n  V, l" [; j# e5 g: ]
    + A# u/ G5 J' E# `
    " [- C& q! J5 @

    + R8 N/ S& R7 I+ ^update、delete% n/ G& A4 j( I+ b. \+ v" e
    1.根据model 的id在内存hibernate的缓存中查找该对象
    / @+ B( y! {2 D5 H" v& B
    ' ^  S- A2 ?8 V! ?6 ~如果内存中没有就到数据库中查找来保证对象的存在
    " _2 W: l2 U; ~  T
    : r" l1 E6 d0 z" g2.根据model和cfg.xml文件中映射文件的注册来找到hbm.xml文件
    + ]* H2 k- h8 D1 C; c, |& ^
    8 r: j2 {( I: i( h3.根据model和hbm.xml 文件来动态拼sql' x3 |$ C6 m4 }) c3 N/ _/ h

    5 `' H- G) k, ^8 B- a, F4.客户端提交或者刷新内存4 o0 a: Q* j/ y
    ) _  x, z3 H, |
    5.执行sql
    0 T8 ]& Z" u0 N6 a" k* _
    4 Y% h3 z3 Z0 }9 p
    - G" X3 J7 v$ o* [6 C$ G5 ?5 p# P
    Query7 f4 p. t, m5 O  p
    load
      ~' ]+ J0 L1 t' w+ K% _6 [) O6 S9 N
    1.根据model的类型来找到hbm.xml文件$ X6 z% u5 K9 p% K9 G% ?
    4 i, y, Y0 S- r  _) [
    2.判断id对应的对象在缓存中是否存在,如果存在,就直接使用,如果不存在就进行下一步。. ?  x6 Z* V  R* P: p$ G
    0 D6 P1 K, ^+ ~6 y1 R
    3.用id做为查询条件来动态拼sql. I) h$ _* j8 j/ |9 u1 B

    1 N9 W+ |- Z) |5 Z4.执行sql 查询(先在内存中查找,如果没有找到(会抛出例外),就去数据库中查找)! q% h/ ?. n3 d* x' x) R4 O% ^

    " j2 i/ N+ u) ^+ }/ n& {; D: H; p5.返回一个model类型的对象
    / w& _, r) P1 K% ~1 N: a  v' k7 X. h) r8 B/ M
    get
    * c. H( g2 Q: v" r
    & w* A! P$ m7 E. F- N1 M0 M4 _    1.根据model的类型来找到hbm.xml文件
    9 X* M* D5 v4 B$ F$ B: M$ x. c
    % l5 v: v9 i- [4 l3 G! w' I( \2.用id做为查询条件来动态拼sql( I# {; l4 m, E% H& p; W! ]1 }
    # S* T6 z: L0 `! ]! P( M  G
    3.执行sql 直接在数据库中查找,如果没有查到就会返回null0 p$ A4 G! T$ @, @9 w

    - }4 H$ i) j$ b1 r' i$ cquery
    & E* I6 J5 b- d& R4 V: i
    0 C8 V. ~: O6 v, Y" V- u$ P& S1.分析hql语句,得到model的类型  Z: x/ l/ B9 d% A; d
    5 ~, q% n4 V2 i* e
    2.根据moedel和cfg.xml文件中映射文件的注册找到hbm.xml文件. R  P. y$ B3 E+ U7 D9 A

    / s. ~' k8 F  f) B' {0 J3.根据model和hbm.xml文件来动态拼sql
    % T9 ?( @8 \2 I" ~; @6 b& u! q8 V: P7 m# ]9 l+ B( y& S
    4.执行sql查询数据库
    : _. w" [+ s, n3 L" f# N5 F
    % @: o7 o( r6 J- g8 j- z7 a5.返回一个resultset
    . l! |5 X6 K9 X, I# C' q: e4 I' h! C7 a/ R, X* k6 b% N
    6.循环resultset的值,放到model中在放到集合(List)中
    . y' N! }# n5 c& ^$ k8 Y' {; K' h; Z, g1 @' l3 U
    * D- S: @6 v7 U# a) e

    . B% d9 a; r, u谈谈hibernate缓存机制" d1 q( ?' x* Y3 p5 ^0 X+ ]9 A/ s
    # D' r% k: h& I# v* y* Y
    缓存其实很直观的理解为放到内存或者硬盘上的一块区域,缓存就是一个缓冲的作用,有很多时候,我们的数据需要经常访问,如果放到数据库中,不是不可,只是效率上低,如果有了中间产物来代替数据库,就省很多事情了。打个比方,去买酱油,不一定一定要去酱油的生产工厂去买。代码中需要数据的时候,可以先到缓存中查找,如果存在,就直接拿数据,不存在就去数据库中取,也省了很多事。
    7 W: R- m) n: M& w" H% ^6 C9 r
    7 G+ l7 E" ?5 I" f  k1 n" p
    5 T' \0 T+ t* w+ U' o- W6 a) N$ Q
    , U6 M( U9 Z# ehibernate使用的是二级缓存,有两个级别,分别是Session,SessionFactroy级别,一级缓存是Session级别的缓存,Hiberante来管理的,这个我们一般不用管,二级缓存是SessionFactory级别的,可以进行配置和更改,加载卸载,就是我们平时用的hibernate配置文件中的配置SessionFactory的属性。' s! c) f3 ^4 o9 [/ E9 r, {

    " J/ |8 ]5 _8 H3 a, X/ _   ~; Z0 G+ @. ]( T) T' s
    4 h  Q" T% a/ \6 Y
    对一级缓存中的session事务进行数据的预存取,数据在各个session的上下文中存在(单例),当session关闭时,就是session.close( ),整个所有session范围内的数据全部清空;二级缓存默认的情况下是不开启的,如果开启,数据库汇总的所有数据都先copy到二级缓存中,这里要注意的是,一级缓存是每个线程下创建的session缓存区域,可以是多个,二级缓存只有一个区域 ,画个图比较容易理解。9 t( u8 C+ s' J5 G8 [9 Z

    8 q1 K% u9 v  S# \) | : t2 K+ B) a# Q/ Q+ h4 G! T* z
    ( t4 ?! ~; t) r2 C, N! B3 u
    | 一级session缓存| | 一级session缓存| |一级session缓存| |一级session缓存|6 @" o) G, [5 E# Z* @. q

    - e' ]4 g% B  L7 o9 ?: `( f5 {5 c, {| | | |
    4 _+ K0 k! _& `1 W7 D$ Z* U! Y
    . J  ]$ Q, F* B- S| | | |
    2 E& T) W# @/ y; A4 N) ^' U8 M5 u0 s, A' V! u6 P# S$ s
    —————————————————————————————————  @  J' G* U2 f$ B1 {0 c( u$ [
    & v5 s, y0 K/ p# ?
    sessionFactroy级别的二级缓存/ H. J# F. u( C0 Q, t+ C* C! d5 z
    , t: i$ j0 s9 j  R: s$ J
    ——————————————————————————————————————-0 h* X* V) k1 M# u" u0 |' X

    5 ?# I! H# B$ T7 M; b|
    7 ?3 U* ?" X# u9 p
    . O# j2 _9 P$ y5 |, i& m% F0 z* u|( i1 [( @) g5 W3 f. M/ d
    7 b! @5 E- Q+ u- `1 Q+ {
    |* X3 \" q" C! r6 k
    & }4 k% p2 o" [1 e+ j3 o1 k: k8 r5 K2 C
    ——————————————————————————————————————
    ' R( B( C: K: U. V3 k1 H# _1 c5 i. ~
    DB* R0 f: R1 c3 F" d( e8 s

    ; ]! j1 B8 N6 s5 t6 P3 w—————————————————————————————————————–9 d+ |1 N9 R/ o! ~7 Y8 s9 d
    ' |9 D% `8 \* s' `# H( f
    回复

    使用道具 举报

    admin    

    1244

    主题

    544

    听众

    1万

    金钱

    管理员

  • TA的每日心情

    2021-2-2 11:21
  • 签到天数: 36 天

    [LV.5]常住居民I

    管理员

    16#
    发表于 2014-12-03 12:48:12 |只看该作者
    Spring
    / i) i- N$ O' Y4 w8 `6 t0 b/ ^
    • 是什么?
      # h3 c7 Z3 ^9 B9 S! ~
      . a/ O1 x; l: G2 e3 e( \

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


    7 T# }" s8 O! ^
    • 有什么?0 [# G7 d2 K! v8 _- k
      8 H: v  P1 j: Z; M9 P6 t6 M2 R+ m' v

    & z6 \6 h8 A- X4 Y2 t/ j$ H

    每个包的功能:

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

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

    JEE :集成一系列的jee的技术(对JEE技术的支持)

    DAO:封装了JDBC;(对JDBC的支持)

    ORM:提供了对ORM工具的集成(支持)

    AOP :面向切面编成

    CORE:spring的核心包,提供bean的工厂和IOC容器

    4 K9 V2 G) k6 A8 |/ x% I
    • 能干什么?
      7 x1 a& i8 i) k
      ( I6 W; j( ^6 `8 S* ]0 V1 V* I  u

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


    2 V: ^$ [" X% w7 ?: q
    • 怎么用?8 U1 e2 n: k0 c0 l/ m0 C- w

      % y# ~) @2 T% V0 @! t$ y
      • 搭建web工程,引入spring的jar包2 j5 T) k4 N) j( B
      • 在web.xml中添加如下配置+ C+ _  q- l* H$ y- M3 |
        " w( i" u& t" d% ]% B
      : @: ]7 N2 C0 ]7 i
      - Y: z5 c6 P: i" n: w8 @

                contextConfigLocation" S0 j9 o1 V: m; `; X6 d$ \. ?

                classpath*:applicationContext*.xml  U6 }1 o9 J" G4 E8 F( F, w

       
    " \3 u- e- H- G* B  q& Q7 D9 L

            / h1 }+ [- c8 N# H+ L1 z  ]

                struts2( u: \1 v/ W9 Z$ c5 P% D! w  K" u

                
    4 n4 S7 b! l. ~+ J3 y# J: p$ s

                    org.apache.struts2.dispatcher.FilterDispatcher4 F3 L) j/ G7 r/ x$ V1 {( o  A* E

                5 g- u3 {: t1 s

            / w1 o( R) [  B7 V8 F" b/ l

            
    / o8 ?# @% B/ L- M0 @: @5 s

                struts2
    1 k* N8 Y/ m* }& M

                /*+ Y* ~( ?6 {! ~  I


    9 c) L4 K' j( D( V. y( p% Z  ^) }

    ( E5 F& ]. R0 J5 ]' \. W; B/ z

                # F$ U& a4 a* m! V+ v+ `% x, K

                    org.springframework.web.context.ContextLoaderListener, \: v& I& ?  S, E7 [; f5 p: B

                
    5 K) |# b0 g) _( ]! W" g% u  M3 z

            

    • 部署
      8 C. m5 F2 Y+ v3 a5 l3 Z6 W0 g

      # S% E, {- a1 C+ x, X- G2 h( T

    ( m, O6 N! [* k( V; [
    1 i! f2 K3 L# R% |, n* F
    + E# l" ^& n0 s6 x$ F6 z
    • 容器和bean& q2 o4 H, V1 Y# |( d0 S: W

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

    容器 :(与jee的容器类比)

    Jee :提供组件的运行环境和管理组件的生命周期(不能单独存在)

    Spring :提供bean的运行环境和管理bean的生命周期(可以单独存在)


    8 M, T3 Z% k8 F4 i- U6 k
    • IOC控制反转
      ' d3 S- m5 W; X! ~
      7 t+ c% a3 Q1 f
      / B5 o; ^) W8 V
      , A; J- t+ G& W4 n
      从前的应用程序想要得到A的实例他会直接主动的去拿,当用了sping后,应用程序由主动的去取变成被动的等待,由spring来控制应用程序所需要的对象
      ) N- Y3 t9 v: S$ H7 Z, A' D% X, ]
      • IOC的优点
        ' Q( z  C# g% t
      1.可以通过IOC来获得实例
      2.可以通过DI来获取注入的资源
      • 配置IOC的原则
          r9 q5 d1 L5 H' w& Z- @- A$ e0 q. [
        • 一定是可变的资源才采用依赖注入
        • 一定是层间的接口或者是模块之间的相互调用才采用依赖注入- E4 D8 D- w5 ~4 ~! Y3 E

    # E6 n& |* Z5 S
    • DI依赖注入
      9 |* M" b1 J8 V, {  \) W! o* {; q

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

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

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

    例如:

    在配置文件中


    & [; C+ U6 ~, r1 [, M' \
    9 V$ N' @& W9 P0 J; a- b5 h4 Y- b
    5 m7 f$ ?8 q3 v! h" l

    在应用程序中

    Public DBDAO dao ;

    Public void setDao(DBDAO dao){

    This.dao = dao;

    }

    3.构造器注入

    : ]" f9 r! K$ J$ ~- V; P

    4.ref 表示参照其它的bean

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

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

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

    6.lookup注入

    7.singleton

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

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

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

    8.DI的优点:

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

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

    " w! D' X+ P: ^  E" _' F* P' T, B) w
    • Aop面向切面编程1 ]$ i$ m: r) C  Y! M5 ]

      7 }: _  i' `0 [" x

    1.AOP面向切面编程 一些较好的模式或者是示例—-范式$ c; f+ w3 Q; p' W$ m! G7 d; o7 B

    切面:一个切面代表我们所关注的一系列的共同的功能点(模块之间的共同的功能点)

    2.AOP的思想: 主动—->被动(追加功能)
    3 S! t% m$ y0 @' m/ e: Y

    3.AOP 的概念6 g( S/ c- J+ t/ H% ~

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

    2.连接点 :事件的触发点(方法的执行)

    3.通知 :连接点触发时执行的动作(方法)

    4.切入点 :一系列的连接点的集合 (连接点的模块化)

    5.引入 :扩展的功能

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

    7.aop代理 :实现机制

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

    4.AOP的事件机制4 m: D+ ~' |" K( Z; _/ l8 L; {

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

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

    3.找到切入点

    4.确定连接点

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

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

      H& t. u; `/ |; f

    9 x6 o* ]9 n7 B) C8 K1 m! g1 t6 F; ~$ |, P: m: s' R
    " [  {2 O% I* J& b8 d3 T% }3 f- G

    8 v" `" @+ _6 |/ M& s$ I# {5 H
    8 {9 s8 z! ~: H+ T. A/ g* k8 W( A4 |; C- m, W, `7 B7 E* n1 a

    5. AspectJ
    % p" g1 ?( g! G: Q2 n+ c* I, ~( \

    5.1.在xml中配置比较烦琐  ]- W3 G8 D+ Z7 x! {* T  y

    所有的入口必须从一个代理(ProxyFactoryBean)开始
    # Q3 a6 B! L) F; n4 k/ @+ e

    5 y$ f7 ^3 X4 |% H% W0 z4 e! y- F

    / m% T  p5 f* V4 I$ U5 i' S2 G4 ?  v

             4 A1 a  p; @; o4 Y+ R
    6 a# W0 A5 d0 e  v2 X; w
    5 S5 U1 }& F: `& S% S5 |0 P! E' p6 R
             
    3 G( U) @! ^4 m! n

            
    5 {5 p. Q8 a+ B; O5 N/ A( e

            


    . `# t  w$ D- ^3 a7 g* {expression=“execution(* com.javakc.aop.MyTarget.t*())”/>, a. ~9 ?3 f; s6 ~& d' C. X+ {& Z

            
    * ~$ n! P4 T+ w3 y8 o; \" B% W

            # o! |$ M/ n5 G% D! x# }( J

       
    ' c+ Y& X, t; s6 k! T

    5 ^7 @/ P) x' B" q' J% ^0 M

    8 A& a( ?( x& ]  U: k& M

    5.3.使用注解的方法相对简单: T6 x  p8 p. }0 I, C" n* y

    @AspectJ的基本语法, p+ I+ v5 F! |! A: F

    1.@Aspect声明一个切面,将一系列的共同的功能定义成一个切面
    - J7 G/ E! k4 x4 v. c

    直接在类上定义@Aspect2 k8 s$ }2 A/ a- c& |5 s$ u

    2.@Pointcut声明切入点& x+ z7 g2 m8 F

    2.1、用一个专门的类来定义pointcut,类中的方法名就是该pointcut的名字% `% @3 k$ W" G" B

    2.2、可以使用匿名的pointcut7 g" Z( r, e, r+ f" Z! Z

    2.3、执行切点的几种方法
    & k! s. N9 p) [9 R) i. X0 T

    2.3.1 execute(public * 包结构.*.*.(..)) 可以指定到具体的方法
    , N# N0 `, B9 P1 t& m( l

    2.3.2 within 指定到包,不能指定到类
    8 q- e9 p# Q. f5 ~3 W+ @

    within(”com.javakc.spring..*”)
    + ^2 R; E$ v3 l* T  t9 @% m: ]

    2.3.3 this 指定到实现接口的所有的实现类
    5 A" z/ a9 f2 v0 d

    2.3.4 target 指定具体的实现类
    : L3 b) G1 ?: z4 V% l, ?! @

    5.4.advice的五种类型的示例0 U3 W; T2 I3 \# y$ q! t

        客户端必须从接口走才能得到监控,实现想要追加的功能
      ]) \1 X4 H# ]" n1 H7 d

    5.4.1.@AfterReturning(pointcut=”” returning=”retVal”)* w1 y/ b% r) Y; R% o

    追加的方法的参数名字一定要与retrning的名字相同
      H; C8 e& {4 N  M7 j6 B

    在注解@AfterReturning中必须加上pointcut和returning两个参数
    4 \" S' u$ }/ w

    pointcut指所要监控的目标对象的方法! D- n/ X$ H: U  A/ E* {

    得到目标对象的方法的返回值,来作为参数,进行下一步的处理,参数没有顺序,按参数的名字进行匹配
    ) @/ a1 a5 }: f1 g2 U/ p( x

    完成追加的功能
    8 b* [5 i6 ~; N2 t5 y

    1 定义一个pointcut,通过方法名来作为pointcut的名称来引用
    4 l) c( R. c, E: s7 _1 s

    (1).@AfterReturning(“com.javakc.spring.schemaaop.TestPointcut.t4()”)
    4 }: T: Q) E9 Y

    (2).$ v. B- X' F5 m: }4 ?

         2.直接引用匿名的pointcut
    1 Y: e; u7 D+ b0 T7 L% A

         (1).@AfterReturning(“execution(
    9 X" b8 B+ @; l4 m7 G+ m# x" |* ^

    * com.javakc.spring.schemaaop.Api.test4())”)
    + ~& l+ b% D% P$ }1 |

         (2).@AfterReturning(pointcut=1 X% V3 E1 P6 q* `# g  _* A% t( Y

    “com.javakc.spring.schemaaop.TestPointcut.t4() &&
    & W3 t7 ~! D8 {

    args(str)”, returning=”retVal”)
    . A7 g& @, ~; w' W( ^: Z$ i# A- X0 C4 O: L

    @AfterReturning (pointcut=”com.javakc.spring.schemaaop.TestPointcut.t4() && args(str)”,returning=”retVal”)- J% {* _" A5 ~* B6 B: _! d& N8 k# W

    public void testAfterReturning(String str,Object retVal){  T, B) U/ {' U/ ?

        System.out.println(“afterReturning1=>”+retVal+”=>”+str);
    : ?# F5 g3 |& H! X" z- {8 {6 \

        }
    + c7 {+ m- W& M$ Y; v- T. A: d

    5.4.2.@Aronud1 O. d: o, q$ B4 K1 I; q$ K# F) T

         注解@Around环绕追加功能;" P; }5 X. m4 @5 k+ `

         在执行目标对象的方法的前、后追加功能;7 t: q* W' i. X5 E  _" f

         必须有参数;第一个参数的类型必须为ProceedingJoinPoint;0 R& }9 s7 r+ R1 _* U

         通过ProceedingJoinPoint的实例的proceed来调用所监控的( N  @1 A% q2 @8 H

    目标对象的方法8 c& e7 R& [# k6 J& l: d1 c

         1 定义一个pointcut,通过方法名来作为pointcut的名称来引用
    " ^6 H$ n) }9 D; Q

         (1).@Around(“com.javakc.spring.schemaaop.TestPointcut.t1()”)  r+ j8 N6 p+ M! o

         (2).@Around(“com.javakc.spring.schemaaop.TestPointcut.t2()0 Q2 n; e3 m, w$ c' @& B- ?- H

    && args(str)”)
      y" W; o. c" Y1 j& \9 Y8 Q

    2.直接引用匿名的pointcut
    - ^# O" L! V# ~

         (1).@Around(“execution(' G& Z& ?9 ~5 \

    * com.javakc.spring.schemaaop.Api.test1())”)) V; B/ l  {% X5 o3 q+ H& ^

         (2).@Around(“execution(" H5 E* u) u9 C' m

    * com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)! ]: U, y4 r3 r2 ^7 f8 }

    // @Around(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”): m  D; w9 ^: U2 U! C+ `" k

         @Around(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)4 W) n  ^' p, l& L9 [1 O/ |8 x

    public void testAround(ProceedingJoinPoint prj,String str) throws Throwable{
    $ z# ]6 }% E( H, t

        System.out.println(“around1==========before1pointcut==>”+str)" K* V- b, @' o% {

            Object obj = prj.proceed();/ I2 m/ A# \& |  p% A3 T: U* o

            System.out.println(“around1==========after1pointcut==>”+str);
    ! l- y# a; R( `) F$ o- @

        }1 I1 w9 a8 V& y* J, d0 D" f

    5.4.3.@Before
    % y3 ^8 x: ?. Q. Y9 R3 j9 U

    注解@Before在执行目标对象的方法前追加相应的功能+ t" Z+ `, [9 ~* A- n1 ^

    1 定义一个pointcut,通过方法名来作为pointcut的名称来引用6 F( E! p, E- _. l$ z

    (1).@Before(“com.javakc.spring.schemaaop.TestPointcut.t1()”)/ @5 @. b* c8 M; |: y5 p

    (2).@Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
    9 X# @8 \, ?7 k2 d$ W! u; j. P, f$ b

    注意args后的名称与参数名相同! q$ |2 J+ x9 D- p

    2.直接引用匿名的pointcut5 M: I: f# a- u& k6 O! E

    (1).@Before(“execution(* com.javakc.spring.schemaaop.Api.test1())”)4 @, ^& h8 Y- v

    (2).@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)* u! x2 K8 w( L" ?6 K

    注意args后的名称与参数名相同; P" c! R" Z  s* H' A

    // @Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)% P5 s3 Y* b3 g8 {6 I  ~

    @Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)6 ?1 g; G+ T# ?1 e9 K& `+ A

    public void testBeforeParam(String str){
    * D! K6 w3 e8 `" `3 }/ j

        System.out.println(“before1=param=>”+str);5 p! Y$ M9 q) A$ A# L! B; L

    }$ b* Y% K5 G5 v1 I7 M


    - L5 L7 p: o2 q0 i3 R' f

    5.4.4.@After
    % @% f" C# Z* @1 v

    注解@After在执行目标对象的方法后追加相应的功能
    $ Z6 |9 J% T! M; b/ |

    1 定义一个pointcut,通过方法名来作为pointcut的名称来引用
    * k0 @1 c. U  u* F% a; I

         (1).@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)" c) `  @8 x) D# d( T' V2 d) B6 _

         2.直接引用匿名的pointcut0 H8 C' d: g2 g7 t) }5 @

         (1).@After(“execution(* com.javakc.spring.schemaaop.Api.test1())”)
    ' o3 J3 {# f$ ?( G

    @After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
    7 G/ `* Q; R+ n) k& p' x/ U- L# C

        public void testAfter(){1 s* o" U) z. K( m7 `

        System.out.println(“after1== >pointcut”);3 I/ q  @$ K7 U/ o' P  t: V2 ~. \7 T

        }  s$ f* i% t& ^+ B8 M

    5.4.5.@AfterThorwing
    " ^: [; O! P) p) `+ H


    ( s) X3 m+ \2 ?% u5 Q& t! J  B  \! q
    + U7 L( b  q" w: D
    • 描述一下spring中BeanFactory和ApplicationContext的差别, R2 L: [9 l, g

      * Z9 m, |: t5 `$ V$ |

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

    " \/ v, Y/ P" E# g& |+ F  K; L
    • 谈谈spring对DAO的支持
      # s5 Y" _' W4 V
        B4 ]" M0 ?; q1 h

    Spring提供的DAO(数据访问对象)支持主要的目的是便于以标准的方式使用不同的数据访问技术。
    $ G2 R9 x4 K1 M/ \5 n# @! c: h% g0 S" v

    简化 DAO 组件的开发。
    / M) t' @$ S3 DSpring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法,用来简化代码开发。# p# ?- r) N7 O$ o

    IoC 容器的使用,提供了 DAO 组件与业务逻辑组件之间的解耦。所有的 DAO 组件,都由容器负责注入到业务逻辑组件中,其业务组件无须关心 DAO 组件的实现。; @1 \+ t$ _2 E! A1 b4 }5 R. `

    面向接口编程及 DAO 模式的使用,提高了系统组件之间的解耦,降低了系统重构的成本。
    + P2 i* O. g  s$ m

    方便的事务管理: Spring的声明式事务管理力度是方法级。+ \+ t* u7 S6 k5 ^. y, k- k0 ^

    异常包装:Spring能够包装Hibernate异常,把它们从CheckedException变为RuntimeException; 开发者可选择在恰当的层处理数据中不可恢复的异常,从而避免烦琐的 catch/throw 及异常声明。. p. e) l$ |6 V: h2 A! F


    + Y6 G2 g$ A3 E" `, S! \. l/ n, S) l: x- G
    • 谈谈spring对hibernate的支持6 V0 B0 K+ n. Z8 i" T" P  @
      ( }+ Y- H- `* u6 x9 t+ [

    在所有的 ORM 框架中, Sping 对 Hibernate 的支持最好。如 SessionFactory 的注入、HibernateTemplate 的简化操作及 DAO 支持等。另外, Spring 还提供了统一的异常体系及声明式事务管理等。' j$ _5 l) _5 ^( _1 t

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

    1、通用的资源管理: Spring 的 ApplicationContext 能管理 SessionFactory,使得配置值很容易被管理和修改,无须使用Hibernate 的配置文件。详细配置如下:
    + v* t& e! r: Z1 J( P5 o

    . p3 c1 Z2 Q3 a& t9 A9 t8 ~

            class=“org.apache.commons.dbcp.BasicDataSource”>
    8 S! A( o* L( u, E5 d4 b6 g

            
    ( T, N7 ?1 {) [8 z

                oracle.jdbc.driver.OracleDriver, Y0 {3 T$ N/ U$ U2 h' H+ I

            
    " g9 m4 C% `% B) H2 c; f/ J

            2 r: Z( k$ _; \: K* \; ^

                jdbcracle:thinlocalhost:1521rcl
    ) n  ]* u! L2 g5 u

            
    7 l8 G+ t9 g( t& ?

            
    , b; R) F; r$ _- o/ m- Y; G( n

                javakc2+ f7 A9 P0 t& W1 {9 ^; R

            ; c3 N# O9 U$ ^! Q. k; [

            
    2 L0 F6 x+ s' K- a6 D- b; H

                javakc2
    4 W- o4 g3 q9 R7 V$ `

            ) @7 W7 l- V+ F5 U+ i

       
    ) w# n$ C" e3 J& P: B9 Z# Y


    0 B4 X( W4 B' V0 G

       

            class=“org.springframework.orm.hibernate3.LocalSessionFactoryBean”>
    & H7 _& D) C" i/ D

            
    4 L. b2 X1 D1 ^" K3 B( V' s

              t4 ~7 S. e! j' X$ Y4 k: ^

                $ I) h- K$ e9 \

                    com/javakc/spring/h3/UserModel.hbm.xml
    " Z% t/ z3 F4 S- v

                
    3 x$ |4 S. b/ v7 v' v

            ; d. H4 f  P) D- n$ k9 c

            . g' S! d2 R* x1 Z) S

                5 u5 R5 p4 x) j/ ~  G0 q! H

                    hibernate.dialect=org.hibernate.dialect.OracleDialect6 H6 _. }, j( @9 Q1 T8 r

                
    ) }8 d* x, W1 m2 L8 A; Z/ V6 P

            
      l# ~9 A' l4 V; v. |* W7 o

       
    # f  |  y" m( l$ l

       
    , r0 b) W. N$ j1 g' @; U

            
    / [; e" P. Q& t' P" T. |( o% J4 ]

       
    0 z" i/ |4 L+ u  `9 X( o0 \

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

       

            class=“org.springframework.jndi.JndiObjectFactoryBean”>* W( z; g$ D4 m

            1 Z  g9 V- a$ {" J+ Z1 L) }

                java:comp/env/jdbc/myds
    # S9 @  A/ x4 g0 J

            7 H# n) r; `; @2 Q

       

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

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

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

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

        * t  c  H  |2 a* [! x

            $ W7 d1 X4 @/ j; R. ^0 T

       
    * e/ X! P! s* n- \6 S# j$ Y


    + q6 S: O( X( A/ G% ]

        ( C* }3 U4 i$ u9 T6 s( z% s6 V0 I

            % V  s$ g' p3 Y3 l

                0 [+ N3 Y# m, Z& Y9 y  {

            7 x% }! U6 m7 w' E; Y

       
    / i( d0 z: W! F. D, [/ x

    1 B$ B8 b0 N+ y  B- w# _& F" o

       
    ) M+ ^6 Y0 a2 \/ t5 U

            2 u/ ^, F  N. ]5 S: k! `9 _

            ( E0 g1 ]7 x. {1 n& {7 k# a

       
    % `: _% g/ K$ V

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

    5 R4 v5 ?! Y+ m0 Q5 I  L
    Spring2.0之前事务的写法
    4 x- C0 C; ]+ I  N2 H# [  |" z

    # N$ `3 F/ o: \6 Z2 s- q, K8 _8 A$ ?: e4 g6 k7 C
            class=”org.springframework.transaction.interceptor.TransactionProxyFactoryBean”
    6 s0 h0 Y( s/ d' B+ N
    " j+ H8 G4 r: u1 R( {6 E
            abstract=”true”>3 I  _1 V8 Y. M3 L8 |

    " ?  U  A  Q, k+ e- K, h
    : f6 @3 r1 `( e4 n) b: G2 X
    3 \1 f1 d  l0 z% N1 v- p3 ~1 H* Q! ~; `; v2 s/ x
                    PROPAGATION_REQUIRED,readOnly4 J1 K: M$ t& H* c) _
    * y! ^- g- }/ f7 e. w3 V$ }
                    PROPAGATION_REQUIRED0 F3 N2 k" P2 q; G" O7 D% h! q

    * x# v- s  j  _* h7 F6 n
    - p! L: T$ ]7 P6 V' ^, j* j$ `9 P/ `4 M
    + |' s  A! h. T  I# e! K7 w  ~

    ; F7 j" `7 w( d  L7 C, M" e* G  |  n6 _% m
    • 谈谈Spring对事务的支持
      8 K' T" C/ Q  v; _0 G3 f: \0 H

      , g# D( E+ f0 z4 U7 }


    1 u0 j" n! h8 i1 L( ^) Q* ^1、声明式事务管理:

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

    2.做法:

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

    2.2

    2.3 注入数据源


    7 X1 b( T0 t4 x- K* i) v) f. L
      N. |& V# O/ |( G: i0 T! b
    ; j. R6 ^! F! W5 V! ]- h. Z% P) v) J: K1 y/ x, x; ~

    4 W0 r3 k$ E( y9 X5 h6 X/ L
    1 b2 g% `# k0 S+ ]$ ~

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

    & q+ p! k' l# f" ?/ B1 F
    4 y; k9 ?" }  q0 N$ F* l6 ~
    ) _4 ^( ~& e0 u4 W* K: Z

    2.5 事务监控所有的方法(事务加强)


    . g& V* p6 a- G1 O, L4 u+ C1 j
    1 q4 o7 i3 }. F! A0 p; A6 S9 e/ ?
    7 g# H  W, c. j6 Z
    - }( E4 z* C. D( I& v; o# c  y  |8 J
    $ k# P! y, ?( P1 W' y6 r* S

    2.6 定义切入点


    0 F8 ?/ N* V; P2 s, C- x) O. F0 Y8 C

    & _5 ]# \6 y1 w3 t" f  g$ `
    3 ^* r+ _6 X7 E& ~
    ) G. g* L4 H" y0 D% e: d

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

    1.注解@Transcational

    (可以在类上,也可以在方法上)

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

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


    1 x3 u1 Y) g% l, r, S! x8 b$ ]7 V6 p' u; j# E: q

    如何在Spring中使用Hibernate的事务:
    , C9 o2 o; V4 a* C( m& Y9 r* w


    ) e, [' K: t5 t* W# L9 i


    0 f$ W; d. s' U. V+ e% o


      Z$ }. R5 I" L- H; j4 p9 D

    如何在Spring中使用JTA的事务:+ b! a: p# z. h3 v9 D8 B


    % K8 b, n9 u# i. \8 }4 y- t0 e
    红红火火恍恍惚惚
    回复

    使用道具 举报

    admin    

    1244

    主题

    544

    听众

    1万

    金钱

    管理员

  • TA的每日心情

    2021-2-2 11:21
  • 签到天数: 36 天

    [LV.5]常住居民I

    管理员

    17#
    发表于 2014-12-03 12:48:32 |只看该作者
    事务( ^' |; y3 b+ Z
    ACID0 \" G+ B9 ]# ?# X' M. h
    (1)原子性(A):一系列的操作具有不可分割性,要么成功,要么失败: O0 y( h1 A5 L
    " G. |, T- G* s) E4 `/ k4 E7 R
    (2)一致性 :操作的前后满足同样的规则,保持平衡。8 t: ^% J8 K, C5 d& Q4 f' I
    , A# ^0 O9 r* G3 M8 L3 q
    (3)隔离性 :在事务运行的过程中。事务内的数据对外的可见性和可操作性(必需由数据库的支持)# D$ R! e( F$ U( o; g; P1 C
    $ O' {8 U% U$ }
    (4)稳定性 :保证数据在事务的操作的过程中不会遭到破坏,而且是永久性存储的
    2 C$ k9 ^3 J1 F2 p9 G; G# i
    - C9 [2 x9 b/ E
    2 Y9 A1 Z1 `9 b; p4 n5 w5 ]+ g0 m$ l/ d7 L
    事务模型: X& O0 n! |  \" O6 I% g$ v/ }
    (1)经典事务模型又叫平面事务模型(JDBC) 事务不允许嵌套8 d% ]& I: P# M& o) X7 c

    8 Z( I* b- O' |- I: c6 V& C(2)嵌套事务模型. O! i3 T7 F" J. m3 k( P

    ) y# ?" u* Y0 M  \& t% P" L" ? - W* D. y2 W6 x7 P9 }' r) f- Q2 L( A0 h

    , o5 d4 W2 w/ u0 @# r事务的两种方式6 M1 X( j- l" r) b1 b3 x
    (1)声明式2 D2 s9 y; r; f
    8 |, j: s9 m- b. ]1 ]# X( f
    在配置文件中设置以下6项
    ; }. p5 R6 R' ^3 r# l; ~6 T* Q+ W5 k) ]2 p0 M
    (1).required
    6 ^1 V5 \" w: B) J% W; l' S
    / @2 x% z6 z) Y) j% K6 }# V) c如果客户端没有事务 在bean中新起一个事务
    0 T& |" s4 ^0 d% z/ s3 A6 r2 [% f4 a, P" n
    如果客户端有事务bean 中就加进去
    , K6 K0 g  z8 U9 x3 X* v
    5 k5 e- r2 y* P9 a8 P( f(2)、 requiresNew
    9 ?- k# ^! M  k- W4 e
    " c* {% e/ d4 {' b% ~5 z0 E不管客户端有没有事务服务器段都新起一个事务
    # G1 G; U% o" E1 H5 A' C% u( D& b
    ( A* H  b& H: H9 u  ?如果客户端有事务就将事务挂起
      E$ [- b! e. c  i; }8 `! y& f) |9 [5 ]
    (3)、supports& o  I  @9 g4 j

    5 Y& N, R9 R; {- Y/ O如果客户端没有事务服务端也没有事务% p  Z' u; a% X- K4 r9 @9 a
    2 T9 t9 x# H; N% k/ S8 _! I/ L
    如果客户端有事务服务端就加一个事务
    ! c! ^( L% }. s' W2 S
    7 R, A+ \0 n$ F9 @, V. ~& T(4)、mandatcry
    * ^! |6 W5 p& ]* C! f) j
      g0 m7 d0 f7 \- `, S如果客户端没有事务服务端就会报错5 _- c9 X8 [8 }/ Q

    7 s' U& D% F4 A! b7 H; \如果客户端有事务服务端就加事务: U- r: Z( c0 [+ H# \- {

    ' j: j+ O  C0 ~1 B0 w2 l4 G& h(5)、notSupported
    4 C3 O( |: S# y" i; V  @& }4 ^. g# S, b
    不管客户端有没有事务服务端都没有事务
    # c1 _5 }: k; t! ]1 c
    7 @! i8 q7 Q  k! t% L如果客户端有事务服务端就挂起
      H7 T/ i$ Z, q" c& U5 i7 C4 u3 A
    4 M1 h' D! f# q5 d( y6 v" ?(6)、never/ f; `: F# S, O2 O
    $ L5 E5 E6 y4 s
    不管客户端有没有事务服务端都没有事务
    $ g6 w, c2 N2 \5 k3 d+ r/ h
    ' j4 G5 x6 [0 f  D# r2 [  i如果客户端有事务就报错
    & c/ R( q% ^2 ]* d$ [7 Q3 g+ s4 r
    ( l, J% `- g" `# y9 K(2)编程式事务
    * S8 N9 Z! v0 _1 o
    # B( r9 ]5 V1 rJavax.transaction.UserTranscation
    5 ~7 D7 V. v0 H; K0 m6 C0 ]* s" S) C  X9 b. L6 |8 a
    JTA 事务可以精确到事务的开始和结束
    7 U6 t& w( O- I& M- B5 j% _, l% C! D$ V( ]" ]; }+ V8 V
    7 t5 v) V7 C4 N- P4 v0 ~! E

    ( p' A* x6 C3 u3 d  J, d7 h/ Y7 x事务的隔离性
    ( l5 |+ J* W& _) PRead-uncommited" F5 ^+ o0 W$ l8 P  s' U6 m
    ) _- N, n, V* `* y9 f* q
    读取未提交的数据(基本上没有锁)脏读,存在不当读取的问题。1 p0 I+ H/ _% F: N$ R: E

    . l/ ?! F( a: I/ ?6 z& `" r! BRead-commited
    # `7 {" {6 z. q+ U2 a8 i' d( e1 _# D" m; ^
    读取已提交的数据(行级锁)/ j/ [' F0 @& Y8 j; D9 x
    / ^1 [0 ]% F4 ~- z
    无法读取已经写入,但没有被提交的数据。2 w- A+ P/ O& t2 V! l
    % Q' ?# z! O9 ?! s/ I
    Repeatable_read
    ) z) X2 O3 q9 ^# [; C6 U% W% [- f1 c. J% B
    读取的数据不允许修改或删除3 Z6 L6 C0 E9 J1 Z0 \8 N
    + b, E: i; w3 Q( l7 c2 t
    不可重复读(行级锁+不允许修改/删除): R, V9 m) S; C  y

    # D0 ?! ]; ?. r* fSerializable
    ' `. _0 E$ Z; N! t( H0 `
    , r$ u' {8 n5 o* w幻影读(表级锁)
    9 J5 h% V" C. E" y/ u) m, P7 B) P) b9 {8 c9 I1 K, h- R
    0 R. H; t" L* w  a- |: B# O) e
    & a" j& H! C. O+ G
    struts
    # w% N8 p* V7 D, S0 y* ]开发流程
    ) w9 M( P3 E3 Y- Q# x2 d, t0 O$ d0 X6 w4 u3 L
    1、创建表单
    ' |" H) Y( S! B' R8 {" [, _9 [; d
    2、从表单中获得输入
    % R6 S7 a1 t( j3 ^, v8 ]# W
    9 u, s2 Z- G3 F9 G( m( T( O% k/ Q. w3、处理输入(业务逻辑), t$ e. u- T1 d2 @8 V

    ) S, y9 \5 I: |# N, E8 v' |4、根据动态输入改变输入流2 c/ q# Q! y; F
    5 {2 C5 A# r5 E. T! ~  Z0 U
    要完成上述四步,我们需要创建9 e) l- t7 ]1 u+ |, F) X

    % d' l0 v$ Y+ o! c1、一个ActionForm
    ' Q7 }7 N& \9 {& J2 E: R, W0 u: E% ^7 S& a" n1 l: t. R
    2、一个action
    ; Q& U" Y( Y( K, R' f) v
      ~+ s: X2 m+ w9 F3、一个配置文件struts-config.xml
    & A: |- d6 ?9 ~# y8 V6 X* K; s8 D/ W+ h/ i
    4、创建页面! B4 r% H+ I5 a6 U
    % i2 \3 P) P$ B7 K7 G
    创建ActionForm, t* ]  L% w# S) n
    - g3 k* O3 _. t- [' ~
    1、写一个类继承ActionForm: i' U6 H* S5 N( b8 |
    7 J. ]  g+ ~- A% A
    2、私有的属性
    : D; D% |$ C$ X7 q& }
    ; s5 H& z$ l1 w; r9 g: S- l3、相应的get、set方法
    - ~* g, V+ T, S
    $ |; _' q; f$ C+ k4、重写tostring、equals、hashcode三个方法
    5 o3 {6 a1 d9 c& Z, ?
    5 \8 [- |" b; t+ c; e  \创建action
    6 h& X. e# A# S4 E/ D2 @: m! [" j1 S6 I3 z
    1、写一个类继承Action! o. R4 ^, h( n8 z% T! |5 n4 c7 n  U
    ) k5 U$ h8 b) \4 E6 q
    2、实现一个公有的方法(回调方法)
    4 m, D7 k; K5 |* a/ H% ?+ Z. N/ ?3 Z& m$ s
    public ActionForward execute(ActionMapping mapping,1 \' c7 E% B: X  R( ?
    % E5 E9 H# E  W2 ~" l& W
    ActionForm form,* |8 S/ g4 M% a* M) e- `% g& r6 i
    4 v. V7 {/ |5 \) Q5 b
    HttpServletRequest request,8 H$ x; W$ [) V
    3 t$ ~' H( d: X9 T" Y
    HttpServletResponse response)
    3 z( ?% H9 c. s/ V% O1 z' S
    2 x3 e' W3 y8 B7 `{9 f( M. D# [: n* X
    - S& z$ l8 x; Y- h5 J+ k
    //1.收集参数
    0 d7 O6 {( |$ M( a, k
    ; t/ I# k% Q0 hMyActionForm myForm = (MyActionForm)form;9 i/ E9 `: q8 b9 i. k0 z

    $ O1 @- b% ^4 Z1 K, R//2.组织参数
    6 K4 D" {( P2 y8 R  `2 `4 `+ D  b* v& k' d0 X7 V' _2 u; d
    - |# {, R8 L# q, T9 g: I

    & n* R& k& |$ `7 Y% S6 l//3.调用逻辑层
    . ~3 w! G) p  ]" N+ H3 t+ N) _  n% g- `7 F* Y
    boolean flag = true;
    / T* R" o0 w# `* ]
    , H+ f4 _( q2 a9 b/ O, t) G- I( |4 n//4.根据返回值来跳转到相应的页面
    ! x) T  K5 J/ ~1 H+ q: w& |$ t2 Z$ e5 N& n: ]
    ActionForward af = new ActionForward();5 ^/ j0 V# R3 `# P+ W
    9 z2 n0 C4 a* h0 @7 e+ X; e3 h
    if(flag){
    ; y# k# g+ v* v7 ?  ^% e  t& K
    4 J- J8 P( N( g" d" `- oaf = mapping.findForward(“1″);
    3 b8 b" v9 y' a  @3 ^: I) i2 k) i% g7 ]
    }else{0 R; W6 i2 M9 ~) S" ^0 ]
    0 ^$ `% D5 c  ~- `
    af = mapping.findForward(“2″);
    + C. i2 _1 G* x5 ^6 o7 G; N) p
    & R3 O( Z$ o8 G4 o  A7 o}8 D: Y/ R: z0 v$ n0 G5 _

    & R$ Z  r# x7 g" T! }5 `/ preturn af;
    % m9 g8 o) l$ F$ {& |, O+ \! B) H7 j' }' n0 W7 c: H. W* p
    }
    & i. _/ w8 Z' Y, L2 h) m" q( g: U; H: c7 w
    配置struts-config.xml文件
    8 K8 t) N8 |8 L$ q
    2 ~) I: N  O3 R, B. \# u( S1.<form-beans>4 S$ ^( P- V0 @- i' b' {- ?& q( e+ e

    5 e7 Q5 o. q& d3 i$ m<form-bean name=”myActionForm” type=”全路径.MyActionForm”/>
    6 y: v2 P1 ?9 G, J: @
      K; X8 e1 ]4 l+ w* c7 q<form-bean />
    ! T; _' m3 D7 \! `/ _
    / c9 C: `; s9 H- f</form-beans>
    ) l+ Q: f. Y6 P" o$ I) c0 y# o& L% s2 m' Z; S
    2.<action-mappings>$ q* |2 V- z2 T3 ^- r
    1 ?; |( |4 Y/ k8 f/ L) b5 w; Z: J
    <action path=”/sll”
    ( N# T* L& X4 Y0 H6 U- X7 m- n1 a: q& M: c9 j* g9 ^
    name=”myActionForm”
    / K5 X. U/ y/ U* E) K9 l, _0 g& d( P0 `1 I/ c" V
    type=”全路径.MyAction”
      P" {: X9 i- R+ }4 H+ [. J
    . Y4 d( a+ T4 R: B% @scope=”session”/ \. N/ L. d0 G! ]4 r$ i
    4 ?3 \$ B- [+ M* O2 W0 C7 l  C
    input=”错误返回的页面”>" R: v! V0 o: z) h8 P

    5 @+ Y3 b5 _( X& c<forward name=”1″ path=”/1.jsp”>
    % j1 c6 d* d% E% D7 l8 d, ~7 }9 e) r# H# E) g/ f4 }
    <forward name=”2″ path=”/2.jsp”>
    9 s  A- w' d* _9 G" E5 C% X
    - |+ W+ S7 B7 [+ s</action>
    / x/ I2 n" n/ M: L" V% ^; m7 y2 J9 z# s, t8 n
    </action-mappings>& {: L! G/ d0 u+ S: }4 Y

    9 |* ~* k4 a" n$ }步骤:, r2 E" t2 w# S7 ]
    ! D- `- g( z; d8 [
    1.创建一个空的web应用/ Q1 n+ P2 |" J$ F

    6 l8 b" U( h, e" t% c5 n. W2.将struts的包放到lib文件夹下( ]0 F8 \2 C1 t1 G
    # d) Z! |7 i  F. ~; r% p
    3.将.tld文件文件和struts-config.xml、web.xml放到WEB-INF的跟目录下
    ) m; S! M3 T+ D! T+ H( n) _; X9 c+ z7 Y# S$ E, t7 ^
    4.配置struts-config.xml文件和web.xml文件9 P9 p! V# j4 r  |2 F

    0 S: x0 K) y$ T$ H( A9 t& y; p3 J5.在页面引入tag文件uri
    8 B3 M, ], w# }; A
    % l* E# r6 L- b& ]4 _STRUTS运行机制
    ) R( v" z' G# G. e3 @7 O' y; V/ n! K2 u  s3 c, S& Y
    1、界面点击产生请求
    8 c( S( J: h2 j6 [) P" I3 f) r, s/ \- @7 o
    2、容器接到请求3 T3 S( g. _. @4 c8 D' _; r( _- T

    & C3 W" O3 b- K' R7 g3、匹配web.xml文件中的*.do来调用ActionServlet( `1 t4 ~/ C3 k2 J3 P2 m- P

    6 J0 @+ R4 s$ a, Z4、ActionServlet的处理! \& i- c0 j5 u) R7 _# H% Z7 a1 D
    % _  L" z# i4 ]# v1 y8 p
    4.1 读struts-congfig.xml文件形成ActionMapping
      m- j" ~4 \( Z+ c
    ! \/ Z3 t; N9 D# P4.2 通过path 来匹配Action类,通过Action的name属性来匹配ActionForm类: c( W9 _1 y$ G3 A! \8 K7 ^
    9 `- r( I- w4 _* k) h/ T: \
    4.3 通过反射机制来给Form添数据
    ( z9 w. O+ t' w: X2 U
    : T5 V+ \# U0 }" j+ v! N+ R4.4 由ActionServlet转调Action的execute方法( Q# k# e4 N0 H6 \! _! h' x

    5 h1 T; G; d+ S9 Q0 m; `& f% b4.5 得到execute方法的返回值,跳转页面
    3 R, _# C/ n1 d5 M) {' P& F; A' F
    ; G; }* B! N& d0 O7 R# |4.5.1 RequestDispatcher
    0 ?  T7 O) x7 z- D0 u1 ]' c
    : b: K0 E; b: Q9 U: p4.5.2 response.sendRedirect(“list.jsp”);- u  e0 @3 a/ ]! Y) y5 w5 r& W
    ' r  U) H3 }& w* n0 O) C3 x" v+ l, A

    3 O, x0 p& S; B& k: y$ w
    ) |. R: p" }& v: @进入execute方法
    / x6 @# t! C1 o7 Q9 ?$ M* Q9 @- z
    1 收集参数: d% R; e/ O/ ]/ Z4 U

    " b; H1 k9 f! {2 组织参数
    ' j0 W8 `; N& T+ D" s" K, v8 O6 ]8 D" X
    3 调用,逻辑层
    6 r" H0 ]1 \9 s4 T+ N. ]+ _+ t+ t1 |- u2 X; J& k) t
    4 返回值
    - e$ Y# b: F! R4 ]+ N) M2 F8 L2 [6 L+ o6 y9 g0 a) c; {* q
    4.1 选择下一个页面 (ActionForward)* w, Z" n0 g7 @4 j3 y" i! A
    4 v+ I2 `. @( H) i) p% T, Y  ^
    4.2 把值传给下一个页面2 [+ q" l; @/ u1 E0 ^

    $ c, z! z0 G' Z9 p! M- ~4 B$ l* @
    6 T# D$ h5 P' ]; H8 O$ }6 c9 N2 @2 h. l& O% f& ]* G9 N
    比较struts和struts2的不同
    ) @) q% q* A$ q2 |% E7 x4 K! g8 n+ f2 m, I+ n! M
    Struts
    ! `' R, T3 q3 |) J5 V
    7 g/ T; i. D  S( F$ GStruts2
    ' q5 f1 {3 D# [+ H, Z, n0 `+ o# ^# R' \2 y8 v7 S; Z% R( D: w
    组成        五个部分:ActionServlet,ActionMapping,AtcionForward,ActionForm,Action        十个部分:AcionContext,FilterDispatcher,ActionMapper,ActionProxy,Configuration Manager,Action Invocation,Interceptot,Action,Result,Taglib) B- s# r* S8 t4 l: g8 e* ]0 k' V$ o
    url        .do        .action% A8 {# D; M8 H" M! ?% t3 k  r7 J
    分发控制        AtcionServlet        FilterDispatcher; M$ V) @& V) V$ q4 K+ M, ]1 _
    收集参数        利用JavaBean技术,将数据封装到ActionForm的子类中;/ X% V1 o/ J# Z, g  k8 B; \
    一个Action对应一个ActionForm的子类; t5 B4 v# H$ T5 Y- Q3 G

    ' a: P: A$ [& D使用拦截器将数据封装到值栈中。5 i+ H4 b- c& j0 E2 D
    使用域模型,一个Action对应多个值栈中的Model
    : r( P+ I" E; t# r# `8 O: t. k
    ) M# F2 X) N; R8 t$ q$ y读取配置文件        ActionMapping        Configuration Manager
    2 A  l2 ~6 D. A5 i; @& U) p拦截器        无拦截器        执行Action前后有拦截器
    $ O* B" K* O# ~( ~' Z' w; `返回页面        将字符串封装到AtcionForward,进行跳转页面        Action中直接返回字符串,通过Result跳转页面+ y  V% Z6 w9 h( W; Y& P6 `% Y
    页面跳转方式        两种:dispatch,redirect        三种:dispatch,redirect,chain
    / r' t( G2 w$ m- K# g9 O值栈        无值栈,Action通过在request范围内设置属性,向jsp页面传递数据        有值栈,Action和jsp页面通过值栈传递数据,jsp页面通过OGNL取得值栈中的数据$ h# w. A, k5 K, H% `, x
    配置文件        struts-config.xml        struts.xml1 U$ C+ L& q* T) H' D
    中文问题        不能解决(需要使用filter)        可以解决中文问题:& ]4 O' P, u$ |$ r, b0 U
    1、在jsp页面添加Meta;$ m4 @: }9 {6 L, `+ c
    ' t7 {. |3 ^2 V5 e; v$ }" v' ?
    2、修改struts.properties中的设置。
    回复

    使用道具 举报

    admin    

    1244

    主题

    544

    听众

    1万

    金钱

    管理员

  • TA的每日心情

    2021-2-2 11:21
  • 签到天数: 36 天

    [LV.5]常住居民I

    管理员

    18#
    发表于 2014-12-03 12:49:03 |只看该作者
    其他开发工具和技术
    ; \  R( k, T; D7 y9 sAnt
    3 ]- x9 q+ H3 n, }* c" p; _# OAnt是基于java的批处理工具# @* }6 A( `: }0 V$ e. T' R
    9 C: J2 @% X( x, p% i) ~, Y2 E
    一、配置ant的运行环境
    $ d' ?1 O9 t% M4 s* L  H! \* f) \5 X# |7 J0 h/ I4 L& M
    1.将ant的bin目录添加到path中9 H/ U& n  \4 T) s4 C/ ^) X: T& V7 y
    , x& F) p, I  U) F$ D- J2 F
    2.配置JAVA_HOME
    ; M6 |: d; ?5 F  U9 c  l2 S9 \
      T0 t: M% W5 Y7 c  u3.配置ANT_HOME$ Z7 n6 V( t; N) }: t, W8 Y* h

    " v9 x8 R3 b0 z' E5 i# B3 o二、配制build.xml文件,该文件放在应用程序的根目录下
    ! O% f! w( ]3 ^2 E' F. p! m: j' y( c$ |/ v& E, k' E5 K
    编译java文件
    9 P* c& u! K& _& S6 G# y; o" Z& W. a' Q' [! N
    执行java文件* H0 H2 z: i/ v; W: Z% D

    * E9 R3 x4 ?; Bcopy- i' M; E: J+ l& ^7 r9 H$ ?) {

    ; ?- U) O6 t9 E& u1 E# J删除4 ^- ^& @/ M5 r3 E& L# |( t' r% a0 O! P$ \

    7 G3 M: c; I* y. o打jar包
    5 t7 c3 R+ V. y8 q. s
    4 i! ?! k1 J! ~5 ~1 O, S* @根据注解生成配置文件
    : Y+ P/ ^( b6 ~: e  m) U  A$ `8 d- T; b# E, f4 X/ p) M
    Xdoclet
    9 E5 H: G0 ]2 s" J5 k/ Z3 \通过注释生成一系列文件的工具(txt、xml、java、html等)  ~8 T0 M5 w0 @, o9 p& j  z

    ( x! p5 M: I9 V8 S. X' I- \. }xdoclet本质是摸板技术+字符串的替换
    " E$ R) [3 M6 n; h6 _( K& P: n% H: J( @8 _) ^
    1.在java文件中写符合要求的注释(将hbm.xml文件的内容搬到java文件中去写)
    . |; d, z; B/ O: _1 s. o" y! L# I
    * O  S; x0 {" y- A! T, q2 }1.1 在类的上面 写与表的对应' b" M+ T8 {7 ?- A# }
      ^+ t0 ]1 G/ T* U& j& p
    1.2 将每一个属性的注释都写到get方法的上面
    0 C6 ?8 c, x& W0 b" c6 @$ T1 M- W5 }  |- O- O
    2.在ant中引入相应的task来驱动xdoclet' T# e  l7 {% M  C; L( U
    : ]- r4 a: ]" R0 V& \+ o
    , h. m$ y0 i, B1 p
    + x! o+ f. A/ L6 m9 B! D& u5 B
    log4j日志管理- M$ J) |. m9 g- N& ~+ Q
    1、是什么?
    7 q9 ^- Q, m' t: q- @6 h- l1 e
    % u6 u" {1 y# y' t! X; c3 P3 a' @在开发期间用来测试、对整个日志信息进行管理的工具
    6 i% Z$ B" O: |  ^6 J' ]) G, n; b7 V0 P% j4 d
    2、功能
    ; V$ o& C/ C, d! ^) A/ g; _& s! P. `. w
    1.控制输出的目的地
    8 _: g3 O; d; ^9 n) _  O4 Q( ~/ l0 b  b$ V. ^
    2. 控制输出的格式
    ! d6 _4 g' r; _8 S3 J8 _% u$ X7 y, d2 _2 t
    3. 控制输出的级别$ {7 {! N' n' X+ f, X! K0 X5 t

    , N' m; f$ x4 G9 q5 Q, \3、日志的级别
    - z( @  ^! `5 s: l) k$ ?4 J& M# Q. h: J* b* Z$ G2 v+ Z
    1. debug 调试
      B4 d2 E( u7 i  l! k0 w: ]7 f7 ~" r4 g3 ?5 E' ~6 u' H; ^
    2. info 给用户的提示信息! U3 Q; g0 D* K- o# j

    6 j7 ]8 [8 q% D! S. R3. warn 给用户的警告信息- V1 L; W$ T; }) o
    % }7 a1 _% P6 }& Z
    4.error 给程序员用来调试. E2 E# S- J1 M" K  P
    ! w/ X& p  G; [( w9 b7 i
    Debug—-〉info—-〉warn——–〉error
    " n3 U1 u! [" v: X
    % |0 X# \6 E( {3 i2 K& P: Y2 ]4、配置' W1 f  K8 J( V

    3 c- K+ R. q. J  h1.配置级别
    1 t; a4 S) Z2 V! y2 M8 D
    # \' R& R+ B6 C4 U- _$ }2 P0 C* D2.输入源 (控制台和文件)1 {: Q+ ~6 W- w" T2 o7 |9 I' L

    , V: `" }* f! Y: h( F3.可以进行分包控制
    * @1 w# q1 B6 L* z9 ~* ^  A9 m4 h) F
    / d* s" S; w; {6 r( N5 b7 mLog4f.logger.包结构 = 级别- j% ]1 p( Q$ z: Q# {

    2 s$ D2 O9 @; z7 l8 J: L' X5、使用4 ]$ ?4 {6 z, G! I4 b

    0 \" H& Z+ P# S/ `% mLogger log=Logger.getLogger(Test.class);
    # n7 g7 Y" [, P% E4 i
    , k2 Z% T6 p  |$ i3 d$ _, w4 X    public/ a* p* s+ D2 D/ I0 c
    void t3(){+ A$ e- M& I* H$ p5 L

    7 U5 n3 V/ w+ {2 v7 T. b        log.debug(“this is debug”);
    6 m' {, u+ u) E/ N
    9 `) N5 b% D/ L" }5 M        log.info(“this is info”);
    + }0 H& w0 Q/ C. e5 u- B" Z0 u% e
    9 a4 M, e. }8 s' o! P3 H* Z        log.warn(“this is warn “);! Y- x9 N! B5 e
    " x, Q' g5 k* I. U
            log.error(“this is error”);
    . _. N( {  e# R' k5 ]
    4 y% @. H8 a6 S% h  Q) b5 T! }/ d% `+ k    }
    & ]4 J4 E/ S' X( B" a
    * L! c0 A+ ~: U/ f% v& bJunit, O$ r' V3 R+ \! {( E
    1.是什么?1 i( Y9 ?& q: N3 X! T# n: H
    & u6 g. Z. u  u
    单元测试的框架& V% n- P+ Q. E7 `

    7 U: a3 j0 W8 W2.怎么做?* E1 c1 R, u1 G1 [0 N# e# Z  s, B

    ) g& N/ s# I5 j$ K0 z0 H写一个类继承TestCase
    6 f  e5 l, G* J( F1 ~  m# K5 f% S) l9 _
    测试的方法一般都以test开头并且没有参数) H6 a( b8 l# W0 V/ U; {8 d5 Q& [
    % D! L; }7 \6 p* y0 Y( {: ^
    在测试方法前执行的方法public void setUp( )1 @! h: _# a  R+ u
    : b/ P* m# V2 T2 Z) l0 a$ C1 H
    在测试方法后执行的方法public void tearDown( )! ~$ X1 Z1 H: k! }: [  n- ]! p& p

    7 _: ?" _5 h$ F+ Gerror和故障的区别- Y% d0 k" j0 N& I6 l
    2 _- c' @4 M$ P* h* \2 x
    error :代码有问题
    $ F0 t& U* B# E0 b9 ]1 e& ~9 [' E& t6 s5 E( n" x
    故障 :逻辑有问题与祈望的值不相符合
    7 \; W6 Q# Q5 G4 }* ?- q$ B) G7 C: r/ N. }' _$ j  E
    生命周期4 {9 a4 Q2 ]4 Y. _4 a" Y
    5 D1 l+ T) M6 q% D# O
    测试—〉SetUp()—〉testXX()—〉tearDown()—〉结束;( L  e6 w& B# y# R; \1 P

    2 c2 X, D: x6 h- h* D. e* kTestCase套件9 {( L% B/ [6 H" {: l( _4 r
    4 y9 F2 E* v8 T5 `( x9 P& }  [
    public class MyTest{
    : F2 g/ J, w/ Y0 g& }, ~( Y7 }& d& ]
            Public static Test suite(){; J, j" k- b$ C# i' [& j8 o9 a" ]

    . a; [4 v: C" }4 t# h4 n0 ZTestSuite suite = new TestSuite();
    9 W7 L: z9 n6 m, \
    . ~4 l  I  f" |! Rsuite.addTestCase(Test1.class);
    9 Z9 _1 ]; a$ x- A6 M+ p* f5 R& W6 F0 i  w1 v
    suite.addTestCase(Test2.class);
    9 G, S8 o" G5 [4 W8 O- F( T
    7 y7 k& K7 L1 f6 S. P6 a$ ]}9 o' \8 T2 h4 K7 m

    8 |, {- N7 X* D( u5 {+ z" L}
    3 n" `4 B% \2 g: H5 U( ^& Y
    " Y9 T5 m& [+ i7 a4 x
    7 B# n# h& N" D% Q5 y  o# c$ P% B  J& y; k( a. a- y, W
    Ajax+ f4 o7 Z- ]' f- |
    是什么?
    : y) I* q5 n' H  @* D$ E( I2 B9 JAJAX即“Asynchronous JavaScript and XML”(异步JavaScript和XML)。是一种创建交互式网页应用的网页开发技术。
    % Z+ \0 y) l- S& B0 n& ~
    6 b# u( p  L9 L无刷新页面。8 H$ M: y6 Y  x" Y1 L: p
    - M2 M" Q+ H; \/ S
    有什么?" h4 R: Z" ?" g* [  w! J
    AJAX是多种技术的综合,包括JavaScript、XHTML和CSS、DOM、XML 和 XSLT、XMLHttpRequest。
    6 ]) R- i" |. h, _' i$ W) Q$ o. ?9 D4 [- O2 I9 Q, k8 M' ]- d  w
    能干什么?! Z/ `+ B/ t( r& u
    使用XHTML+CSS标准化呈现;9 y# o6 s* y. s
    使用DOM进行动态显示及交互;. ?. O% _0 t9 F
    使用 XML 和 XSLT 进行数据交换及相关操作;+ E5 T. s; t5 q* _) c
    使用 XMLHttpRequest 进行异步数据查询、检索;
    " @. K& b3 P( ?# \; j使用JavaScript绑定和处理有所得数据;3 j% ?# l) `) Y
    4 a. f+ u1 i6 {+ Q+ n9 T- U; D7 M
    传统的web应用允许用户填写表单(form),当提交表单时就向web服务器发送一个请求。服务器接收并处理传来的表单,然後返回一个新的网页。这个做法浪费了许多带宽,因为在前後两个页面中的大部分HTML代码往往是相同的。由于每次应用的交互都需要向服务器发送请求,应用的响应时间就依赖于服务器的响应时间。这导致了用户界面的响应比本地应用慢得多。, k2 O/ C# O, n8 Q  }$ q' x6 ~; U
    8 s( Y5 q' E5 Z4 @
    与此不同,AJAX应用可以仅向服务器发送并取回必需的数据,它使用SOAP或其它一些基于XML的web service接口,并在客户端采用JavaScript处理来自服务器的响应。因为在服务器和浏览器之间交换的数据大量减少,结果我们就能看到响应更快的应用。同时很多的处理工作可以在发出请求的客户端机器上完成,所以Web服务器的处理时间也减少了。
    ; I0 @3 o$ F5 ?3 G
    7 P: q, m% ^4 ]8 l4 Z/ }/ J! a使用Ajax的最大优点,就是能在不更新整个页面的前提下维护数据。这使得Web应用程序更为迅捷地回应用户动作,并避免了在网络上发送那些没有改变过的信息。$ i* K. C- e6 `8 j

    ' [$ x1 D7 v0 ]8 j( z# p对应用Ajax最主要的批评就是:
    $ D& S3 X( q# u- \( K( _1 它破坏了浏览器后退按钮的正常行为,就是用户点击后退按钮后不能看到之前的数据;. K( K9 Y: I" J9 o8 q6 i
    2 一些手持设备(如手机、PDA等)现在还不能很好的支持Ajax;
      X4 u1 |& @  V- Q" v3 用JavaScript作的Ajax引擎,JavaScript的兼容性和DeBug都是让人头痛的事;
    ) M6 {/ v2 ?6 _" g4 Ajax的无刷新重载,由于页面的变化没有刷新重载那么明显,所以容易给用户带来困扰――用户不太清楚现在的数据是新的还是已经更新过的;现有的解决有:在相关位置提示、数据更新的区域设计得比较明显、数据更新后给用户提示等;
    " L1 u4 \/ k3 [. F; B7 ~( T7 z' r* ^) f2 n' s# \
    怎么做?
    . C  t0 f2 n# Z) h0 G<script language=”javascript”>& w4 ]* N/ S' S
      I" O% g; j5 K7 X0 P3 Y8 M
    var req;
    / a  d- y( ?8 z4 G0 o' M" w2 ^8 w6 [, |& ?: O
    function add(){
      }0 F1 A( V+ K4 d7 I' V5 u# m3 H! N- e( E/ }
    //1:创建用于传输的对象
    5 y5 P4 ^2 n' W5 B3 o( f% s1 j# ~- K$ }; r; D( a& m
    req=new ActiveXObject(“Microsoft.XMLHTTP”);
    ; o9 ]7 o( C0 n& X- N
    " [* C: G8 }/ T4 i// 声明返回后,处理数据的方法
    8 ^7 u6 F* {4 _% H' t# I6 |; K  Q  ?' R) c0 ?8 W0 H- k+ y
    req.onreadystatechange=manage;: ]; c( O% e3 V# z5 L

      ~# p) a+ k  y5 t//2:准备传输的内容
      h, V; F0 s& p2 j6 p3 D, m7 @5 Z
    3 u& e3 ]% u3 yvar str=”test1111″;! A) I- P' P# _' l
    : h0 t" p- W: r+ z) C8 J
    //3:发出请求; G) X0 P# c% A* w# Q
    + H3 H% q3 A* A1 W2 F2 [
    req.open(“GET” ,”/others/ajax/test/t2.jsp?str=”+str);
    % g2 H, K7 _/ N1 ^
      O2 m7 B; ~( e, preq.send(null);
    8 N! H, o" ~- b& _
    ; x7 j# g8 p9 y  b& |}1 T5 j* k& H) r8 T
    6 P- E0 i+ k) f& Y3 T& q2 g
    //4:接受返回并处理/ a' a  A3 _8 G. m
    0 W5 m, r" C; H# j, c+ ]; d0 O' ?; Z5 Q
    function manage(){$ V9 \5 S; A( |/ Z+ j4 g+ ~
    8 v" _% G. p+ \; r% c6 T+ A: }
    if(req.readyState==4){
    ) ]# ]  ~; m, V" t. E1 x/ x3 d
    & f, _; D: @$ Ealert(“r==”+req.responseText);
    . P4 m: s. q8 u( d$ d* C
    ( l+ X7 ^" ?! N}
    + V  e9 m# n- ?
    - F" x4 x4 R0 e' [}
    , m! x( H5 W/ I; g, m. [% A0 W" A* ^0 |
    </script>! j/ `  v! u0 U; }

    9 T' a+ ?3 m7 G& Q( l7 X1 IreadyState的取值如下:& @( w4 \$ j- s; L7 |) E- J

    , [/ T- ~6 C6 L  0 (未初始化)5 `- P4 U3 f( G
    ( Z8 J. P% J5 ?
      1 (正在装载)+ o, _- K+ K! g  f

    - a2 {: K% w6 k2 [7 Y  2 (装载完毕)7 G* M- Y) C1 C+ F! _

    * i% R7 k9 t( M) ~9 U  3 (交互中)
    3 S4 O, j& L9 v/ x: r1 m  H# |& k- @) w' {3 F5 K- Y( }
      4 (完成)
    7 b. {4 {5 [1 X6 h6 F! ?9 k  f* a* J$ [6 j* v- v

    . L# Q7 Q+ C$ e: I. A7 S- \1 _9 z2 n, H6 \3 z/ N# c5 G
    原理' H1 A' P, Z2 ?* E* B
    Ajax的原理简单来说通过XmlHttpRequest对象来向服务器发异步请求,从服务器获得数据,可以是xml格式,也可以是一个字符串,然后用javascript来操作DOM而更新页面。
    * K3 s6 V6 s& e
    ( |5 d  g# F" E* a& ?Dwr  X( y4 |+ [4 T
    是什么?
    / ]8 d) T7 |/ C# i- ADWR(Direct Web Remoting)是一个开源的类库,可以帮助开发人员开发包含AJAX技术的页面。它可以允许在页面中使用运行在WEB服务器上的JAVA函数,被调用的JAVA函数就像是在页面中JavaScript方法一样。
    9 p  c$ c$ k  N5 j4 Y. x4 D
    % n5 v2 g3 ^, l7 Y  |! c有什么?- h9 C8 M5 D  j! M! \5 B( _
    它包含两个主要的部分:允许JavaScript从WEB服务器上一个遵循了AJAX原则的Servlet中获取数据;另外一方面提供了一个JavaScript库可以帮助web开发人员轻松地利用获取的数据来动态改变网页的内容。8 S8 B- ]2 a; N% |* `9 Y- B
    8 C6 v4 l. }: \0 A
    3 G! X" z1 S3 w; w+ `! ]2 m. z: s  l! W
    5 [$ R2 t( |! S; `2 Z; ~
    能干什么?  A; `3 R' G# V9 y4 `+ J9 M% H
    动态地把java类生成为JavaScript,感觉调用就像发生在浏览器端,实际上代码调用发生在服务器端,Dwr负责数据的传递和转换。这种从Java到JavaScript的远程调用功能的方式使DWR用起来有种非常像RMI或者SOAP的常规RPC机制。& Y" P: x8 n8 S. y) P* ?
    7 Z4 m) q8 v% e0 r

    # p* n5 c7 ?( W% k! x* [# a% h& I& x! W* t3 a
    怎么做?
    ) r- Y3 b) z  n① 编写配置文件8 L, P# G2 Z$ U8 O" b) G9 R9 d

    4 D! O/ Y& ?( v% w9 U& cweb.xml5 P) _/ V( g4 i8 m3 }( k
    3 z: @$ }7 M( {
    <servlet>
    0 c7 P- h/ L7 q$ ]
    ! e' H7 g& f8 B1 r0 ^# G2 F, g9 T<servlet-name>dwr-invoker</servlet-name>+ u) b# _; }* m2 ]
    % o2 v% E$ r5 ~3 Z) {
    <servlet-class>
    2 N8 H  }1 c2 N' X; W/ z% z" ]: {! f) c! k  a! T9 \0 t
    org.directwebremoting.servlet.DwrServlet3 K/ N% ]: N: h( T* E9 w6 R
    3 m4 Z- r2 p& a8 u
    </servlet-class>/ Q0 R5 ~7 s% D$ s0 a( p

    3 Z, g  i7 F: \- G* d$ _) q8 [4 K$ B. f<init-param>  B! c3 D  f/ \  Y3 O9 K

    / ?( a: K; t3 T3 I( e; H' q/ O<param-name>debug</param-name>
    / Y! M  _9 V& ]0 j* e. y" \5 b4 z) }% }. h3 ^+ H  I4 N
    <param-value>true</param-value># l& \: v; T* y/ L3 }

    / A( G5 U8 a0 @0 N</init-param>7 A/ `1 P, s2 p9 V$ B3 ]" m9 i
    * q/ @$ |# e- K5 J% R
    </servlet>
    4 M  m7 X3 W* g
    # r9 Z+ W8 D4 W<servlet-mapping>6 O$ M5 F/ H4 i9 H9 L
    $ s2 Y! c# Q, ]$ Z, r6 y9 `
    <servlet-name>dwr-invoker</servlet-name>5 L- ]4 G) t) G/ y7 e1 p

    $ a9 i- Y  X% _2 z3 Q9 C<url-pattern>/dwr/*</url-pattern>! ]1 C3 f+ o% Z$ A! b; Q2 z

    # S# J% S/ q) O0 V4 G5 D. p</servlet-mapping>$ B/ @+ e# R/ n

    # C; A5 I; ]5 `; Vdwr.xml
    : d: l9 J/ m- _. l; Q$ `' E! j% x! `3 o- u/ s  z
    <allow>
    % r' j' D  }4 M/ y) e2 n6 x- a
    $ I- `6 r+ Y  ~<create creator=”new” javascript=”kc2″>5 {+ a. g# ?6 p+ {/ l( F

    7 a. ?% t! w4 l" w<param name=”class” value=”dwr.Service” />
    - s8 a- U/ K; w9 y, c# p
    9 E! c( [# X% u0 x+ e/ A6 {</create>! L4 c% E! e1 q
    & f% d0 Q* X# ^( Y
    </allow>
    - f; m" t' p1 S, Q1 ]) }3 o$ ~0 a2 e7 ^
    ②编写service9 P0 }# J9 J* h. O9 p

    ' }5 E+ c2 E, b$ t/ bpublic class Service {% `5 m% |9 s! M2 I# g
    " Y# r7 v# ?$ G& d4 X7 [
    public String sayHello(String yourName) {
    % v- Z/ D6 S/ \+ A' }% A( {
    % R5 N5 s  F/ }, Q//可以是访问数据库的复杂代码
    3 ]" Y4 G5 T: i" L8 ]" s( P. N
    . c- b  W: c! R. h9 g: _return “Hello World ” + yourName;
    ! Y  d) G( O* m& c7 s4 a1 ?8 J6 q" ]
    }! G- B9 U5 E% m; P
    & M' E; Q) H( `6 W0 \1 N! b
    }, x2 Q, r- y$ ~( M% R' @% I

    : L, _8 S2 x  b6 M) @③测试DWR/ p$ B: H* \, s0 h! V
    1 ^7 p6 n' Q5 v" x: N
    将代码放入应用服务器(比如Tomcat),启动。
    $ ?6 J% i+ w( m2 ~
    % e6 N$ ]/ ~6 \  k然后在地址栏输入http://localhost:8080/你的工程/dwr" F# Y# X* R2 k1 [- K( L4 y) D2 Y# i

    : ]4 V2 `7 z) e) g& s; E) L9 Q1 \6 Y& W④编写jsp页面4 i6 w& u" M9 k
    ( I) Y' ~, m0 l0 ?
    1) 要引用3个dwr的js,其中engine.js必须要,如果需要用到dwr提供的一些方便的工具要引用util.js
    8 E, t2 Y: }2 {' |" {- s/ y9 ]# n4 p* M7 L4 g
    2) 然后还要引用dwr自动生成的js,dwr/interface/service.js,注意js名字要和dwr.xml配置的一样' J# O* n1 q- C* ~0 Y# f$ u

    9 m) {9 n/ n3 @* I& }8 J3) js里的service.sayHello和java类的那个有一点区别,多了一个参数,用来得到返回的数据
    回复

    使用道具 举报

    12
    快速回复
    您需要登录后才可以回帖 登录 | 立即注册

       

    关闭

    站长推荐上一条 /1 下一条

    发布主题 快速回复 返回列表 联系我们 官方QQ群 科帮网手机客户端
    快速回复 返回顶部 返回列表