我的日常

登录/注册
您现在的位置:论坛 盖世程序员(我猜到了开头 却没有猜到结局) 盖世程序员 > 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 |只看该作者
    JEE+ ^) }( t# q$ O9 O
    简述JEE
    # r- M/ r/ {( i! SJEE : JAVA  PLATFORM  ENTERPRISE  EDITION
    8 n0 B- \( c& y$ U" k" H6 v$ t* _8 t' `. V. A1 B, K3 z) W' ^
    JEE是一个规范集;
    " F! `6 y4 K% p0 r, a" i" H' J9 a# J4 G
    JEE是一个框架集;
    5 J5 h' `& v! V& d1 M# ?1 X: J3 \; Y# O
    3 x* ~8 Z) V" B. eJEE是一个技术集或API集;- E/ q3 C# W0 ?6 s1 F0 Y
    2 y# W; i& v! B# c3 g9 u( `6 }
    适用于创建服务器端的大型的软件服务系统
    . E/ x2 j5 v+ D( I9 w
    * o1 U) O, g7 T' T+ u0 g : R0 V9 j3 w3 |
    * |2 w, W; q% ~$ {
    C/S B/S 模式
    # y  I+ Y0 M& Y% W1 VC/S client/server即客户机/服务器模式,客户端也参与程序的运行与计算(富客户端、胖客户端)7 H2 i- ^7 W! Y

    7 I4 G/ e( L4 U6 WB/S border/server即浏览器/服务器模式,又称为瘦客户端,客户端不参与程序的运行与计算4 {% s  Y! \/ m0 y
    5 K; t) |. }, c

    . _' O6 }2 F% n. p$ A/ b0 s2 @* [: [
    企业级应用(大规模的应用)的特点
      z: u6 `* U: {1.生命周期长、稳定、可靠0 D# X: |: s. ]3 L2 |0 v

    " h- Q% R. L9 I0 P$ H2.组件往往分布在异构的环境中,能够跨平台3 G3 O0 c% ?& a. ]/ c1 j: _' k( |0 P9 P

    * L7 c- Q1 g9 }9 O6 h3 X# h3.维护性、扩展性、重用性
    ! J) }+ x' d" D( G; U3 }$ a! C" ^! `% O+ L. Q
    4.有事务、安全、线程; R4 @, J* {- B) H& {6 K& }2 F

    * p2 y/ }! r- u7 I 0 ^, f3 b: U0 L, W* }" w. H
    ; q, I, s5 g( |% i- t" p" |/ Y* W
    什么是业务逻辑?
    ( p2 P5 i4 X9 K( R; W% O依照业务逻辑划分模块,
    - N9 P3 Q" N9 ~$ k! ]& D9 U5 q8 y
      y# I$ |; T0 h' a* `; D所谓判定业务 就是具有以下特征:
    7 W0 S! J$ G5 ^8 }
    4 x! T" |' t& f) ]) t- |1.业务流程: b% p% G: `1 f+ n
    4 A+ B* C2 V* D- h4 v8 Q7 [# t
    2.业务判断
    6 T% T$ v0 k# p8 d3 E& D; I+ w0 S5 H9 P
    3.功能组合; O6 W2 L- g; }: L3 ~7 n: h

    ( o% F6 Z# `6 Z% l: d- Q4 I+ o* Z
    . o: f* d+ G( l% K8 ^  b9 j* {. B7 R
    平台(角色)的划分( ]2 ?$ B# S/ M4 F: R) W
    1.平台供应商。提供满足API集实现的厂商(BEA weblogic IBM webshphere)+ ^: ]6 ?- V( }+ K- {; O8 B

    " Z- V# W; h" R. s( Y2.组件供应商- C& }& i/ M, c; x9 `) [. f" `9 A3 n

    9 ^2 C9 c$ I0 e5 q/ E' J# l3.组件装配人员
    % q/ ]- F" q) R0 `8 ~, |7 `# R5 o9 j
    4.部署人员
    ; ^+ G5 t, z3 n: v8 {4 Y% t/ A2 y: U/ J! h0 T0 {
    5.系统管理人员; k5 C) h% f- _" M' h

    ' }# W4 ^# u: |6 f. b! S6.工具供应商 提供开发组件所使用的工具(Jbuilder、eclipse); S  N6 p' ?' r, L6 y" T6 \5 @5 v

    6 c: N2 A% ^+ p . X1 x. m1 L0 P! [" x% g; f
    & [2 F% U. k0 T8 \7 O
    java技术分布(设计架构 模块内部设计)9 v) w% `4 S4 h: Y
    1.表现层 Servlet、 Jsp、 JavaBean、 Taglib
      L% v+ m) g+ q8 {# v/ Z4 s% r. J! Z8 G! v5 ]0 t( E8 X  _
    2.逻辑层 EJB(SessionBean)/ `: \, A& O6 ]2 K
    7 k9 o6 U" n  {$ K' R; M+ ?
    3.数据层 ( JDBC  EJB(EntityBean))
    8 \/ O5 Z, L0 \* [( S2 ~
    7 K5 q) i7 z* b! g% R' b$ z4.服务 JTA(JAVA事务架构) JTS(JAVA事务服务) JAAS(JAVA授权与验证服务)
    ( X# e: {% s- A& ^" t- T/ J4 C9 `6 x) `& Y' }* T. {0 {
    5.分布式通讯 RMI(IIOP)+JNDI 、JAXP(JAVA 的 XML 架构)
    / X( i; \) {+ d, T; r' Q. ~5 h0 o
    JAVAMAIL(邮件服务)、JMS(消息服务)、IDLC、JCA(JAVA连接器框架 (成))
    * r4 b) S: i. G, s) x0 W9 H) \# k4 h. d( i8 ~7 Z; ]2 A$ m+ h  L' m. h; D

    4 R# o# T  p9 I' Y. s6 m
    & u2 x' X  w# Y9 I. fJEE的体系结构: 是一种组件的体系结构
    7 e. g# i0 \- }, s' `3 Y* U. V) X: H1.组件 : 能够完成一定功能的封状体(独立的功能的集合)/ d' g% V- ?' n

    2 Y3 A# C% N' y" r9 A不能单独运行,必须运行在容器上. Z, a8 p" f  v' D  b

    * i% C0 ]% g( i5 }) K( A, J# b分为两类:web组件、ejb组件
    6 T6 u9 N! X( x& X. a* U  R0 a) h) i; Y: \
    2.容器 : 提供组件的运行环境,并对组件进行管理(一段程序)
    & [% H$ w1 L* ]& t  Q. E* r# Y" {, ^% J3 \/ p1 ?
    管理组件的生命周期, [6 p. i# I3 @5 y
    ) w4 F2 g2 V0 R6 ?& v6 \# `6 I! S
    不能单独运行,必须运行在服务器上3 q* z. S( B5 M# @# D
    # o, N& G' W0 l2 J- R
    程序(组件)通过上下文来调用容器(context)  ^8 G0 ^, Y. l5 j, h" V
    5 g* G# s( }# a. P/ y1 U5 _) T
    组件通过web.xml向容器描述自己,使容器能够认识组件
    2 i0 B. E9 V. _" b5 i4 ]6 R
    + S) `9 ]/ H7 K容器通过回调方法来调用组件
    8 T3 B' J; X/ w9 i% N2 h, [# G* I2 }, g
    分为两类:web容器、ejb容器5 e! p" R, S, J% o% I4 G
      l( t% B* h2 ]& k, u& u& {5 w# G
    3.服务器 : 提供容器的运行环境,提供大量的JEE基础服务
      d9 O: w, ~2 A, z/ o% g% S8 k+ i$ a+ D/ n
    web服务器(只提供web服务)
    ' e6 A6 c" K& ?. S+ e0 ?
    ) H) R; B* M6 ^2 Ajee服务器(提供web、jee服务)% h8 p0 z% G) J- ]" H' P8 P6 O2 \

    ) o: O, q$ g) `2 ]5 M# d6 ~+ n
    . W+ M! f) k  w
    * f& T5 @6 E0 ]6 V% r# y4 x+ f1 D什么是回调方法
    6 p9 B- z- F0 l& R' d: x  G由容器自动调用的方法,就叫回调方法。
    4 K. w! I% ~; L. {! ?' [0 t! S3 X5 k# g8 [( Q
    ( C0 V  S# {  g9 C

    # h8 H/ d  x/ ?' C7 vRMI远程方法的调用机制9 e) C( \4 V; W# n
    例如:A主机有B()方法,C主机有D()方法,A 想调用C主机的D方法
    . W  I2 I$ i, G1 O
    : {) @2 @4 D- r, Q& B3 Z- a: K# I4 ?1 `+ ]0 p, ~5 `5 j
    % k  l. D  Y+ y* @9 u

    , d9 E$ s# \% j: \5 i+ l( x% n
    2 u% y; a- l$ ^5 }4 \2 X学习方法+ K! U: A0 P% B; j3 |0 V( r9 R7 M
    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 |只看该作者
    Servlet% {& J# \! j4 M
    •     描述war包、jar包、ear包的结构
      / a6 t& F& p. [. L  h& R
      ; ]/ P/ \+ D/ x" T; [% Q
      7 d0 v4 c3 P' X/ k8 Z7 r4 v

    war-                            web文档压缩包

    —WEB-INF

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

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

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


    ) J" \7 z" V" \; t( J$ i& [* e

    jar-                             java文件压缩包

    —META-INF

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


    & S" p0 v- ]+ m% F& S- z

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

    –META-INF

    —Application.xml 配置文件

    –*.war

    –*.jar

    . H9 k2 [' i+ m+ q% @
    • 什么是servlet?servlet主要做什么?2 W- h3 ]+ Q: ~9 J

      8 \7 M! h) r0 E/ N2 Y& ~( L3 _8 k0 Z

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

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


    & D& \, S5 E, W6 F" v1 v
    • servlet 与cgi相比的优点?servlet的缺点
      $ B9 o2 j# v3 z& ^8 v7 q: A6 z+ t1 y

      ( [5 I% U! ?$ h2 ?* D2 A. U
      + V% I& V+ I3 x( s8 `6 b& D

    优点:

    性能(线程比进程更快)

    可伸缩

    Java强健且面向对象

    Java平台独立

    缺点:

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

      J0 B1 T+ |8 _, i4 C- z
    • 常用的servlet包的名称是?4 L. i* s; b2 U
      8 C# W7 m5 Z& H$ x9 E7 i
      . @+ C' g, q8 w

    javax.servlet

    javax.servlet.http

    " l* O; N5 ]4 b, }* K
    • 描述servlet接口的层次结构?/ [# J0 W) C; V8 R- M
      . ?' c4 v0 J' [' Q! n# E

      0 V8 Y# h( |/ J2 z: P: z  V

    Servlet

    –GenericServlet

    –HttpServlet

    –自己的servlet

    ServletRequest

    –HttpServletRequest

    ServletResponse

    –HttpServletResponse

    : m5 w0 k, [* L8 o
    • 对比get方法和post方法?
      # \  w! n% H3 {. u4 t

      9 w, h. f3 j; Z, y- P
      4 t* O7 ]; f/ U7 X6 U6 i8 ~; F

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

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

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

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

      _9 Y. N$ c/ o/ E& |: \5 z2 A$ [
    • 归类描述HttpServletRequest接口都完成那些功能
      / A3 P- O6 {9 u

      " v: ?& y2 |5 r+ @8 w: \
      5 W' z$ b# i& {+ ?2 n
      • 读取HTTP头标
        % V5 e4 r( T4 I8 C" h$ p6 T. Y3 r
      • 读取cookie
        8 `9 j; A! J& J2 s" t. ~
      • 读取路径信息
        . }" u7 U/ r5 K1 J' e
      • 标识HTTP会话。# _# T  P/ Z2 q; h, }% M: |
        8 B! z; _7 N' j5 n% W& q4 k

    - h+ ^( k* Z" x! j4 J
    • 归类描述HttpServletResponse接口都完成那些功能( J& A( \3 n9 G( d
      2 x! r! \& u: g, `0 d! G
      / Q7 S$ z: [# s
      • 设置HTTP头标! h& L: G  p4 B! }
      • 设置cookie" b/ @4 A. R5 a4 J7 w4 H
      • 设定响应的content类型
        " K$ {5 E0 v5 v0 O7 N! [" z
      • 输出返回数据
        ! U% L2 }. ^3 n0 f
        $ P7 s9 i$ ?- _% t

      f1 ]3 C. S( c$ V4 F
    • 描述service方法所完成的基本功能?默认是在那里实现的?
      ) t9 \* c. a5 C) w9 s
      - e5 o+ Q0 k# S  D4 Q) m

      ' }; P9 Y" D  T7 ^1 a2 u( l% M

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

    实现:默认在HttpServlet类中实现

    ' z5 q6 j1 {! q1 \' X- S
    • 如何开发自己的Servlet?描述应该做的步骤和每步需要完成的工作% g( Y8 B5 x; ~! _- u

      ( R( R# h; e( ^( r
      ; g- O+ W8 ?+ z8 H

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

    # l3 E) t% s, V: u$ ]) M7 m
    • 为何servlet需要部署描述?1 T8 m6 m+ \8 i$ _; v
      2 t- H- s+ V0 q' z

      . D9 ?6 T2 R8 x( k

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


    - r' H; i3 s4 @+ |8 G6 s' N0 |# _
    • Servlet基本的描述应该是?请写出来/ A: [8 o* {6 q1 L4 O+ M

      3 j; W  B0 T/ G" F) m4 T( a8 v6 M4 {* c* Z3 S

    + A& ]( N# b2 \$ P3 F4 H- S

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


    ; `2 g, F: R) X1 c( [$ x5 [; J5 f- c
    • 如何在html中使用servlet' a' g: Q- P4 x( j9 y5 F
      ! m# c0 o- Q2 G$ s% J4 d
      ( X' n+ B* i0 U% y' L9 y. t

    FORM标记

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

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

    语法:

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

    {HTML form tags and other HTML content}

    </FORM>

    ! ]5 ~& o' W4 C8 a
    • 如何接受request中的参数
      / S: y( I* E/ `7 r
      7 H5 L) W5 ]: o8 _, g
      String userName = request.getParameter(“userName”)方法
      1 T* O$ r0 O1 M1 p+ P+ s+ R! C3 W7 Y% a7 `: p" M# ~
    ; V4 q' K; g% _' l* r
    • 如何接受request中header的值
      . n! t3 A7 i" M/ J8 X9 L4 }

      9 c4 r. ~! Z! e) h0 x2 _' O( a0 Q" t

    request.getHeader(name);

    request.getIntHeader(name);

    request.getDateHeader(name);

    request.getHeaderNames();

      X' z- C1 r  a, m/ T, A7 I& ~
    • 如何输出html
      # w7 ]  O" B2 {/ l" w/ _

      7 }% r3 `- |) \8 F
      2 O: y6 Z; f1 a4 I! i

    PrintWriter pw = response.getWriter();

    pw.write(“<html>”);

    pw.write(“Hello”);

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


    1 |7 h* E$ m: Q9 a4 r& U& G! W
    • 如何设置输出的contentType3 k/ D; A6 v" i* y% I2 Z8 \8 R
      . p7 h8 s7 M8 j" i) ^; l. W% y
      3 F3 `- ?/ W' v& k5 ]1 ^

    response.setContentType(“text/html”)

    + Q3 t3 O( \' B
    • 描述servlet的生命周期?- x& I# [4 u( K# i4 c

      5 Y  }- Q6 n* x% k
      % z  ?+ _% }5 V' @0 l

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

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


    7 k# v( g& d+ |5 N8 d& @
    • 描述init,service,destroy方法的功能和特点
      . p) n; E0 |6 z7 C: I+ c: K/ q' v$ D
      " a  f) p( T! s- S$ G) C

      9 |5 O4 ?6 s6 K* Z1 h; C. Z5 [

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

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

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

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

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

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

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

    6 L9 I* T$ i8 u4 p# U) W; J0 m
    • 什么是回调方法?有什么特点?
      7 T) h* c  `% m. ?; z
      " V! H" g$ R2 [5 A2 M7 T* D8 [

      3 T( m7 @" t- k: b6 S/ ~

    由容器来调用程序的方法

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


    & B- Z- L, h' T; ~+ s1 F5 }
    • 如何设置初始化servlet的参数?
      2 {* F# S8 f9 Z' X% j  K
      0 p  i& E0 q% r. j
      在<servlet>中添加如下配置5 B/ v5 N7 U2 D. B. z' p. x

      & F1 W" `3 C% u% n- s6 U5 `% Z

    <init-param>

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

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

    </init-param>

    ' Y  w2 W) V# H
    • 如何获取servlet初始化的参数" J! s9 ?& `* F1 n' a' n
      1 K4 q) R" z, _3 A& b7 U

      ) b5 ^$ n: x/ Y

    public void init() {

    greetingText = getInitParameter(“greetingText”);

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

    }

    9 p6 z: e0 P# @6 W9 K7 Y0 V
    • ServletConfig接口默认实在那里实现的! S7 c. w2 Y3 x$ x  c

      1 \9 Q2 A( Z7 K! n) f5 L# X" Z; f- P$ j

    GenericServlet类实现ServletConfig接口

    % U' b; ?, w4 x0 a8 S) |
    • 什么是ServletContext?有什么作用?
      7 Q% v, r  A& _; _% T0 K
      4 I: i* B2 r  Y, y& G3 c

      % {3 R1 a6 U, Y, y8 `

    Servlet上下文

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


    # K2 S' ~+ _2 j. ~1 y: ~- O/ O; g
    • 如何访问ServletContext接口?是在那里实现的?
      6 ~2 W. x! \8 a6 M0 ]& H. F

      ( L5 o- o: c+ a+ Q+ N0 t& g5 o0 o* ^1 g* J/ l! r- p9 \5 s5 ~

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

    GenericServlet类实现了ServletContext接口。

    % w; g3 I7 E% {2 B
    • ServletContext接口的功能包括?分别用代码示例
      ' x/ R7 M7 k+ h) l/ V

      0 q/ G3 V# O. J& C5 i% E& d3 c) b. z5 Q% C+ M  x7 Z5 Q

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


    : I$ l4 q# ?$ k! J4 l
    • 如何设置ServletContext的参数?0 U" J6 s1 Q( a3 N

      0 |$ p5 {! P' e- o2 ^( B' T5 y5 c

    <context-param>

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

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

    </context-param>

    6 j! G' w" ^; T1 b! a
    • 如何获取ServletContext设置的参数值?5 }* Y! ^# [  q! V4 B" w
      6 _) P/ H% P  t. {+ V) f
      - o" [8 s. S* p% M8 G; q  u

    ServletContext context = this.getServletContext();

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


    ' {% v& Z& f/ T- g, t
    • 描述Web应用的生命周期?; x0 t7 y& i# C* o: _% `
      # E" E7 P$ w# Q/ |
      ( ?2 a1 U* v" k

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

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

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

    1 s! U( z7 b+ T  B, E- a0 C
    • 如何用代码实现监控Web应用的生命周期?
      : F6 _0 e% [: q1 {) n2 }

      % ~9 _; |1 d: K+ b; N" A( f+ T: R8 Z) F& f
      ' `6 s, s% u* S2 w6 T

    public class Test implements ServletContextListener{

    public void contextDestroyed(ServletContextEvent arg0) {

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

    }

    public void contextInitialized(ServletContextEvent arg0) {

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

    }

    }


    3 J" S  E, l9 c. S+ I7 h2 D. |

    web.xml文件中的配置:

    <listener>

    <listener-class>

    com.csy.Test

    </listener-class>

    </listener>

    , w, D7 L8 T$ D/ ?
    • web应用中如下错误码示什么意思:400,401,404,500( Q* E/ `, G: l1 V
      ' y- {- ^5 ]6 W3 C/ u, A5 V( B
      400 Bad Request//错误请求
      401 Unauthorized//未被认可
      404 Not Found//没有创建
      500 Internal Server Error//服务器内部错误
      1 c# }7 }0 [. _- E6 a
    9 E! ]- {( e2 c/ _
    • 描述Web应用中用声明方式来进行错误处理的两种方法
      6 o9 j4 J* A- H& W$ `+ i

      0 B- C% [5 x- t1 P, O3 y( y& }2 G+ L8 N8 u" W. Z" N; ~

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

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

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


    % g& f" Q0 M0 R- A
    • 描述记录异常日志的方法,都位于那些接口?
      ' f; ?6 S; S" S8 b+ I9 _

      ( _/ K& i5 d) D) h
      0 Q! p' w' e8 z4 M( k$ T+ e

    GenericServlet:

    log(message:String)

    log(message:String, Throwable:excp)

    ServletContext:

    log(message:String)

            log(message:String, excp:Throwable)


    ' H$ E5 x! z- x6 y/ Q( {
    • 什么是会话?
      ) ~; [$ D/ l( e4 D
      : R! ^) @0 s) l! g8 d# C4 a, N! l. m
      # Z: b: Q$ c9 k/ K' |  k. N

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

    " A- x' a- E5 v* R( O& ]
    • 如何获得会话?
      + W! E) ]4 M3 f3 s" Y

      % f( `+ @8 U# `. Y
      HttpSession session = request.getSesseion( );

      ! |9 H, h6 c! ~7 S

      I/ k* |* Z/ k: c( U+ @6 u
    • 会话Api的基本功能?
      2 o+ q% n6 t2 H8 D1 o1 W4 u

      0 \3 l4 E, K2 G2 @
      & B! |5 o, S- W* i7 ]; Z1 z

    getID() :String
    1 o, ]3 W2 }0 Q# G$ _; Q9 q% [

        isNew() :boolean7 x: X* ~8 k2 E) i

        getAttribute(name):Object
    ) k, y; E! o# z, q

        setAttribute(name,value)$ o" C0 \# F; P

        removeAttribute(name)

    4 v, E! _' {% J4 L% N6 M) K
    • 如何销毁会话?. s$ {( T; Z0 R& Z
      , D# q* J$ f3 t- Y: j' M" Z
      7 N6 w9 t  Q5 A4 b9 ^( E

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

    <session-config>$ A! r1 C7 r# t

             <session-timeout>10</session-timeout>
    9 ?. E, p* ~! \$ K. v, Y# T+ [

         </session-config>% F0 |1 p% [) M9 A: o2 U

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

    invalidate(); K& u: L3 i& k- ^0 t

         getCreationTime() :long
    - n* a# x0 p; W  c/ H( q4 x

        getLastAccessedTime() :long0 f, I; }* W( j

        getMaxInactiveInterval() :int& S5 i( Y( r! }# j+ \7 G

         setMaxInactiveInterval(int)

    1 E. \- A# O7 ?; ]4 W# }
    • 描述会话保持状态的基本原理' d% r5 w9 A9 q# C
      + H3 n9 F$ Y- F

      5 ^2 X2 q. Y' w1 D5 @2 P- Y* l4 X$ @1 g

    $ l( U. c2 S4 z, O0 j5 K5 `. N

        client server
    " g1 T8 n$ f- V7 {9 m$ H9 U


    * S0 \0 L, F1 r

    request
    9 J0 n, r8 H' ^

    response (sessionid)% o4 x0 ^, v: Y: t

    request (cookies)
    / s# w8 @9 t: @3 B- B$ g# f. C1 a

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


    # W% y+ @1 ~  y
    • 请描述session和cookie的异同之处
      4 P2 q, s1 N# {: r- G3 u$ z/ R

      % [) V1 q. k" A$ ?# T& r/ J  a9 I% D0 ]
    0 g. S5 U% Z9 ~( u& H5 W$ K

    - N1 ?2 r" _0 c: z0 ~% [
    • 如何读写cookie,代码示例3 _5 P5 |# }' {3 D6 Y

      7 L$ h$ H; Y8 V: `2 g2 B" B/ m/ H- N. R2 ~# ^: T9 H

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

    response.addCookie(c);

    读:Cookie[] cookies = request.getCookies();( K& i/ j! W$ v2 j, q6 h5 q

            for ( int i=0; i < cookies.length; i++ ) {$ h0 j: T- {; s  F

                String key =cookies.getName();, m2 p% ^3 N. |- s- s: `

    String value = cookies.getValue(); ; D: S1 M6 [. q

    System.out.println(“cook”+i+“:key=”+key+“,value=”+value);. q+ d  h  z8 R

         }

    ! f1 R8 ]& K6 u( c
    • 什么是URL重写,如何实现,代码示例3 o1 E: ^( v8 q- f

      7 G+ L9 K" Z8 s: v$ i
      , d5 X2 @: ]0 F: r

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

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

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

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


    + H$ F$ l5 U9 ?7 s# k; b' i* A$ @
    " M# e; r2 b! D1 N; M: h
    • 描述web应用的4种认证技术4 j7 r: [/ b+ c- j+ C' ^" F' h

      5 m# H  r+ E8 K, {: B5 g/ P( l% Q
      ' I( I/ ^; t# }5 R% K) u

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

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

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

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


    , m) d; [7 q. o$ r3 {! ^) ?4 A: |
    • 什么是授权,什么是验证?
      5 l" {9 R: U" m( Z* K8 k( l
      * H& v+ X- x6 H" z
      , {: d5 h' m  W

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

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


    / _7 _, B8 J0 O9 x! l# X9 `
    • 什么是HTTPS
      9 z1 w- m4 g& u+ u2 L$ y4 c0 Z
      $ p# W) n6 E" @5 G, B: g
      + ?' L3 g5 R9 p5 O# ?

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


    9 ]' W/ @" ]1 |9 b( U" R7 R' i4 {" q
    • 什么是审计?$ P* `4 v3 H3 W- f

      % `2 z/ L$ X  k0 \9 b! A0 f. O8 m$ {3 P; z: o! \* u  }+ u

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

    , m) @5 ~+ l+ Q7 K7 D/ o
    • 如何实现声明性授权
      * L, ]# k9 t# z  b+ B# \
      ( o! q; J6 p8 [* \% I
      ! Y. h2 a0 l, M& m* |' L

    1、标识web资源集

    2、标识角色

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

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

    在 web.xml里配

    - C: k& v; a% u! z2 m4 R7 V% `& N1 j
    • 描述servlet并发问题?
      % c- Z1 X' [( u

      . f; H* l' n- m; D$ @. ^! c1 o. z0 y

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


    3 ]: K+ A- n5 ^6 p0 A
    • 描述Web应用中的六种属性范围
      . r+ Y* B9 M& u5 z
      0 c% Z. B* N$ ?3 f9 O) K
      ! O- ~) ]; A6 j  B" L/ }* k

    局部变量(页面范围)

    实例变量

    类变量

    请求属性(请求范围)

    会话属性(会话范围)

    上下文属性(应用范围)


    : g0 ]2 R9 Q4 i% I, k% l9 s# D) P
    • 指出上述六种哪些是线程安全的6 `" i3 k: L9 e$ s0 T

      9 _" k0 _0 m% c" j  S& P( a! ^& e6 o5 m; W4 B' t

    局部变量和请求属性

    ' m, x. j4 ~( ]% X# O
    • 什么是STM?如何实现?4 V! f: f9 w/ \9 Z6 P5 k
      9 p. k, O& ^/ y5 J  J+ |

      . g# Y# ]# f2 f+ p( E) [

    SingleThreadModel接口

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


    * y% M) r4 T( S3 [" }* ~
    • 如何实现并发管理?
      4 X7 w* P' S* ~5 H4 E- }7 A
      ( s: [" v& @4 ?. |3 ^

      ! ]2 }9 }& @2 f2 R# z- [

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

    使用synchronized语法控制并发

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

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


    ) w, {: f% B$ f6 g; Y% W0 j
    红红火火恍恍惚惚
    回复

    使用道具 举报

    admin    

    1244

    主题

    544

    听众

    1万

    金钱

    管理员

  • TA的每日心情

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

    [LV.5]常住居民I

    管理员

    13#
    发表于 2014-12-03 12:45:45 |只看该作者
    Jsp
    ) ^& {+ [6 q: B4 S什么是Jsp?# p. x) ?* X. x4 [) [" F3 ?
    Java Server Page    结合java和html在服务端动态生成web页面的技术
    / z0 \' _6 B  z8 H
    . o" W# F, Y* O8 u" G" f- J% I
    7 V' i: Q/ x5 H0 u2 P; H' B; h- J% d: s  s
    描述Jsp页面的运行过程?+ t6 S4 D2 F0 }4 w+ m: m% Y$ ~7 e
    第一步:
    & T* }2 R% G( J4 F; J6 |# z9 _4 F3 q  B+ M3 K
    请求进入Web容器,将JSP页面翻译成Servlet代码
    : n" z7 E5 q+ B2 h% [8 g5 C3 q$ [0 f2 N8 q6 U' `0 H! H* s
    第二步:
    3 k+ W0 F: u' ~- Q  k
    * `* m; }7 X2 x8 t# T编译Servlet代码,并将编译过的类文件装入Web容器(JVM)环境
    5 C2 W8 D# Y) q% N' L* g- s6 I: W- D$ j/ ]" d
    第三步:
    4 j  N9 c- a3 O1 Q3 f: I# z- L* J/ c9 @5 ~
    Web容器为JSP页面创建一个Servlet类实例,并执行jspInit方法
    * q* y( p, v8 a! `. j
    : i# Z) H( |5 |. u) d第四步:5 o) i5 l! q, j
    & E2 t: a2 L  L1 H3 n
    Web容器为该JSP页面调用Servlet实例的_jspService方法;将结果发送给用户8 x# j1 t! A( R. P
    ) u1 N# _2 i: X8 N! c

    $ `% C! Q" f% f3 g; \0 p. S: _$ K* B2 x
    描述Jsp页面的五类脚本元素的功能、写法、并示例
    8 z. k6 O6 T# S" _注释 <%– –%>) g$ |) y* g4 V% i! s

    % m. ?; ?, R8 [  m8 T0 R<HTML>' h  X$ Z6 p8 o- @) d" s

    $ @- C( F/ o0 d& A2 g/ D<%– scripting element –%>, z$ m  ]; @  S+ q

    6 l, R, j. D( E3 p</HTML>+ H' \! F# c" H4 E% ~% ^/ }2 s, J

    1 u) a2 W9 c: b- p2 ]: X; b指令标记 <%@ %> 指令标记影响JSP页面的翻译阶段
    5 g6 K7 m  l+ ~0 Z0 w' Q; V! \5 O8 E6 c( g* p0 B
    <%@ page session=”false” %>
    . Q: o6 d2 K  V
    6 o) m1 Q6 q6 g# j声明标记 <%! %> 声明标记允许JSP页面开发人员包含类级声明
    3 F9 J  z; \) j3 a9 r6 w% s! S& q/ l2 ^4 C9 V
    <%! public static final String DEFAULT_NAME = “World”; %>1 O$ I/ u7 W! C, i1 I( q( D, I6 e
    3 Y7 A. H+ D* M7 Y2 p6 u
        脚本标记 <% %> 脚本标记允许JSP页面开发人员在_jspService方法中包含任意的Java代码
    9 e& ~$ y$ |/ y& v( Z# h1 i$ Y4 w
    " J7 \/ q3 V( t4 _4 J    <% int i = 0; %>) H& O# ~5 ~5 U1 F( I
    0 h' M5 j6 ^9 d) A: r7 p  n" y
    表达式标记 <%= %> 表达式标记封装Java运行时的表达式,其值被送至HTTP响应流 <B>Ten is <%= (2 * 5) %></B>
    9 t& T8 ]; a  A
    ) H7 G% p  J  M  d
    + E$ v3 g& ^! h7 H$ y
    " [! V, {4 p/ l0 Z描述Jsp页面中的注释种类和写法
    * H+ c; l: \: h5 W4 \$ i' e! GHTML注释
    ' X/ X1 A7 ~- C: w" X7 K# P( h& ?% _5 f  C% R
    <!– HTML注释显示在响应中 –>% r9 J8 r+ K6 h* H( v% X
    6 s- {; d2 J" D6 c
    JSP页面注释
    " P  e8 S" F) E+ D
    8 I6 l  e- T) c/ v<%– JSP注释只在JSP代码中可见,不显示在servlet代码或响应中。–%>
      t7 G* w, R5 w. I- _$ t7 g, N$ x+ F$ a' Y% c8 G( D9 B
    Java注释6 m3 W" n$ `/ D$ i& ^
    # K1 F7 O$ V2 E# U- l9 C9 ^
    <%
    3 o+ R: {4 X: ], m) {$ H9 T" ?. r+ n6 Z+ G2 Q2 @& C
    /* Java注释显示在servlet代码中,不显示在响应中6 y5 }' y. h: o" w# f2 P. P' T
    ; }5 Y3 H5 m" u% Y( t/ _0 m
    */
    : _$ J* n2 Y1 R" V+ x7 Q9 `
    . O$ G% L( t, J& Y' M%>
    % f9 m& k& y" `
    1 K. v( S/ C/ ~+ [6 ] 1 X. I4 g& h& B2 w* p' ?  Z

    ) B  }* r( d3 a描述Jsp页面的指令标记的功能、写法、并示例
    3 ]/ _. }& D/ E- @指令标记影响JSP页面的翻译阶段
    , X+ {' R+ _0 F) d8 v' ^- [: Y& ?9 T  c+ B# C+ I
    <%@ page session=”false” %>  G, S1 t# Z- C4 X

    # x- p) m- L; o5 }/ P9 g: o4 J<%@ include file=”incl/copyright.html” %>
    & `6 ?$ E- p4 b2 F: d) b- @! U4 Z2 n
    <%@ taglib %>
    ! G. w5 Q7 N4 I, v) g6 c- S; F: C4 K0 D/ L5 K% \8 J
    ) P( V4 |9 L; ?+ Y2 k7 ~% F& L

    % q( s, T# g4 p; f0 g: Z描述Jsp页面的声明标记的功能、写法、并示例2 m* v% j. w" P  D8 Q
    声明标记允许JSP页面开发人员包含类级声明
      O3 Q7 L$ `+ |" n+ I3 y9 V8 ~5 u/ @! g- |$ M
    写法:$ a( G; P+ t4 l: }, ]
    + c8 i  i2 T- N9 F, y
    <%! JavaClassDeclaration %>
    2 f3 _6 v, w+ R9 s  z. C, R' Y; p4 O. W: q
    例:$ V0 X* t5 n' m2 P  V

    9 I9 t9 N+ f8 u, _4 ?/ d<%! public static final String DEFAULT_NAME = “World”; %>
    , F0 G# ~  g' e" R5 E! v. F
    * `4 {! s3 T+ D0 _1 n5 ^4 J4 Y" K<%! public String getName(HttpServletRequest request) {( J! I. ]: r7 r* I1 \; Z) ^: B
    ( i+ c$ O2 j! g( J
    return request.getParameter(“name”);3 p3 @& `$ ~: s2 U/ U3 g
    1 a7 t  G5 J4 ?8 [
    }
    5 B# k3 Y$ Z- ^+ U; k5 n  q1 ?, Z% q+ A# `, D% p
    %>: M- A8 p  a1 {4 Q. B# X: k
    ' E6 C6 ?+ ~# E  d7 }! \
    <%! int counter = 0; %>
    ) C" E/ [' J2 J* m1 v) U' ~! H
    , g: r) q0 }6 j6 C5 x0 v/ M* ^7 p * G3 `% v! s) N$ g) ~- e% _

    ! i1 J$ ]: i$ Y" l描述Jsp页面翻译成Servlet的规则
    " M+ Q$ j9 B& `/ z& w* k% ]- Pjsp中的注释标记被翻译成Servlet类中的注释
    6 c& G: H. S3 F3 }  L; n! ^
    + F% q8 i7 Z( @jsp中的指令标记被翻译成Servlet类中的import语句等8 M" b/ @2 G$ V1 o+ y3 k" @- A) ^
    ' v0 {9 P' ^4 O1 {+ o+ H, s0 ^/ S
    jsp中的声明标记被翻译成Servlet类中的属性+ f. H+ M- f5 {  W" O

    7 v+ H1 z5 f* q9 o9 c4 k) A' Y" Gjsp中的脚本标记被转移到Servlet类中service方法中的代码
    , ]' _& Q5 t1 y" U) @
    0 U6 Y: ^+ |- d0 g3 `7 L' gjsp中的表达式标记被翻译成Serlvet类中的write()或者print()方法括号中的代码
    5 J! ^4 B. _! `0 {5 D7 n" S0 {9 I  W% x; y8 z8 X
    8 n2 b& r/ g  o8 g( r: B0 r* }6 n
    % c7 E, ^! p* J1 x0 a3 E, s
    描述Jsp页面的九个预定义变量的功能、用法、并示例  ?  y$ U8 O/ h4 |
    request 与请求相关的HttpServletRequest对象! h; z5 N* c: H/ o) e8 {* |
    1 H9 G' s. ?2 u# Y
    response 与送回浏览器的响应相关的HttpServletResponse对象
    ; e/ ^) @- j7 p; d
    ( \0 d$ [* r! T' lout 与响应的输出流相关的JspWriter对象$ l8 y. u6 P! m. U+ a, \
    3 t+ k6 z. z. r- {) w% n! ?
        session 与给定用户请求会话相关的HttpSession对象,该变量只在JSP页面参4 k( `1 l( z% O* z& d, x. m
    / l1 c' J7 G9 v7 V; T2 ]  e0 {
    与一个HTTP会话时有意义
    ! j4 n1 O3 x# V, e! M! c! d( D- {: \
    $ P$ J( V1 B0 k* [* v    application 用于Web应用的ServletContext对象, H' V6 h/ H& }. o: W  C

    % T% T: J5 P9 f3 t9 E+ i, Dconfig 与该JSP页面的servlet相关的ServletConfig对象
    9 w5 r9 s* V$ d% U# r  m& Y, n$ J
    - A; D: z, T) |9 Z, i& g$ N- Q  TpageContext 该对象封装了一个JSP页面请求的环境3 ]9 Q* B# _' @9 E# `  w) e

    ( |; b  U2 G$ w1 D2 g! Jpage 该变量与Java编程语言中的this变量等价( I( J- N2 b# K4 y, e7 S8 V

    4 w% Y0 `  z& N, S. L    exception 由其它JSP页面抛出的Throwable对象,该变量只在”JSP错误页面”中可用) A$ ]- n! g/ _  t: @' E3 Q

    ' L( U# L, V: }* Z8 J- t
    ) V/ w) L( C7 t( c* p0 M( I8 C4 s6 O% n9 h7 E& H9 U
    page指令的功能,写法、并示例,并描述它的如下属性的功能和用法:import、session、buffer、errorPage、isErrorPage、ContentType、pageEncoding4 Q' B# @* Y7 W# h* N" k  d, l) c0 L
    import import 定义了一组servlet类定义必须导入的类和包,值是一个由
    : X* B8 V+ m9 s6 d3 y: T0 S
    7 j1 l9 `8 ^1 B* T/ }! }$ Y逗号分隔的完全类名或包的列表。8 n! t4 g: K# E5 q
    & D8 G) }/ R1 J; N  M
    session session 定义JSP页面是否参与HTTP会话,值可以为true(缺省)
    4 R1 q: K. a4 F9 B  M- V9 p! E" [$ R$ ?
    或false。
    & C/ }. \+ b+ B$ d4 y2 v* ?' Q( S6 {# R3 u; l
    buffer buffer 定义用于输出流(JspWriter对象)的缓冲区大小,值可以为2 ?: k, I9 ^$ j% t& U1 Z- f2 a, y3 V
    ' _# }# S5 f  c3 ?
    none或Nkb,缺省为8KB或更大。
    " X8 R# n' E( M' K: T6 p. K  T/ _) b2 Z
    errorPage 用来指定由另一个jsp页面来处理所有该页面抛出的异常
    7 o/ d+ B4 i, N. f- m$ c. ]9 ]0 Y  V  I; ^9 [
    isErrorPage 定义JSP页面为其它JSP页面errorPage属性的目标,值为true或1 b; u7 K. J- r2 u
    0 r- h1 `4 k' K% m9 L6 k# `
    false(缺省)。: |* L# C2 T: I

    4 o  A+ X" f0 k- l: g  E, {3 UContentType 定义输出流的MIME类型,缺省为text/html。
    % Q+ Q- P& F) \% Y* t; ]+ }- M8 |0 l2 B4 d3 Q* G( Z) R
    pageEncoding 定义输出流的字符编码,缺省为ISO-8859-1
    , y+ s; [% O: ]. W/ Q3 {8 {
    * b4 U1 [; a3 f5 [5 J& y   j1 `- c, i$ b" t
    7 z" D7 ~6 R4 a
    描述MVC各部分的功能?MVC的优点?MVC的缺点?
    2 q+ U" i8 p  j- N7 v% IMVC各部分的功能:# O7 G+ Z# r/ d9 V# h0 A

    + ?8 _( H; X; _9 K/ q% B) {# d% T9 vModel(模型表示企业数据和业务逻辑)
    / N, T8 J2 S9 Y& R7 N2 T+ T; U5 p5 X5 X5 ?% S' N
    封装应用状态9 z( ?7 g- z9 K7 c
    , R$ Z# X9 a- D) V) O3 W2 [
    响应状态查询
    " t- N: c4 C' c
    6 Y& Y  J  u/ F3 C3 k暴露应用的功能& [0 A% O, Y9 N- ?& l# e# u
    8 ?3 R# m! A0 ^9 B! w  n
    Controller(控制器接受用户的输入并调用模型和视图去完成用户的需求)
    8 v5 p* V5 L9 j/ `" o$ n5 v7 Q4 m# l6 j. }+ p3 f8 a
    验证HTTP请求的数据: p( Q# g: k, ]
    # T9 }+ V3 H; }/ {1 d7 f4 x; }
    将用户数据与模型的更新相映射
    ' y. E- |& w3 J7 m6 E/ U" E& _, W' D: t3 n. N$ U3 u7 H$ l0 T
    选择用于响应的视图
    ( D: r: i! x* u7 J
    ! x, w- F7 Z. t$ W3 d3 A$ `9 A6 n" vView(视图是用户看到并与之交互的界面)
    / V& o7 E4 z8 z% E$ ^) o/ Z9 |3 a7 Q6 T& `9 K  G( }& \
    产生HTML响应
    9 Q( Y& I3 u5 x" R) R
    7 P8 W' V8 ?, k/ o# R请求模型的更新
    4 V+ ?! |" h% |4 o. l9 T  S( v4 C0 u+ w% z$ p" I0 f$ k
    提供HTML form用于用户请求1 K4 [# l: c+ b( ~+ V7 ^9 i
    ) k, e& V) A( [
    MVC的优点:: z, \) ~& Q2 U, X
    # _4 E5 B; _! a! K
            低耦合性:视图层和业务层分离
    . i! ~. C) o) m/ _. U/ n4 a
    6 J& N+ P+ s4 Q" Q# n0 }" A1 L, c高重用性和可适用性/ Y# G- b! P7 Z
    ) b  {; E3 Z# s9 z
    较低的生命周期成本: n8 m# Q4 i( f  h  P  B
    3 j/ V  }. A" R  n
    快速的部署6 f9 i- R  @& I% \
    0 d; a) u  F5 w: E2 t) {- j
    可维护性: ]! U, }& ^/ S2 Q; ~1 O
      i  D9 Z- x5 `' Q
    有利于软件工程化管理: j3 ]1 [+ _& _! h# v7 W' Q* E
    ! a+ v# C# j0 e! g0 q% v5 H
    提高软件的健壮性
    : `: ^$ ^1 ^; b+ c8 t( V
    5 k, x( r5 S: t' }MVC的缺点:+ Y8 R# t9 [& U* j+ j7 d! r9 m
    8 D: G, @% @4 r. _
            工作量大,增加工作的复杂性,MVC不适合小型甚至中等规模的应用程序$ i2 t6 a% C' l; i
    ' H" g' n+ s! A  L7 z: _1 M9 i. ^
    & B7 R2 r$ g0 a' X) l
    ( A  Z3 X9 N' F+ }8 o
    什么是Model 1结构,以及结构中各部分的功能
    3 e; F# e& Q4 n! G结构:jsp+javabean
    / u% y& u) K. I9 w! f( m/ K+ z' T) w. ?6 R6 k0 g% t# A2 y: s
    Model1中使用jsp来处理web应用中的视图控制部分
    4 c% b. s) W% K  [
    # o& y0 t/ e" t" DJavabean收集参数' S3 _! q1 N2 U1 P6 Q
    * V7 [3 ^. |8 c& _( L6 X# O
    : A  Z* h8 O& x( u4 y$ p: K

    % n% [8 t# j5 o( W2 u) [* j什么是JavaBean?% v8 O) \) N9 F% ~3 D3 X# ]; ~
    用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包,并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。/ ^4 ^. ~. Q$ U& }. R8 _6 o' M. P5 K2 z
    * c# }% j3 y; A; k/ M! a8 p

    6 x! U0 a% p1 s" S
    7 J- Z# n+ w' JJavaBean的规则?& i4 n$ [; m7 {' H4 K; G
    使用get和set方法定义属性# t2 v. b1 I  N% U
    9 Q8 u/ Q7 o* m3 s0 m! m2 c
    一个无参构造方法
    + r) l7 l& s! {( g# F* v, |
    . P1 b+ W- ]5 y% ^无public实例变量( 所有属性私有化)
    + q& ~: |# B; x. v2 r( Y2 l& E, B: S
    ; T5 t- K8 _& `$ }- j; m* p& A
    6 c. C- \+ q! v+ _: K, Y2 Y
    什么是jsp标准动作?包含那些?分别都是什么功能?如何使用?
    7 N" l5 d6 r0 {; l6 o( |JSP页面中使用类似于XML的标记表示运行时的动作0 \0 v* h9 k1 x- i: d
    ( o7 `- {6 A  ~% Z
    jsp:useBean
    / E! _( o0 r6 M2 t/ o( Z' H
    7 i# i6 X% X" ^7 Jjsp:setProperty
    0 l9 p1 Q- R: \1 h
    ' H5 ~8 r' [% ]  Sjsp:getProperty
    " i0 \" \; W3 ~4 y' Q. y# q! w. @* j4 e
    jsp:param% D9 e8 O" ^% p( W! \1 ?( ^- T: p

    1 ]  O% C3 p% Q" d. ]0 q2 ljsp:include" w! }5 E2 }3 {. s. R

    # a( ^9 a/ V' o" D  _+ I! ?0 v2 t3 q1 p/ tjsp:forward
    5 B( P4 j% z0 f" ?$ x, c" p: f% G' n) [
    ; E8 b: v/ _  E8 ]' f1 _$ n
    9 t8 M' b- m$ |# w. Q' z
    用代码示例如下标准动作的使用:useBean、getProperty、setProperty
    3 p% g  P* ~9 ], Z/ T: R$ e<jsp:useBean7 }1 r4 i; k$ u

    # a: h8 i! Q( tid=”myForms”
    , y* F" g7 L! P* E& N* N# z& [. p
    0 L# R! K. @6 }, P: pclass=”com.base.mystruts.forms.MyActionForm” scope=”session” />$ P& _% F! C8 a- B: e" k1 g6 n' I
    7 l7 D4 a1 E, h' D) N# s. q/ j# m
        <jsp:setProperty name=”myForms” property=”name” />
    4 i* E6 D' u8 N1 b% V0 z( u) u( V# z; ~' j1 f
    <jsp:getProperty name=”myForms” property=”id” /># r6 g. o' G5 ?9 T0 U4 E, F

    $ W2 B( O  N! U4 x. o$ F0 G
    % l4 F/ l0 {% F) E: y; k: Q% N
    描述说明Bean的四种scope
    # D# _9 b& {" l6 T" N  ^& Lpage
    / h& g2 w: T3 s8 \0 B! }/ T9 q0 G+ m9 k* u
    request  K3 R7 \! h) b) ?8 t+ M5 @9 u( z
    7 ^8 Z9 j% L7 B  K1 r
    session
    1 c' n6 f5 e# A0 d8 ~' P7 B2 t& _7 [) c9 T
    application
    ! Q6 O  f/ c2 `! e: ^
    % o5 e2 Q/ s8 |  Z# P7 g * ^  M' @' v5 u$ |, [$ M

    & [! E3 E. Z/ Q6 Y. i) P描述说明页面上的字段和Bean中属性的对应规则* Q- e# }! {* W1 ]. W. e
    id 指javabean的变量名/ y7 k( a+ d  ?6 G- F

    4 ^3 U% A. l! Dclass指javabean类的全路径  N- r8 J$ ~3 u# ?# {, ^- i
    % g' a# R$ U. B1 L; ?9 V8 L- a# V: ~
    scope指javabean的应用范围( b/ A6 P% L, i0 F# I
    - v# O. j& K) X/ S
    name指所用到的javabean的变量名, d& e- W8 c6 d  @" g2 m% _; R

    7 U( s, ^) C3 y    property指javabean中的属性6 N5 r- j/ h6 p/ w* n) K

    7 W7 V" h! ~- }- T 5 Q+ A/ z3 i4 {

    $ t" c4 a4 @7 [; t& w* w描述useBean动作的处理过程7 Q- y# j8 x+ z( X9 q
    使用id声明变量
    , [+ D$ t( e: G  _+ Z- R) w0 P8 u0 n* H; E" U/ C* I* ?/ A
    试图在指定的范围内查找对象
    ) w: B8 L8 O# B0 F" H
    4 z6 ?0 |: ~4 c' |1 \如果没找到4 ]7 d  a1 C5 {, ^

    4 k& I' x+ `" p: L% \0 s# [创建一个类的实例
    , c0 o+ @: I, w# u, L6 p- p
    8 [; J$ {* M  W1 A) N$ X# B! p执行useBean标记体初始化对象
    + o2 U) }0 _- n* `& N0 u. \" ?3 M# I: b/ m  K
    如果找到
    , t; N# ~+ R& A0 k
    7 i; X& p. e) M- M     将对象转换为类指定的类型8 B  Z+ a( x& r; c+ q7 D) y6 a

    0 a/ N1 y3 y8 m. j 7 I7 T6 j" W0 ^( [/ D! h, H. T$ g

    7 h, @4 F) N: j描述forward动作的功能; s. x# E% u7 X( M- c
    使用脚本代码处理请求时,可用jsp:forward 动作产生一个不同的视图,, G1 h5 Y( ]' U+ J9 P, j

    . |/ \2 }8 x( i+ i使用同一个request:0 q' x3 v! `' c' U. b
    7 r* w; ?, i* v; U- Y
    2 ]: k' J; t, q" W; t

    ) G. U# a9 _% ~  ?什么是Model 2结构,以及结构中各部分的功能& K* U: a4 |$ b( G0 d4 g1 h
    jsp+model+servlet
    % H+ s& x( h# n/ a! J& A
    ! H1 L5 U' W% k8 S' LModel 2架构使用MVC模式,JSP页面充当视图,Servlet充当控制器$ c8 I7 P& R! t7 H6 Y/ |, ^/ I
    # U0 g* m  f( E, m; K) x) Q6 o- q
    Servlet控制器:8 C5 h* _( b# q; x8 W# N' ^
    0 N( \* K0 J+ g; {
    验证HTML form数据' h! Z( P/ t  A, |# k% l

    * X3 O2 T+ ]4 t& p调用模型中的业务服务3 l. V2 z. G2 ~! B

    ; X% d. o3 z! b% ~" B$ l存储请求(或会话)范围内的域对象
    " p# w) q# J4 E% {4 l
    ' N2 S8 Y3 I% l, G- d0 @# c选择下一个用户的视图
    2 e1 q; k# p; C  q3 U( P, o' H3 W) S6 i, n2 @; i& [
    JSP页面视图:/ G# Q( z# D! m2 y& t% L+ Y! _

    ) k/ z( \, P1 W! L' k使用用户界面(在HTML中)# V! A' v% ?: i& w2 g8 y( r& o* `
    4 u4 c5 R8 Z4 ~
            访问域对象
    0 v- z5 {& |! L* G9 ~2 _9 K5 X  F
    ' a+ q# v- Z8 S- n# @* j

    / y3 O. I8 }! K; V6 Q. C如何获得分发器?分发器的功能?/ j+ A3 a" ^& L; c+ j* n/ G7 m% K
    上下文对象中的分发器:
    ) x. ~+ S& V3 A# A9 d) T% u( \) ?  B5 u: L2 h  U( B, g% l
    ServletContext context = this.getServletContext();/ z; n: i# @* |: c3 E( i
    8 Q. K5 a$ _, A$ j: a) Y
    RequestDispatcher servlet = context.getNamedDispatcher(“MyServlet”);5 Y/ _# x( ^. E4 Q7 K9 W9 ], ?

    # h9 s' O, v8 H4 q. ~+ Wservlet.forward(request, response);
    ! M0 j5 n* o/ I# X" Z4 J$ G6 H8 C4 o7 h' a# R
    请求对象中的分发器:0 n* n2 l8 s7 i+ G/ x; R
    / R6 l- f7 }8 D+ b; s
    RequestDispatcher view = request.getRequestDispatcher(“tools/nails.jsp”);3 ~$ _$ X! M3 V6 U; D3 a+ ^
      k  m8 A# B. D# C9 v4 E0 O
    view.forward(request, response);
    * y8 j8 Z6 v8 A$ z  D4 R: `
    6 g. Q' L5 ^9 ~2 c8 z4 {  f可以将请求转发到另一个jsp页面,并保持请求的传递性
    . i; E8 w# g, ]8 O
    5 p2 B/ ]/ I4 O! R: W8 s/ V: L9 B
    1 x  z% ~( w7 |! \+ e
    0 G; L  Y3 j( U5 o/ i' S. |Jsp中页面跳转的两种方式?
    : I  t" r7 x; w+ D使用分发器跳转页面; R$ }' B  \4 q: j5 T1 a
    RequestDispatcher dispatcher = request.getRequestDispatcher(“url”);
    % y" z0 Q) S- U) g# k0 I4 n" w+ j2 O% J
    % |' _4 I! H- c: R/ T9 k2 _4 Vdispatcher.forword(request);+ A7 R' U; V% ~9 y9 ?- w  G, o% z% R

    1 p; j+ d9 ?% e9 y    特点:保持请求的传递(上一次请求中的数据,在下一个请求中仍然可以得到);1 c- p' c( G9 E& n$ `
    9 U- j/ a6 T) c' R/ c% b
            转发的页面只能是同一个Web应用程序的其他Web组件4 [2 }+ Z* A6 ~) Z$ v, Y$ {, ]

    3 n  U! u9 ~& Z7 A使用重定向跳转页面, U' i5 }' L$ G3 t7 I0 s" g
    response.sendRedirect(“url”);' a2 J; p; Q. H, V4 M
    0 E8 @/ q! |. h! p, J" B
        特点:产生全新的请求,(上一次请求中的数据,在下一个请求中不能得到);; B* M6 A) v# b5 ?4 K" `

      ^& C$ A7 d9 Q5 F/ M        重新定向的页面可以是任意的URL
    ) N, b! y! o) e' I. U
      R9 k. w5 `! Q+ [8 l : G3 u. d% e! Z0 j: y
    4 P+ X* e& @3 W8 Z1 Z6 S
    描述Jsp中引入另外页面的两种方法,并比较两种方法的特点?3 I/ L- S# t; n
    <%@ include file=””%> 在编译期间把另一个页面完全嵌入这个页面,可以说是一个页面
    ; M" \0 g2 R* }( ]: u, X/ c" [( L+ O7 t$ i: k1 H" e* q
    在这里可以共享变量
    3 A) K; d; U' O
    1 n3 K  O( f5 Z, w! N) s: P% w; w<jsp:include page=””> 动态的再运行期间把另一个页面加入这个页面,可以说是两个
    / ]# s) a* {& n$ T( g
    0 w0 c; G8 h$ k5 V" U1 }页面,不可以共享变量
    ! Q: E4 j7 B! I5 H! I" q# ~* S' R: A) I1 p- V5 R2 q
    ) o! ~& B2 e- ]: a/ [; i% {) p. q
      k/ r  i+ D' W2 e! Y6 e$ ]6 v
    什么是自定义标记/ \8 F' D  }0 J1 Z" J: A" F
    自定义标记库是一个Web组件,
    ) W0 t/ f9 {' N
    . F" K/ H) t# z/ N包括:3 ]! ^' m4 y4 n2 `7 c6 V
      h$ a  I  k3 ?9 F2 ~( S
    一个标记库描述符文件(*.tld): F1 X0 t8 j+ q
    8 n; T9 F3 K1 H
    所有相关的标记处理器类(*.jar)
    ' e; ?8 A/ F1 L( a% e9 a5 W
    7 q, a$ B+ M) t% \! I; ~ / G% B5 w  Q0 k
    " Y# ~* `0 v# o/ Z2 @' F5 h+ V0 [
    描述使用自定义标记的步骤,以及每步详细的工作
    9 o' _" c3 l- l使用自定义标记前,要拿到.tld和.jar两类文件. `( {; E$ X& n# i6 J
    ( I  i) j  {5 o( k* s5 w% F& Q* S
    把.jar文件放到WEB-INF的lib里面。& C; T+ d9 i: b
    把.tld文件放到WEB-INF根目录下。/ Q) A( H9 L. n
    在web.xml中配置。
    2 u. u5 |0 R# A) K0 M<taglib>
    # M, e$ B" [, v* k/ i6 r0 V3 e
    $ |8 \( C& D. \( Y: a<taglib-uri>http://java.sun.com/jsp/jstl/core</taglib-uri>- ?% X6 J' U/ ]! q# _
    " Q2 B( ~. l+ y
         <taglib-location>/WEB-INF/c.tld</taglib-location>2 ^8 f" |, t  a  }; n, I% s

    ( g5 Y$ S% n& c) [4 o9 J1 ~# k3 ~+ \</taglib>. L& d, ]% C; y% X- e9 \7 X
    ( T, Z' h. v- _: C$ V
    在页面中引用。
    : c8 @- G" A' Q<%@ taglib uri=“http://java.sun.com/jsp/jstl/core” prefix=“s”%>% }0 {8 c) y4 U5 H+ l: Z6 V$ D$ P) K& C* J
    1 @" l: C# W: M9 e
    uri必须与web.xml中的uri对应" B) c! _3 g0 y7 Z( `
    : n6 `. s0 \3 {0 N* [
    prefix是前缀,用来区分是哪一个taglib
    + c1 K5 c* [& V6 e$ a" Y& N: ?
    ( O$ C" Q4 E  A1 ~) ^0 X使用标记
    % E- [6 L+ T* v/ h  `9 y格式:<prefix:tag名称 属性>
    8 F. I0 K. c# q, M- L# k
    % M- \+ B/ e$ \) o" ^% i<s:forEach >
    回复

    使用道具 举报

    admin    

    1244

    主题

    544

    听众

    1万

    金钱

    管理员

  • TA的每日心情

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

    [LV.5]常住居民I

    管理员

    14#
    发表于 2014-12-03 12:45:59 |只看该作者
    在tomcat下配置数据源+ u% y% K$ d3 B, ^6 m) F* @
    1、服务器与数据库的连接* a6 t- u: G& k( T
    " d+ ]1 Z' J6 `- p( K
    配置server.xml文件
    0 @' a1 k6 K7 N1 T7 B" k: G8 Q# V* Q" Y
    1.oracle/ t6 S  z1 P- B% h! b
    1 s2 E3 b4 p6 W$ f2 @
    <Resource name=”jdbc/company” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”
    / M! D. ~' C' l2 C% v' N9 `! d' \
    ' l2 L! |9 W0 Z* m" M4 v$ z4 ^) g                        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”0 p2 X( _' z% V: N/ m

    2 v. G5 e. i, h- m: x$ burl=”jdbcracle:thin127.0.0.1:1521rcl”/ J! w! O' V6 v; w" P

    . {5 [6 o  C+ j* \. Y5 wdriverClassName=”oracle.jdbc.driver.OracleDriver”
    % O3 x4 @( S3 h4 J6 c+ I, {, ?1 B& [) u  Z$ q% G
    username=”aa”: @6 K; B7 ?/ o0 H7 R& F. k
    : o+ J" i; R: j% V4 P5 k
    password=”aa”7 L/ I5 S8 I  r7 u
    5 H1 C4 k# U' h6 x
    maxActive=”50″
    $ [0 `0 I9 S, Y/ g2 e& w8 a
    & C$ ^. _  a; q& _* c) zmaxIdle=”10″5 ~# t$ H  m1 I+ _, L& O4 A- C

    . D" r3 E, q0 h1 a1 CmaxWait=”-1″
    , k' b. g# L% {* H
    ' l8 }$ a) ^. F9 b! I/>$ D- Z6 Y4 i" R1 ~$ t
    $ d3 n9 m, @: X; p# _
    2.sqlserver
    ! m" {5 V* f5 i7 h- T
    , Q+ z0 L$ N  |) R; B5 {! y" T* [<Resource name=”jdbc/webpage” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”# Y7 b# u) \: {# ~" l) C

    ! I* E& r. U2 c( J" J0 y        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”
    # E; j/ I# E( X& F# x1 I- i
    ) g. Z) z1 i9 k1 }* Iurl=”jdbc:jtds:sqlserver://localhost:1433;SelectMethod=cursor;7 E: ?2 h/ @  @" V( Y, A8 D* C2 G
      v- I  e; g' r
    DatabaseName=webpagetest”4 |% n; E  ^* A6 P0 \' T3 _8 S

    " P; E( R  Q  V( t% Y4 T, _driverClassName=”net.sourceforge.jtds.jdbc.Driver”& D7 G& s9 Y, Y7 z1 k. m

    . a. t8 F+ h9 Y- a/ ~% i: d, P( ^username=”aa”9 v$ \) ^+ k6 U" z( ~

    2 N7 V  W1 X- z  ^1 npassword=”aa”
    5 Q$ x$ |5 W# o
    , D. P* U; o; |maxActive=”50″7 M! k# w+ t8 X9 N7 i4 F

    8 c+ f+ B( u; LmaxIdle=”10″) p; w  T6 O4 c8 m
    * X: [* {7 x. O. o0 f9 Z
    maxWait=”-1″
    0 `! x: \2 z; X3 z1 A* h. N; @* Y4 X+ f
    5 r# M, L3 A) E* e# Z/>' J# n( Q8 \6 ^/ Z6 W- _* S9 U

    3 ~5 w1 q' y# u6 n$ k- B% V$ X2、配置自己的web应用的xml文件
    * K" N' S% m6 z  V8 v
    & y# B; z* g1 t6 x# ^6 S% ~: j. E% ` ( t3 Y! b% ^, o

    - q4 x8 `3 I1 y: J: x<Context path=”/eb03web” docBase=”F:/workweb/eb03web”4 |7 z! E; X' Z  n9 }+ F
    ' `$ j& M3 i4 M1 g
    privileged=”true” antiResourceLocking=”false” antiJARLocking=”false”>- C7 ]1 u* |( p1 ~) z

    1 J& H" ~+ i) T$ u<ResourceLink global=”jdbc/company” name=”jdbc/company” type=”javax.sql.DataSource”/>
    . q) u4 ^" [% Z6 B# K" ]
    " u, }$ s& J8 [% \</Context>
    & E6 Y! |  V3 }& n' Y
    & z2 ]) F) U8 ~+ y; @ ; R  u) ~/ L' e8 @( o/ J

    ) ^% h; N+ T- f3、配置web.xml文件
    / z' d0 U6 ?" |* O( S9 S$ d- L+ [! _# D, j2 L4 e: P, y1 }9 W
    与服务器建立连接, o3 W: q7 a7 ?

    9 w$ a8 B- t  ]5 N- z0 |$ a<resource-ref>6 k3 G6 [8 Z8 i
    8 r3 c& k, c7 |) o5 ?9 C4 h
    <res-ref-name>jdbc/company</res-ref-name>
    ! z7 T6 C) C6 e8 N; o* Q( @# r: k& A8 W' q% S
    <res-type>javax.sql.DataSource</res-type>/ f3 e8 A8 A+ c! x# ^: y- s3 @
    - P* x5 e' G: G  j! P7 ]/ M: j
    <res-auth>Container</res-auth>7 F. G9 t, N5 C1 S
    9 T7 c' M) v  n
    </resource-ref>3 x4 T* Q  _$ T+ W8 Z
    " c6 T9 I. s4 y2 N. ]* [
    4、在应用程序中不直接与数据库连接,通过DataSource连接池建立连接4 d% @  T+ L2 m! u7 P1 X

    5 C1 h! ~4 B0 p" M- }: }//1.在程序单独用时设置系统的属性,在tomcat下可以不用配置,* F. A/ R0 f: G3 k
    & _$ \' r" g4 U" n! k7 Y
    System.setProperty(Context.PROVIDER_URL,””);' h& {$ i/ z, h* u0 D+ p6 Z

    ; V! v; H, Z' i" l. |* bSystem.setProperty(Context.INITIAL_CONTEXT_FACTORY,””);' V/ P) G$ c3 v, B. U% Z/ E( v

    , I2 ~0 M9 V1 L2 y//2.创建一个上下文对象# {/ G6 X* P' R
    9 A6 x3 j( _0 T6 i2 G
    InitialContext context = new InitialContext();1 w$ j5 s! b  u3 O- N$ Z
    / {. H& N8 A# U5 C
    //3.通过上下文对象在连接池中查找DataSource6 W. Y6 {) F, T* d. q

    " c9 T! |% R0 w0 p1 c0 x$ [DataSource ds = (DataSource)context.lookUp(“java:comp/env/jdbc/company”);3 K( m1 D$ M* z+ h8 R1 H& b

    2 m0 z9 A( k9 ^# I, x7 h//4.通过数据源建立连接) i9 h% Z* m% i( ^

    # c. F6 `1 S- B: _" ^1 O) uds.getConnection();
    回复

    使用道具 举报

    admin    

    1244

    主题

    544

    听众

    1万

    金钱

    管理员

  • TA的每日心情

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

    [LV.5]常住居民I

    管理员

    15#
    发表于 2014-12-03 12:46:30 |只看该作者
    ORM对象关系型数据库映射% k. q0 i6 U! `* {6 z
    (Object Relation Mapping)( B9 h' v# H$ A* S6 ^- G( Y: H

    ' T- b8 E6 m8 S% a一、映射的特点
    " E" P$ b! x& Y* j# W
    1 t" [1 V2 {/ g0 B1.一个对象可以对应多个表" R9 F. v9 T5 ~! j+ a

    & `$ M. X* W: Y/ z& {2.一个表可以对应多个对象( B/ }0 X6 |% a( M4 }" g6 _

    5 Q( V$ _- v- K3.对象和表的关系不用完全对应
    ! Q. J! X; y2 I( W( H- H' E0 S1 O: W
    4.对象的属性的名称和表字段的名称可以不同. ?2 N2 S7 y6 T, s" |

    ; F) X, {/ D! v) q5 c$ r5.类型可以不同,但数据类型之间可以转换
    - D8 P3 v, k0 L, g5 e& Q7 A" W- u+ r# p  z0 q
    6.对象中必须有主键,数据库的表对主键无所谓, Z( @/ [, }. m8 I" U& q
    % [/ [9 W/ @4 m: T
    7.数据库中有主外键关系时,对象中可以有,也可以没有
    ( S* D' K  O+ s, ~8 B
    7 G9 m9 @) t0 g% g8 Y* o9 Q
    2 C! r8 {; p7 o; M: h5 F6 c
    / S1 i2 z! _9 E$ ~$ t二 、有一个映射的描述文件————>xml# F2 Z& }; c" J% P

    5 t5 A% D3 _- r7 }: Q  ]三 、怎样实现描述文件————>一段程序
    ( z) R0 O' t6 u# s# |, }9 q$ B, k
    对象 映射(mapping) 数据库
    & e+ [5 a# |+ _* M* q. j; Z6 J4 Z6 ~' ^1 @
    user
    8 U0 @" ^6 c$ K3 U" o1 J: s2 p! ~
    4 \+ P( b: U- Z$ c2 M1 jid=11
    $ c6 D& L5 t( M' Y% l) N( X5 j$ I  B- X" y; g
    name=”张三”———— > (1) —————> tbl_user(id,name,age,tel,address)
    ( X3 L! z5 u& J+ J* t2 {3 ~5 S5 o$ s" X7 c
    age=25 <————(2) <————
    : W9 a) J: h. q8 F1 ^( M
    8 g4 x4 r8 }$ ~+ `$ e. Y % I& o& o/ M3 Y' Q- j2 W
    * b8 n1 B" u4 t/ \( Y3 y% d; F
    (1)从对象映射到数据库
    + q6 Q, D7 x# N
    ; O5 z% @* Z3 i. C5 }1.JDBC1 z# J$ _) c  S/ A, v" A

    : e, Q, m' E- f6 l' I4 H6 a2.根据描述文件来动态拼接sql5 O3 @; m; g/ D$ d0 T3 y+ L& k
    # U& n/ J( N$ q5 H
    3.执行,添加到数据库中
    1 Z1 Q, ?; a" y4 x3 K  ?8 [: M9 f& Q( T% _" R: z* @# p$ y7 ]
    * A$ J& G  }. w* I! l
    2 f; a$ F6 h$ q' p( Q
    (2)从数据库中映射到对象+ Q- U( ]% T$ q$ V+ K# p

    1 U+ f) d& ]- L1 L3 Q, t1.JDBC" s( f3 F1 Q2 X

    ) {& N; k) `% g2.拼接查询sql$ \& F* [2 P- Z( ]* {/ {
      D2 H* M3 I8 r
    3.ResultSet3 N0 N  U/ h' f7 D: {
    4 ~- l) g( ?: c) i( D* N5 \( ~
    4.Model 4 Q; g0 i& F3 {
    # n; H( X! N. T% \2 O

    ! X/ m7 B1 W+ A
    3 V% K( h' u+ t6 S& v* Bhibernate, \5 F6 a$ ~* f* [
    开发流程:" v1 m' t8 l% q  I) ]. T( f

    ! Z  q, u6 _4 {8 T: @5 s: |是什么?
    - H8 }0 y& \+ z' m- Hhibernate是一种基于orm 的轻量级的框架: D2 A. p- a% d9 w3 R
    # P" o2 d! C  A1 S9 {2 }6 D7 ]

    # K; D% e7 f0 c& j! s7 K6 N" r4 _) i7 w$ n5 a7 g6 y  M- M
    有什么?; q/ [# L6 Z7 }, U
    1. session 保持连接状态(依赖事务和连接池)0 Q# I4 p4 @* R7 X
    9 F$ b+ s# z0 x. T! U
    2. Transaction事务
    / Y( l4 s( D5 n4 i; O+ s7 Z& G! |  A: c( i( Z* j7 L( z
    3.
    8 `$ A0 ^  Z6 ^Connection Provider 连接池* j9 N. V( _" [6 J7 ]- D
    - ^# Q1 C- Y" a7 e4 S; r& D

    / d6 W+ A. h/ @# T- X% i" Z" L
    ) a+ I- R, J2 O! @$ h能干什么?
    - R+ s  @& k6 j6 i0 v  X1.orm
    & `. k' H, K+ |: w* s) q8 {1 w( L" {' U* n
    2.提供操作数据库的接口,简化数据持久化的编程任务
    9 M, a$ p3 j) W
    ' T- D$ ]: {: m  K; N
    ; Y7 r2 I* v; ?  H1 X# [# I9 U, L
    怎么做?2 \6 W) u* _1 ]$ P1 J& F
    1.搭建hibernate的运行环境,将hibernate的包和hibernate所需要的包拷贝到lib 文件夹下
    ' _2 ]# N5 Y8 o9 ~
    ( }0 b$ J' j+ d7 w' k2 K2.O(vo)
    / e* J) S: u; V! f! E: A9 K" w  B( ]5 h; B, @4 i! @& I" q: g
    3.R (关系型数据库中的表)5 N- `1 P2 b. U; D+ \/ j0 u6 R: S
    / U) }: E; S. o6 D
    4.配置文件0 z; t- _0 T, a) r( H$ k
    ( k- @" h- E7 b9 H- s: ?, `' u
    4.1 cfg.xml 放在classes根目录下,默认名字为hibernate.cfg.xml
    $ _' d- t; \* ~7 V4 B7 A7 W
    ' }; F% Z4 y) o- R7 v! [) La.与数据库的连接/ y+ G/ r. k* [8 `0 \

    6 x% u0 {! q8 x9 R( \9 Rb.可选配置5 @; T. I- C1 @. M5 e+ k

    # j! b1 q, J" o, hc.映射资源的注册
    6 v# P) c1 ?% M4 @, `/ R& O3 \
    $ j+ H% r& ~9 b5 p6 j4.2 hbm.xml文件 名字与类名相同 并且与类放在一起
    8 J1 s7 B2 w/ J9 H; a/ X4 _- W/ \
    a. 对象与数据库表之间的映射
    : \6 B9 v& X$ P5 t. a% {. s' Z, g, Z+ e/ x
    b. 对象的属性与数据库表的字段之间的映射
    6 }$ R3 a, Y- h; c! L$ `/ G9 ^# h9 d  B  \% j
    c.组件之间的映射' d. J7 E4 n" a9 Y' o) A5 Y

    + e! C$ g; ~; Q( y! {d.对象与对象之间的关系映射
    5 N2 e" b% S4 L* a4 z( r6 [: m* |0 }+ y; t; ^
    5、客户端
    " }- ^( |9 _2 r7 {0 f0 r# a2 o2 E" G; q
    1.得到SessionFactory8 M  a: y5 [5 x+ a+ u4 o0 [& V

    1 f, V# @# Z/ g" {' r. G2.通过SessionFactory 工厂来创建Session实例1 u% N1 b% v! S/ k! n: _' T# ~7 G2 T

    * l# z  S2 g% P) ?, O8 ?) s2 y  F9 W8 K; W3.打开事务7 J4 k& D8 w- \. }
    * j6 ]- I: W: G; M
    4.操作数据库; v  c  L( \1 {& W* }

    $ q& G$ |" i0 v) e+ K$ D5.事务提交. s8 g/ S- T, u. N; m0 n" G
    * T- l* n* \! e6 D$ Y& K9 u
    6.关闭连接8 a# e* G0 z3 z  t
    ' K+ x- j" }' |- ]1 Z% B
    运行流程:
      J2 Z) e1 P- _  ~/ `
    2 }" [8 |- a+ R0 F5 p整体流程
    # g0 `5 r9 j& S& Y6 ~: t1.通过configuration来读cfg.xml文件
    0 x# h" }5 n* h7 q  [3 F$ o% y0 K* Q) z/ h
    2.得到SessionFactory 工厂(根据数据库的连接来创建sessionfactory)
    : B5 k& y3 T" E( s+ N  C
    4 s* {6 ?8 v2 j0 d. s3.通过SessionFactory 工厂来创建Session实例
    5 Y; v# L; G0 [2 U: g' Q+ w
    3 ^- U6 }7 z+ f' e# [4.打开事务
    & e' X. w9 ?# G+ q& l4 {  k) h( L) D# b2 M  `+ W* E# l
    5.通过session的api操作数据库
    ! k4 d* z/ h+ o. c) n( v! Z) K% @* x( l- j/ D& I
    6.事务提交
    * y4 I. G3 O; ]! S7 H8 v5 q  T# l5 h- I' s' W7 o; I
    7.关闭连接2 Z( u3 j0 X; x+ S4 A! v* X8 f
    ' r0 V. O4 ?- f, A
    ( |' W/ K: H( `2 J4 M
    $ w  o/ z: ?. {5 O9 C
    save
    : Q/ s1 H% c7 I1.to—>po
    3 _$ e) q: `5 y2 P: R6 Y) K
    6 ~8 N. l8 ?# P* V" L) l; [* {2.根据model和cfg.xml中映射文件的注册来找到hbm.xml文件" I6 I  V9 d, `0 {/ v

    " R/ x  Y) G. u3.根据hbm.xml文件和model来动态的拼sql) |: ^* y6 A) T9 _! M1 F/ ~+ m

    9 }+ @: y: c6 C4.客户端提交或者刷新内存) }# D/ u/ R% y* @$ F

    ! p  Q5 d1 q- L: l( G5.执行sql,值放到数据库
    - [9 h/ N1 P  V" d& Q* j5 I- A+ H7 ]( S# m9 d( @1 ?: E2 y
    - R0 w( Z3 p5 R$ P  j2 h
    9 _# f1 u5 N, J& ?; P; o" h% E
    update、delete6 v; C( c  d5 [; E
    1.根据model 的id在内存hibernate的缓存中查找该对象
    # i6 E$ E: E. L% q: q
    ; l: b3 A  c& b0 Z- p4 c# U% B& ~如果内存中没有就到数据库中查找来保证对象的存在
    9 W1 K9 `  z/ ~$ q) q& R- F) m$ \' t; d
    2.根据model和cfg.xml文件中映射文件的注册来找到hbm.xml文件4 M6 D) X% f, g4 z
    $ Z( ~; l6 ?8 c+ |5 N) S
    3.根据model和hbm.xml 文件来动态拼sql  P& c3 A/ [" |7 ]3 t# ?) J# T( D
    $ o9 O& h) u7 b# W% a
    4.客户端提交或者刷新内存# I8 f7 y( @8 a7 [0 P
    : [! I' \5 a9 ]; N! l2 X% z# `& F5 N
    5.执行sql% {+ `! H3 ~3 O7 `& g

    : b! h* I+ m4 l8 q- K
    0 a$ F7 k) N- j
    : d! ^  j3 o9 t( H4 d2 v6 g. EQuery- S0 p* j) F- `# l9 c
    load* I4 R$ z1 z6 b" A* a

    & m+ x3 [3 k+ Q  W3 \; y6 i- }1.根据model的类型来找到hbm.xml文件1 f( B9 e: O% q) @" `
    ( [( }* R6 H% ^
    2.判断id对应的对象在缓存中是否存在,如果存在,就直接使用,如果不存在就进行下一步。
    * F  A" e5 t) S- J6 N" Y0 _( Z. k( O, P; m
    3.用id做为查询条件来动态拼sql" Q0 b. }: w( s6 W  O
    ; a# M1 W' L  s2 O/ q+ U/ V/ R  a
    4.执行sql 查询(先在内存中查找,如果没有找到(会抛出例外),就去数据库中查找); I) N7 ], E' ]- [* O$ v1 m7 X

    % _( l9 Y; k0 U* d/ E- F5.返回一个model类型的对象& W9 _5 y* y6 l) e5 O
    * j. x2 k: b2 `+ G* F
    get
    $ ~  ]' E8 q5 M' C4 X/ h& v) b2 Y- F. ]+ p' Z6 z; t6 O+ `
        1.根据model的类型来找到hbm.xml文件
    - H4 U/ F: A& p
    / B: g' l  v, T) ^. Q$ F2 Q+ q. `$ ?2.用id做为查询条件来动态拼sql4 f: B0 B' b! m9 }2 J
    " x$ X# T' k& P3 Z+ R8 h- T% _. z
    3.执行sql 直接在数据库中查找,如果没有查到就会返回null
    # q: S& Q6 z9 h, t3 J) H
    & H6 Y2 C/ c! P8 I. xquery1 Y9 T) ^! ~, k1 T+ {& w

    $ f$ K. X9 c9 t1 M1.分析hql语句,得到model的类型& }% `$ T. I* F  n
    0 _( u% l3 L) z, H
    2.根据moedel和cfg.xml文件中映射文件的注册找到hbm.xml文件
      |6 d5 d/ Y, G1 s" N9 l- a3 w1 U9 ?3 d" n5 s; a/ E% j. R7 X
    3.根据model和hbm.xml文件来动态拼sql
    ; i2 z8 e8 m9 m% o  b5 m9 b6 i. W& g0 N5 N* i, _% r/ }# }" B
    4.执行sql查询数据库9 ?- r" V9 A- h1 W
    ! X# N/ U, p# j0 [! _2 L
    5.返回一个resultset9 N7 e% o0 ^2 q, w! W

    7 Y8 u! ~) O, A* C- @' J8 K& r6.循环resultset的值,放到model中在放到集合(List)中
    # v) M1 ]8 \! d+ X) d6 d3 k0 h4 j! D+ [" Q0 w

    % a  p& q! E; s: T; o
    ) A" ]; C+ o9 K/ x. `谈谈hibernate缓存机制
    7 U1 c- B8 |0 P* f6 r' p+ Z' r* b0 f7 m
    缓存其实很直观的理解为放到内存或者硬盘上的一块区域,缓存就是一个缓冲的作用,有很多时候,我们的数据需要经常访问,如果放到数据库中,不是不可,只是效率上低,如果有了中间产物来代替数据库,就省很多事情了。打个比方,去买酱油,不一定一定要去酱油的生产工厂去买。代码中需要数据的时候,可以先到缓存中查找,如果存在,就直接拿数据,不存在就去数据库中取,也省了很多事。5 r4 N" P" k# }

    3 D# u8 z' b; a) j$ ~
    7 _( a- N! C2 P1 X
    / n3 [! B! @* x4 r. j4 Zhibernate使用的是二级缓存,有两个级别,分别是Session,SessionFactroy级别,一级缓存是Session级别的缓存,Hiberante来管理的,这个我们一般不用管,二级缓存是SessionFactory级别的,可以进行配置和更改,加载卸载,就是我们平时用的hibernate配置文件中的配置SessionFactory的属性。
    ' Q+ y: T# I3 L1 M
    ( d9 Q* v9 P" P7 v6 H6 U0 L& ], ]2 Z7 C
    9 i& U8 F, U" c
    + r" Q; g( T3 |/ Y: \对一级缓存中的session事务进行数据的预存取,数据在各个session的上下文中存在(单例),当session关闭时,就是session.close( ),整个所有session范围内的数据全部清空;二级缓存默认的情况下是不开启的,如果开启,数据库汇总的所有数据都先copy到二级缓存中,这里要注意的是,一级缓存是每个线程下创建的session缓存区域,可以是多个,二级缓存只有一个区域 ,画个图比较容易理解。* h# h% }3 Q# ~+ F7 \5 x* l
    2 `, E# x( ~( S! ]) P
    7 k5 m+ A' T$ r6 P- |. p5 F  B: f
    " ~2 v+ l# D, r& K
    | 一级session缓存| | 一级session缓存| |一级session缓存| |一级session缓存|6 d/ ]9 z6 s/ K, u5 X/ @
    ; S( V0 }' W! j% g8 @$ R; t3 C* u9 c
    | | | |1 D! l7 \( T, }9 ?, J
    4 V; _; Y: @% {: n
    | | | |
    . v; j/ z. K! y$ {) l2 C( C/ Z7 M/ l, P( Z
    —————————————————————————————————0 F. D; M9 I" i3 M- {5 j
    9 s  u! n+ |' ~; l; u
    sessionFactroy级别的二级缓存$ W; A; f4 M- C! t- `) v
    2 V. s3 d4 u- a+ }* U2 ]
    ——————————————————————————————————————-
    1 U* r9 p* m: ]6 [) M, s% [! A3 R% q( W4 j6 \7 b0 r8 T
    |
    3 M6 f4 O/ ?. H+ o8 G: [+ `( Q* E( N& V- d# l
    |/ u' `2 Z8 j4 N$ P5 I' F( X

    * J, w, F0 j5 q8 A|
    4 b7 x5 L  N. {; q1 e0 k
    3 N9 G2 z$ O2 t; S" h9 P" u$ W——————————————————————————————————————  p  a& f, w; l  [

    : ^5 V: x+ j, u. A: q, J" V7 G+ nDB+ L" R- F! ~5 k$ ?: I

    & U, i! a" R" Q7 W: ^3 f—————————————————————————————————————–
    % f) S/ u. x4 y1 r
    8 K: {2 }/ }& ?6 t1 ]
    回复

    使用道具 举报

    admin    

    1244

    主题

    544

    听众

    1万

    金钱

    管理员

  • TA的每日心情

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

    [LV.5]常住居民I

    管理员

    16#
    发表于 2014-12-03 12:48:12 |只看该作者
    Spring
    ) `" K6 e0 C6 C7 ?( _& |
    • 是什么?
      2 J. _# @3 X4 V

      ; o% l! Y9 Q7 a0 E' v/ k! V

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

    5 C- |+ ]) d' v* Z
    • 有什么?# r- Y$ L  Q8 k% G

      * \  W' E' }6 I9 D  Z4 @+ c

    ( @- O* ?( K; p, k) d9 G* W

    每个包的功能:

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

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

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

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

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

    AOP :面向切面编成

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


    8 \8 S6 c/ }8 P3 |" p* C' z
    • 能干什么?
      ! J. n  }$ x& O+ H
      * n- }  r/ D+ |0 e

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


    + k2 U) p6 V- @& u0 i
    • 怎么用?
      5 g5 T% m" y3 H* _" G2 G8 }& d
      # U; |) w  z' X; I. a
      • 搭建web工程,引入spring的jar包! o  X, e% V+ x
      • 在web.xml中添加如下配置6 E7 q4 Y( s) }# x8 \
        ( I0 P; B# a. \! ~; ~5 F, c) Q
      . P  K' N+ g+ {8 B7 s
      ' w6 l8 B. g# ]

                contextConfigLocation7 D2 U; ^/ `/ C

                classpath*:applicationContext*.xml
      C  b  M) E: B5 o: k( ?) i/ M

        8 K+ {* v& ~+ i  v) X

            
    2 m: r$ k$ m* t3 q; t3 C% X, ~# Y

                struts2
    5 N1 W+ Q0 i" v, k, Q) u! F" L( {

                
    8 U( N9 e+ n4 i+ _- B* m9 l

                    org.apache.struts2.dispatcher.FilterDispatcher
      u1 o6 {9 ^% [1 i

                ) R3 i* P: \# G! Y2 t9 x

            
    7 _7 V0 M. q: s3 C, t3 j

            9 B0 t* g- y( U8 O5 I( z% \6 P7 {9 Y

                struts2; J7 k9 [" b4 g! H  ~7 [

                /*
    ) w/ P; T5 t, V& `' J+ y

    ) i: c' e; p, K: h

    $ \& G# P2 _8 v

                ; I- e) q0 x: e

                    org.springframework.web.context.ContextLoaderListener% N( u$ k0 L; e. `% E  e/ r

                
    ; l; ~6 Y6 t: o) }

            

    • 部署
      8 l2 V4 h. Z" L/ ~

      + r9 p1 b6 i" x3 P- M8 _7 ?
    ) ~9 Y+ B+ Z, X4 B" d: d

    " ]9 ~9 v* W- o$ D" @2 `( ], r2 A  f
    " l. L1 ]+ K6 F' ?
    • 容器和bean
      0 v' X3 k3 X. c* T  V

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

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

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

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

    # u2 Z! M5 E6 h4 L3 }1 U
    • IOC控制反转
      # U# q2 a& B! d' W
      % s: f$ f; V; y0 c; l

      * P9 A" ]1 G# w  V. d& p " |6 Z/ U- p0 O: h( I
      从前的应用程序想要得到A的实例他会直接主动的去拿,当用了sping后,应用程序由主动的去取变成被动的等待,由spring来控制应用程序所需要的对象

      5 W/ j7 ^1 d% F* @0 H
      • IOC的优点8 }: u6 l8 f+ v2 ~" s
      1.可以通过IOC来获得实例
      2.可以通过DI来获取注入的资源
      • 配置IOC的原则/ x  [  N& d, B) `7 a: v7 M
        • 一定是可变的资源才采用依赖注入
        • 一定是层间的接口或者是模块之间的相互调用才采用依赖注入' Q# s7 p* t2 C/ }% K( o
    . _! a: Q9 q. ^* n; R
    • DI依赖注入
      - o- S) K4 x9 z. C0 f& D  P* H

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

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

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

    例如:

    在配置文件中


    * x. s, Q  J5 l* x- L" ]( u7 w% |1 \/ k8 [7 e

    ! \* x  m( @/ y; j$ {, k

    在应用程序中

    Public DBDAO dao ;

    Public void setDao(DBDAO dao){

    This.dao = dao;

    }

    3.构造器注入

    - N, ~# z- l) j$ R

    4.ref 表示参照其它的bean

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

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

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

    6.lookup注入

    7.singleton

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

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

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

    8.DI的优点:

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

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


    ( ]$ s4 r4 D6 n. M
    • Aop面向切面编程
      . O0 l6 B7 U  G3 A# c! t+ ~

      8 K3 w3 w7 ]6 q

    1.AOP面向切面编程 一些较好的模式或者是示例—-范式
    ' s, j0 l! ]1 \( ~" e1 G& p

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

    2.AOP的思想: 主动—->被动(追加功能), ?' f% S, ?3 F$ y$ H

    3.AOP 的概念9 W; g2 `# ]2 {6 e5 P7 _

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

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

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

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

    5.引入 :扩展的功能

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

    7.aop代理 :实现机制

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

    4.AOP的事件机制
    + q' Z/ v: C1 Q9 j

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

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

    3.找到切入点

    4.确定连接点

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

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


    0 w: M1 p) U, f$ F. E, P
    , ]8 y7 }+ @! H8 c- v
    9 Q- I( R/ n9 ^+ T; J* M  V, x$ E" V' L" F% |9 e" Z% d8 A0 W: I

    1 q9 o$ E1 O3 l; J5 m2 ~4 F$ W/ b1 Y
    + |( G. t1 L9 j3 p. D( p1 d9 k) `  Y; @6 Y" ~: k( Z

    5. AspectJ
    * D- K" `' W) s0 \

    5.1.在xml中配置比较烦琐0 K& q4 [# ~6 @0 l  n

    所有的入口必须从一个代理(ProxyFactoryBean)开始
    ( f* b; I' I0 l) ^

    1 L( F3 E  V9 E* F! b: Z" C  b$ i7 R
    9 m+ j- I6 b. d& k2 D

             ' ]& s1 U* r: d; W
    8 Y: k; K. l3 R! D

    : j4 j, x3 {7 w$ f9 z: t& w         
    8 U% k) b: v8 X2 d# P0 n$ V/ a6 n

            
    % R. W, K; l9 m" a& _

            


    ) A# M! A( {7 X& l4 fexpression=“execution(* com.javakc.aop.MyTarget.t*())”/>
    7 K* b0 J. h; F& b# m' R0 F4 q' N

            
    2 l8 F% N5 u" j# {! }' i) k

            2 y8 h- D2 m5 X' }

       
    0 L" M! b% A. F& ?


    $ H" `4 Y; P% i$ v$ P- _' m, l3 m. N

    5.3.使用注解的方法相对简单
    . t( w7 B; E* h4 f, K5 C

    @AspectJ的基本语法
    ' ?& l9 \  U# `' j: ~

    1.@Aspect声明一个切面,将一系列的共同的功能定义成一个切面+ X' u$ T( S' g/ F3 L

    直接在类上定义@Aspect; a- G+ b* X* M9 \) ]

    2.@Pointcut声明切入点& g/ _7 a, O; c, `, }) M

    2.1、用一个专门的类来定义pointcut,类中的方法名就是该pointcut的名字1 f+ E& V' N, O+ ~# e- K

    2.2、可以使用匿名的pointcut: f4 G# v& Y& M

    2.3、执行切点的几种方法" \" ]4 Z8 N; h  S& z4 ?3 K

    2.3.1 execute(public * 包结构.*.*.(..)) 可以指定到具体的方法
    ( Y4 f( Z! r7 Q0 ^1 R4 r

    2.3.2 within 指定到包,不能指定到类' Q1 C% I/ L! `7 i+ u4 b

    within(”com.javakc.spring..*”)9 c8 A! N- J1 G0 I

    2.3.3 this 指定到实现接口的所有的实现类
    - R- t" [  L/ {! Q$ ?8 E* ]: w

    2.3.4 target 指定具体的实现类. J( r7 n) S7 \# D; A; O

    5.4.advice的五种类型的示例, y8 k' ^* y! U

        客户端必须从接口走才能得到监控,实现想要追加的功能9 U$ j! x9 }4 P: V

    5.4.1.@AfterReturning(pointcut=”” returning=”retVal”)1 D: ^' a+ S, a- }+ n* h

    追加的方法的参数名字一定要与retrning的名字相同/ l5 d) I7 z1 r# G

    在注解@AfterReturning中必须加上pointcut和returning两个参数* Z  U) b! ?, O1 J; L

    pointcut指所要监控的目标对象的方法
    9 z/ |, `3 Z6 X' b+ g

    得到目标对象的方法的返回值,来作为参数,进行下一步的处理,参数没有顺序,按参数的名字进行匹配7 X& Z, i, j" Y" m

    完成追加的功能! ~( a% W( Z  @/ p9 q

    1 定义一个pointcut,通过方法名来作为pointcut的名称来引用
    ( V& F' u" ]& g7 w

    (1).@AfterReturning(“com.javakc.spring.schemaaop.TestPointcut.t4()”)
    # U. i6 U& h0 F: P

    (2).
    $ I+ h1 H/ Q2 d/ j) P

         2.直接引用匿名的pointcut
    8 E. P% t: `1 @6 u; q

         (1).@AfterReturning(“execution(
    # x; N4 C0 Z; |6 i4 u

    * com.javakc.spring.schemaaop.Api.test4())”)# ^" {1 D7 g( T( Q/ F' Y1 x

         (2).@AfterReturning(pointcut=5 P& r& `' Q4 c) |

    “com.javakc.spring.schemaaop.TestPointcut.t4() &&
    7 \1 M, [0 ^2 {8 m

    args(str)”, returning=”retVal”)8 r' x6 Y0 L5 _# c) F' u/ c

    @AfterReturning (pointcut=”com.javakc.spring.schemaaop.TestPointcut.t4() && args(str)”,returning=”retVal”)
      b% L0 H- @" \1 Y

    public void testAfterReturning(String str,Object retVal){
    & i1 ^2 P" H5 R" V1 Q

        System.out.println(“afterReturning1=>”+retVal+”=>”+str);5 a( H7 K' q0 E' ~0 l

        }" u# k. O3 g/ @

    5.4.2.@Aronud: Q: R9 o( f. _6 w, M5 m

         注解@Around环绕追加功能;$ c& }) Z6 v+ Y+ a0 C% r

         在执行目标对象的方法的前、后追加功能;5 X, I( T- X; R9 d

         必须有参数;第一个参数的类型必须为ProceedingJoinPoint;
    ) Y; `7 ?& @* A. z4 T

         通过ProceedingJoinPoint的实例的proceed来调用所监控的
    8 Z% z6 m8 B3 K4 p; a3 o! p

    目标对象的方法
    & ~6 k, H; e0 m6 a! k

         1 定义一个pointcut,通过方法名来作为pointcut的名称来引用6 g4 ^* g" a7 k! U: w

         (1).@Around(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
      j/ y( s. [+ f

         (2).@Around(“com.javakc.spring.schemaaop.TestPointcut.t2()" @' l9 Y. R. j) x$ ^+ j: n& y0 _* J

    && args(str)”)9 k! \% R/ o2 Q" ^1 s5 s3 S

    2.直接引用匿名的pointcut* v/ p8 p: E" F$ ]

         (1).@Around(“execution(2 g, _% I: Q- z

    * com.javakc.spring.schemaaop.Api.test1())”)
    1 K+ m7 ]6 i% b) Q2 I& ~7 d# @

         (2).@Around(“execution() m% @. T$ P* z

    * com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”). X6 C4 y  W. f8 ?: j

    // @Around(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
    # h/ ?. V: @0 a3 m0 ]; z( o

         @Around(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)9 F) _" R' f/ v' U" ^

    public void testAround(ProceedingJoinPoint prj,String str) throws Throwable{
    , l5 d8 h. x- `/ c5 m! g

        System.out.println(“around1==========before1pointcut==>”+str), _, p- x2 p, n( {3 P" k

            Object obj = prj.proceed();
    3 H3 J: j/ V+ k/ H, Q, l% l  D

            System.out.println(“around1==========after1pointcut==>”+str);8 Y) x0 }1 h5 U% D* A+ |5 S

        }
    & ~; q. D; f7 S5 o  o/ B7 u

    5.4.3.@Before% r1 J6 F0 G7 t6 b7 n4 l8 E

    注解@Before在执行目标对象的方法前追加相应的功能
    * d  ]: m& y* T' k1 [6 J* t

    1 定义一个pointcut,通过方法名来作为pointcut的名称来引用# _! m' G/ X! a/ E" c( k& k. r

    (1).@Before(“com.javakc.spring.schemaaop.TestPointcut.t1()”)- h; D: D( l3 P

    (2).@Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)
    1 @4 h3 g9 P: s" I# H) a: u5 s

    注意args后的名称与参数名相同1 f: ]1 K6 f3 o& T- Y- h$ u" _

    2.直接引用匿名的pointcut* _' r: H2 v$ h+ o

    (1).@Before(“execution(* com.javakc.spring.schemaaop.Api.test1())”)8 s$ O+ Z6 E  a; K: F

    (2).@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
    0 W8 D. e0 e! @5 b7 B" {# O, v

    注意args后的名称与参数名相同
    ! y) F5 q, L1 {% i5 \; ^; x

    // @Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)7 O2 Z) r- r' ?3 y& w4 Z* S( l# V( s3 J

    @Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)
    / \5 ~1 y' p# T; i

    public void testBeforeParam(String str){* |; R6 \8 p. }0 p

        System.out.println(“before1=param=>”+str);8 h& i8 \, c! d% z- V

    }4 J* C, x6 p2 A9 z

    2 t# _6 M0 ^, X7 g' Z

    5.4.4.@After/ o4 c) |# v3 E, l9 I3 L1 X

    注解@After在执行目标对象的方法后追加相应的功能
    . b+ }$ u. w8 Q8 Z  f  B) Q

    1 定义一个pointcut,通过方法名来作为pointcut的名称来引用
    1 Z. a& g$ J3 q, s" e. y) v* {

         (1).@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
    ! M+ B5 S' G  g7 N: E$ s" q

         2.直接引用匿名的pointcut
    - }3 k: r( j" X2 u

         (1).@After(“execution(* com.javakc.spring.schemaaop.Api.test1())”)
    / F/ e) X6 \2 c; B- W

    @After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)
    0 m: h6 s( U: F

        public void testAfter(){) b! |$ Z/ E6 Y( ]

        System.out.println(“after1== >pointcut”);
    6 ?/ [/ q  Y0 X$ u

        }
    . l  }( Y% _. u

    5.4.5.@AfterThorwing( B# g4 x/ m0 }* M& ~, ^

    % G8 X- ]8 |# ~9 _' C/ \0 q6 E
    5 {* |1 |8 e1 Q# s
    • 描述一下spring中BeanFactory和ApplicationContext的差别) f% e2 b! ~& s& m' x9 ?9 ^# J" A

      2 a8 L+ b& d4 R2 `$ u

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


    & ?+ X; |/ O: i; @6 H7 G# [
    • 谈谈spring对DAO的支持% m* z: m1 b+ `2 h

      0 V2 B9 E7 `- O! m& t2 n

    Spring提供的DAO(数据访问对象)支持主要的目的是便于以标准的方式使用不同的数据访问技术。
    * W8 l! z, J* H& w

    简化 DAO 组件的开发。% F0 z) r3 b7 _0 W4 T% ]
    Spring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法,用来简化代码开发。
    1 Q; d* X* `& \9 A6 h

    IoC 容器的使用,提供了 DAO 组件与业务逻辑组件之间的解耦。所有的 DAO 组件,都由容器负责注入到业务逻辑组件中,其业务组件无须关心 DAO 组件的实现。
    ) R. P' K' S/ ^: P- w  y1 n

    面向接口编程及 DAO 模式的使用,提高了系统组件之间的解耦,降低了系统重构的成本。
    ( b0 [5 Z4 {$ d4 \* U" G  Q

    方便的事务管理: Spring的声明式事务管理力度是方法级。
    & X; W: r. h+ Y% H6 G- D

    异常包装:Spring能够包装Hibernate异常,把它们从CheckedException变为RuntimeException; 开发者可选择在恰当的层处理数据中不可恢复的异常,从而避免烦琐的 catch/throw 及异常声明。
    " u5 }1 E1 l6 D/ [1 s( j9 t) J- e


    , Q1 ^! ~- I. x% E6 b' x* l: l9 e( g9 i( u
    • 谈谈spring对hibernate的支持6 A% _6 h# r0 N* R4 a3 u- T) V

      7 g3 C1 H8 I1 V7 L) T

    在所有的 ORM 框架中, Sping 对 Hibernate 的支持最好。如 SessionFactory 的注入、HibernateTemplate 的简化操作及 DAO 支持等。另外, Spring 还提供了统一的异常体系及声明式事务管理等。
    8 ]4 O' ~; f5 Z3 p5 ^5 b

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

    1、通用的资源管理: Spring 的 ApplicationContext 能管理 SessionFactory,使得配置值很容易被管理和修改,无须使用Hibernate 的配置文件。详细配置如下:
    $ O' X' J* R! @6 I7 k$ e% ]


    6 K: G# T6 J7 e. r1 G4 w) `1 P% c# ~

            class=“org.apache.commons.dbcp.BasicDataSource”>+ b& P/ u5 }6 Y/ J' q; G

            2 P% o7 |' B8 D! V8 ?" B

                oracle.jdbc.driver.OracleDriver. u) f9 I( ]5 w  _% V) V1 S

            
    . J* H& G, }+ h6 Z; s. s) K7 b

            
    + X7 F3 f  M! l" i) F

                jdbcracle:thinlocalhost:1521rcl& O0 x4 [: @* m% L! S1 W7 O

            5 C# q( j" v, G4 w; a

            
    - q4 c' h. u; p5 ?% s- z  _8 n' G

                javakc2
      s7 M+ @# a$ H" W* d

            7 ]" R8 @7 L7 R' F; b* g

            
    & h1 {1 n9 {8 T4 t

                javakc25 f1 c+ w/ r/ c- `% u7 z

            2 Y- y2 W; L  c2 T! Q

        ; A, b9 q4 J! l  t% X


    ' I0 Z3 e9 v& f+ w. o! |3 B% c

       

            class=“org.springframework.orm.hibernate3.LocalSessionFactoryBean”>3 n4 \1 p) X/ V" r( w8 {1 V- V

            
    5 V) T* \/ @& M# t5 B' B4 }

            4 b5 F  G2 Z& O

                2 s- z$ ~. Y" @$ c

                    com/javakc/spring/h3/UserModel.hbm.xml9 u, a% f/ g5 H4 W

                
    9 S4 J2 k7 \) F) J5 l

            4 a: C6 r+ h( j0 y

            
    0 Q) a# E9 i( m: `+ x

                
    * v& X/ Z. u; w3 H$ S* W

                    hibernate.dialect=org.hibernate.dialect.OracleDialect
    6 s/ W* R3 I5 ~+ p

                " C7 h* p) ^' I' t# t) J

            % Q7 q; f8 w. n2 @

        & y1 j+ T( h& ?0 {

        5 v2 N( }" Y% {7 f3 e

            
    & @. h, [5 s( ?' ^% m

        0 |2 u/ o; V4 h' T

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

       

            class=“org.springframework.jndi.JndiObjectFactoryBean”>' U2 C0 S' T, U) j% O; T! H

            1 w7 m! d( j& i- _9 `

                java:comp/env/jdbc/myds6 o0 m: E1 H' G

            
    - ~1 V3 o+ W' l6 Y2 C& H

       

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

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

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

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

       
    / A/ t0 G) |% T

            ; Q! ]0 [7 G2 U& Z- @

       
    - {  W5 f+ q2 x) e% \

    ( d# B7 V$ D7 m( t" m# s

       
    3 _! ]7 d! U8 `6 [8 F( d

            
    * }: V! q) B# y

                
    : M/ n+ p0 ]3 ~, I6 o

            
    ! W7 A% F5 R# P' ~4 F# }1 d" o

        % O. L/ \  x3 U7 i: r

    % |0 I1 `4 T6 D+ g4 e9 h

        0 w/ F! P: R1 n) M

              _* b( S8 @& U/ V5 \

            4 p4 _2 @, k) [% S

        9 w) \; K5 u3 D$ G$ Q: p- a5 f

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


    ' ?6 y; O5 Z& I+ M! O6 {( L
    Spring2.0之前事务的写法0 ?& A. q! {4 K

    7 J" a3 b5 M; }1 Z' O! u% W
    ' J( V, f& c: J/ I% ]: h        class=”org.springframework.transaction.interceptor.TransactionProxyFactoryBean”2 x- }& U$ J6 X' j# V

      \! R; Z  L$ e1 M        abstract=”true”>
    % N+ l% k5 W9 C4 m
    * i5 d  Q9 p3 r$ x; |& x* V( K- u

    * w! o% M# N1 Z  t4 ^) v: K! I6 {/ H+ G  ^# S3 m
    5 X  Q; m) I2 x. ^+ u6 m1 A
                    PROPAGATION_REQUIRED,readOnly& A7 H9 M# y+ g# r8 t. @
    0 [1 N% ]* v' ]- {% w: C6 f
                    PROPAGATION_REQUIRED
      j2 @2 }# R3 c
    0 |# O0 [9 M5 `7 ]8 P2 C4 s

      }7 C  D9 I/ ?4 K; c: N: `
    4 w1 m, G- R8 b' U% b# W, V1 g2 H& O
      t& Z6 _* w2 b: R
    5 A% o* e5 b# z2 t" [, H6 z
    • 谈谈Spring对事务的支持: m- S. y9 o+ O0 j3 c& T2 }

      1 w& K+ ?, F; P8 i

    ' R" `$ h: A* q' H+ x7 S
    1、声明式事务管理:

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

    2.做法:

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

    2.2

    2.3 注入数据源

    1 X  U# F. g: `9 X, X) f  E, N
    7 X# B5 _% H, A- z( Q' m7 s

    ; a0 I- n2 Z% [2 v/ e' o/ t+ V  E5 f: }! v& O! |

    6 |$ v8 Z# {) Y- \- M9 b, J
    7 {) F; Z+ N3 ?0 O7 O( ^" k

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


    - ^0 ]# R$ Q- n, ]& J! E( X
    6 x8 }, t8 |3 M5 X5 w( i& g9 F$ E& P* E0 W( a5 T

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

    6 V5 L6 N/ I6 b  U+ r% I% W: z1 b
    ) r7 y6 R! `/ l8 @7 w( ~5 h( N
    : n, G+ J' X. L5 H7 K" U& r, S* I
    , _4 u! ?) T: M' y' S% |

    7 j# }; m, E; H  L- T

    2.6 定义切入点

    " q. y8 L: b# a# f/ ?

    ' l4 o0 }/ ?- v! e3 p$ z5 n
    5 Z) R; t+ N& L' w: \9 r+ Q! D; Z5 [9 x2 E# e/ G* @
    0 r3 f# a# g, G6 H

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

    1.注解@Transcational

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

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

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

    2 S6 t4 j* Y. I  {% D& T5 I

    * N* [  o+ {8 @8 o+ P

    如何在Spring中使用Hibernate的事务:
    $ `' X7 g  F* A" i

      r7 h5 I# I7 k

    0 F! D7 L! T; q) S% s


    ) r- _7 ]7 l2 p9 D

    如何在Spring中使用JTA的事务:
    ' I& L  P7 K4 s

    / C8 A0 e, V8 o- J8 X3 k
    红红火火恍恍惚惚
    回复

    使用道具 举报

    admin    

    1244

    主题

    544

    听众

    1万

    金钱

    管理员

  • TA的每日心情

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

    [LV.5]常住居民I

    管理员

    17#
    发表于 2014-12-03 12:48:32 |只看该作者
    事务! N2 j  a/ o  o! o0 t9 @( I8 Y; j
    ACID7 Q+ J! I4 R1 l
    (1)原子性(A):一系列的操作具有不可分割性,要么成功,要么失败, j6 p  P0 P. \, U& j" b

    ! {( j" S) ]7 k; g# Y6 j. T, J0 z(2)一致性 :操作的前后满足同样的规则,保持平衡。
    9 C. x$ _) {! `0 p
    * B  I7 h( x8 X( Q& y(3)隔离性 :在事务运行的过程中。事务内的数据对外的可见性和可操作性(必需由数据库的支持)4 S& T9 H; u6 L5 l/ Z" p" [
    / F1 M, W/ L- C& R
    (4)稳定性 :保证数据在事务的操作的过程中不会遭到破坏,而且是永久性存储的' d  T" ^  [' u  s! I

    & w$ i! B/ O' @. j5 p0 } % E% d7 ^7 e# h) a- A

    9 O* j7 ?6 x% ~2 z( d- l事务模型" J' g4 I" Q3 l3 e% R6 i
    (1)经典事务模型又叫平面事务模型(JDBC) 事务不允许嵌套* ~9 Y" O9 a7 a8 s, l

    ( u8 a) Z4 Z8 Z  X+ L2 B. V' T(2)嵌套事务模型
    ) M4 X; V3 z0 B) q5 I- x; e0 E$ G  a

    2 e) ~4 {9 I' L- q9 y3 U3 S
    6 ~! ~* M. ~( `事务的两种方式/ i( n2 w4 ]) H; u7 A6 c
    (1)声明式
    7 o5 y2 O3 i  _
    2 e. j; u3 O! r在配置文件中设置以下6项, B- }" p' P- J1 z+ m! a& y( g

    6 _& a8 a: i* ?* X(1).required
      L  S$ c/ q$ g. p) P3 z0 D$ i9 Y8 Z. `* u% t3 R
    如果客户端没有事务 在bean中新起一个事务1 c, x  Y) ]: ^: B- H+ @- X

    / Z( D& R- g% k* ]如果客户端有事务bean 中就加进去
    " Z! i4 l8 n! D5 ~  f& p, i0 g; ~3 L" O" C3 t
    (2)、 requiresNew' m( j( k$ z, c1 s- p
    ; n3 `4 s  ]6 G/ l7 ?
    不管客户端有没有事务服务器段都新起一个事务7 ^# Z% V. E- v2 e/ y% N8 ~

    ( m4 {/ T, P# X' g) K6 U) R如果客户端有事务就将事务挂起/ w3 L" d( B- ^& d/ n8 j

    * S) f4 f9 t7 g3 c: j7 M8 D(3)、supports, l& q  i3 @3 v2 N

    ( O1 _9 m; J# v7 G如果客户端没有事务服务端也没有事务- @) _# P2 n4 \# S  M+ {/ M" v

    4 d2 k8 u3 u( v$ H" A3 p# Y如果客户端有事务服务端就加一个事务
    & \# H: j$ p/ q% C. @+ p, j+ K% e
    2 R0 p2 |+ Z2 D(4)、mandatcry
    . V' u! e( y& E. l
    & V3 q/ V- g4 ?% l+ p如果客户端没有事务服务端就会报错
    ! k* U( |8 H5 ]% D7 l* k
    7 _% S0 U& C( ~+ c2 D  K如果客户端有事务服务端就加事务
    . m5 r8 U6 b: I/ I$ Z! x  x
    - ]4 @+ p9 ]/ E8 g2 _& {) Y4 n(5)、notSupported8 Q5 _1 |- j4 u1 c4 S' J

    9 p5 \0 x5 j! r, }8 t) C不管客户端有没有事务服务端都没有事务7 f2 _% r, P: Q" y3 W
    ( S8 [& e% q- T* f$ r; `9 H' x- b
    如果客户端有事务服务端就挂起  @8 e% `) K; o: p5 f

    & d- Y# M! c# V8 L9 Q  F(6)、never
    + K: Q3 `9 z. v! h- R6 }& r% U% H; m7 o2 i1 N( ^1 q
    不管客户端有没有事务服务端都没有事务
    & q  Q, ?# A9 l# t/ Q# q0 a- w6 W" x% y: k& K# j4 c  ]0 }9 J
    如果客户端有事务就报错" y+ X1 n; @8 t; B; |
    ! I8 L' B$ ?# e1 @9 f4 O
    (2)编程式事务
    8 W# D  s. t; t6 [" t6 x
    8 z" k* Z( h) j* i& B8 p3 FJavax.transaction.UserTranscation; x# y+ I$ A8 `4 t* Q& o: v
    0 a+ s0 I9 \6 f% c
    JTA 事务可以精确到事务的开始和结束9 F* Q* `0 R* y- l6 {7 E
    ; _) L" \3 M1 I. h! X
    5 a  T$ y0 a* x% `
      h0 |! w+ m9 {& ~5 u; K6 l  V+ u
    事务的隔离性
    $ Y/ F. H. ?6 N6 D3 lRead-uncommited
    # O5 i1 R( A0 o; l" O
    ) y( h/ j) I/ T9 r读取未提交的数据(基本上没有锁)脏读,存在不当读取的问题。0 V! Y- N" ^, [" J- f7 r

    - g9 w6 M' R  D/ [$ o" E* V' D$ V  {Read-commited; {, c; K! T! n) J% y/ c, _

    - q3 e  V- `' D0 i. _( n读取已提交的数据(行级锁)
    " i5 `$ d" M6 X' z3 i6 u8 v0 y: ~* C- B: U
    无法读取已经写入,但没有被提交的数据。
    1 }: B+ x  C; b) A% j  k! V
    1 t" Z3 g% e4 q9 kRepeatable_read1 J* `: ?$ P8 P8 f

    2 G  N+ N4 h: q5 k! |5 _* b8 I读取的数据不允许修改或删除$ ?- n: x0 i6 L) J: A6 N
    * f; j3 ~  z. K* A/ N5 U
    不可重复读(行级锁+不允许修改/删除)$ _1 e6 \# V/ ^% C9 g% |
    ) t* S* u6 c8 Z/ n% t2 q
    Serializable
    " j+ I; q$ W& f' _. J" z, e4 N6 O( z1 W( W! v  ?9 ?; E5 s" u
    幻影读(表级锁)
    & p% h; X: O, m) u1 X. Z/ x- X9 o$ A# V( [/ m' @
      o9 K6 P) \3 D. @  t. h& T+ @

    ; g. ]& y8 V7 Kstruts% Y& l$ l- z  c4 P
    开发流程
    + Y0 N5 p8 Q' P0 O8 E
    $ Y# M& G* |$ d! f5 Z, C1、创建表单
    9 @2 r2 G: X$ A* v4 ?7 B5 Q
    , ]+ F4 C. U1 |2、从表单中获得输入% v8 i/ i& _+ g
    + x% `$ i$ e3 L1 \4 A
    3、处理输入(业务逻辑)8 v7 I1 U! }4 ~/ g7 C

    / _2 z( ]2 l, A4、根据动态输入改变输入流
    0 k/ t9 P* ?6 |! g/ J9 Z  n* R$ S2 W# I
    要完成上述四步,我们需要创建  ?3 h5 F. O' X
    8 F/ R( ~; a7 A; S# p2 h, F
    1、一个ActionForm
    2 z8 l; k& b' N3 A) j, p& u( @. C; C/ W2 N( [# n6 I4 G) W. y
    2、一个action$ v9 z8 U5 G1 g
    0 {8 D' |6 s9 o( Q+ V5 w. ~
    3、一个配置文件struts-config.xml
    1 O; m5 |; Z' J9 @3 Y( r. H3 \9 B/ z+ e! F8 }4 m9 B
    4、创建页面
    ! A; Z5 {# P; j" u# i" X7 h% z. H+ p, V  {, x
    创建ActionForm  `# S; F0 @7 ~4 }3 }, A

    # G+ \% ~, G  j; N" J1、写一个类继承ActionForm; r6 k: J/ q4 F- o( l2 O" [
    ( z3 t) j- X) {- s5 y: s8 U: R3 b
    2、私有的属性4 C1 ]& N0 F9 }4 L
    : m  J/ d8 G' ]( A$ O
    3、相应的get、set方法0 x: y" g8 f0 R! g6 t
    , y4 f6 [& i1 [8 R) a. S
    4、重写tostring、equals、hashcode三个方法/ w% C/ t7 w9 h* L% H9 W* I6 M. c
    3 Q2 c. m) F  ~. m! t
    创建action
    $ z. d4 y# A8 }( D8 Z4 p/ H+ d6 }
    1、写一个类继承Action: P5 C! r5 R* z

    3 O& P0 l+ C. z8 G2、实现一个公有的方法(回调方法)
    - I: i: K3 w# e( c- u% G5 k
    5 a& o5 O% ?9 g3 v* K2 `public ActionForward execute(ActionMapping mapping,# |# e* J0 w6 e; f
    4 y3 I% s0 w+ b, m7 o( q: `
    ActionForm form,: R6 H: j  J3 n  j5 e3 y

      e3 p( ]% `+ ]! ]2 IHttpServletRequest request,2 E- E0 k0 K: K
    0 _! b; H; `; j5 Y
    HttpServletResponse response)
    ! x- w( s) s# j, c
    2 a0 A- }4 y9 u* d7 _9 q, y: m3 ?1 p{
    ! [* Q( n1 i) J. {1 _# m6 K- V- K' I5 r- S* ]9 J
    //1.收集参数
    / o7 O3 z4 f" f+ l
    8 q4 k) A' Q0 |% N% R! W& pMyActionForm myForm = (MyActionForm)form;6 i. N( u& r  T4 O

    & w% W& q1 ~# P& f6 L+ N% T//2.组织参数
    " X( B, T  p& k& D
    / M) Z' Q* v. v' _4 e9 X# } + |2 ~' a3 A9 Z7 i$ z5 u
    : |  h- |3 X6 N% S
    //3.调用逻辑层
    / b9 Q. H# p9 X; k* E4 @7 N& e
    9 y- S4 e5 T" O/ O7 ~boolean flag = true;  z% q2 ^& z" ?2 S5 u
    % w7 G% |! Y/ }$ N
    //4.根据返回值来跳转到相应的页面
    , U- `: E5 s: k; z; p" V$ w( T* i# j
    ActionForward af = new ActionForward();, F% p. t+ X; F9 B; R& S
    % A& d$ p0 b- f$ S: e8 ?& O
    if(flag){4 K& Q, G, P4 h3 x; E/ M! E
    . b$ M% f3 @6 X, Y: A; B" f
    af = mapping.findForward(“1″);
    # H% t' ]2 a: m3 c! r# d9 |6 Y
    # R0 q: z* ?9 S1 h}else{9 M% t; b4 |& @& A4 q

    2 _2 x" {$ W  Z$ u/ D) j" }af = mapping.findForward(“2″);* L2 o8 n: N; }& B9 g
    2 j4 _3 I" z+ s$ K- N5 e1 i
    }
    . }; Q" n& X8 E, L% J
    & X+ L+ W; P0 V2 q- c$ l# q/ J. j6 B; Wreturn af;9 |- ^9 }. R1 ]

    1 D; q% w" \9 s# Q4 N}
    $ f( K( {6 p9 S0 J$ l0 X3 s' p4 m1 h0 H$ b
    配置struts-config.xml文件
    + L+ A6 E' S( T/ q, N1 g+ Y, Y( M% X9 x2 G3 _5 f% l$ @
    1.<form-beans>  h) S* \1 n0 _1 e+ j2 H
    & g" w. p! m3 W% s4 n- w; i
    <form-bean name=”myActionForm” type=”全路径.MyActionForm”/>
    0 X+ B8 s$ T1 B* k6 F6 c; Q
    9 e8 S7 ~  ~" a2 ?$ f5 l9 |<form-bean />
    % _/ i2 R& Z5 ?7 a1 W& S) }2 F4 u+ t  I; @" B3 f6 I
    </form-beans>
    5 p3 A( x0 T/ E! x- C5 D, Z5 ^7 R( |& G' ?* \
    2.<action-mappings>
    " d4 d/ Z9 ]7 p. P7 A+ c' r, A, X+ S; a( F: X, ?' _3 C
    <action path=”/sll”
    3 b1 Q6 a: X: f! g7 a* y! w0 ^) v. A& p; P, {' o1 o3 [7 Q$ `
    name=”myActionForm”1 r- j/ S  K7 o5 ]4 X! v
    " G0 G; b5 M  V# H$ C- h
    type=”全路径.MyAction”* ]) c- D. e. G) }3 Z. }( F
    , V# z6 V2 |. c# i( R
    scope=”session”1 O4 J: g4 F) n8 _& [

    6 W  }& T) y8 F/ J! Z5 D) A' Zinput=”错误返回的页面”>
    / V% ]$ ]4 V) @4 ]1 o' [/ r: n+ O8 Q7 F2 r7 T# y$ d" D9 H
    <forward name=”1″ path=”/1.jsp”>' v8 V! O/ A4 R5 G3 d2 F# R  A

    4 y5 _0 E+ v' m9 H8 G<forward name=”2″ path=”/2.jsp”>
    ! k$ B& i/ y! X. w4 R& S/ Y2 z
    : c' [& p. H. K- q( O* t</action>% x+ C' x/ t! {9 |8 Q( _: p

    ! }  C; U2 P5 U: V( f</action-mappings>
    * V" y, \( B0 {$ K! K* ^" \, ^5 r: u! h" y* e- V# H9 U
    步骤:9 b% V; z2 J5 P$ ]

    9 O. |' l# m8 ^5 c. N  f/ d1.创建一个空的web应用, g) H2 {) a0 r

    9 A6 z& V: m- x4 {) U* H$ Z; T2.将struts的包放到lib文件夹下
    # O- N8 p1 W% t: p9 }2 `7 e8 ^
    % e& M/ j9 p- H. i7 f1 m3.将.tld文件文件和struts-config.xml、web.xml放到WEB-INF的跟目录下4 o+ F( [/ F' N) c0 N0 X$ F
    ; a/ `4 m/ [3 N
    4.配置struts-config.xml文件和web.xml文件
    ; C4 ]1 M6 `6 |3 ~0 i, b4 [; X% l# U* ]- C
    5.在页面引入tag文件uri
    : }) p) r% ~' i9 z- s& z4 H0 w5 H) U% L  P
    STRUTS运行机制
    % `( C* B! n1 j' q; o# }
    0 |; m3 A; P2 G, P1、界面点击产生请求
    # V7 Z6 o+ L! {, z( f, g5 _! j) u5 B1 w, e2 Q
    2、容器接到请求2 e% ?( v5 j. p. S
    # m- c2 h7 s" ]: t6 O1 e
    3、匹配web.xml文件中的*.do来调用ActionServlet
    8 ?) o# s- b, q' x6 H; u! g7 h4 i0 i- g7 X
    4、ActionServlet的处理
    % w4 j9 S- e3 t4 W4 \
    ; g, E$ D) g2 r4.1 读struts-congfig.xml文件形成ActionMapping
    / \  _7 _: L. G7 m  z7 L: ~) }* `6 L. j  M
    4.2 通过path 来匹配Action类,通过Action的name属性来匹配ActionForm类6 ?# Z; R/ i( P: J8 K8 f: D+ z) t
    + ~2 p- O7 V- ~# c1 w8 y, K+ ~
    4.3 通过反射机制来给Form添数据, j1 Z% W0 q" r2 d: v3 e( [3 ]
    , o- [( _* U% c# H9 E
    4.4 由ActionServlet转调Action的execute方法
    0 `" o# o/ Q! c) Z. ?0 `" {3 [7 Y2 O
    4.5 得到execute方法的返回值,跳转页面6 {4 k" A0 t" s- n7 A- I6 `$ ~
    5 G9 D  R7 m3 c5 u1 ?% `4 ]
    4.5.1 RequestDispatcher2 t3 o4 Y% V/ |. D9 u
    / F  y% {! d! n$ g. h( E; g
    4.5.2 response.sendRedirect(“list.jsp”);5 m- S1 J9 r7 n3 H- G" ?5 t

    / L, p0 g' B4 T- }  g 3 ~2 i9 p1 T4 b' A% l
    0 U+ w7 n$ p% D" L8 w9 `+ ]
    进入execute方法
    $ s1 a3 ~) T2 j* s: _5 Y: Q5 N5 s( J8 c4 N
    1 收集参数% G+ q9 m& ~- q4 ^: {+ c& V) C
    ' O- e. y5 u: o
    2 组织参数
    # d  X$ V! c/ B0 y( C! d' H& `. V4 V6 R/ N6 j
    3 调用,逻辑层  H! P  @& B5 ^% ]1 c

    5 Q5 ^% N+ J8 G' U/ q4 返回值7 t; I* z; c# L+ J+ H7 d& r

    7 S9 O' T9 {( B, j4.1 选择下一个页面 (ActionForward)
    ; W$ v3 m" L* `8 n- N+ N( m- L' h( d( z  T! D0 b% t
    4.2 把值传给下一个页面* ^( \8 W# L; [5 C( m+ f

    5 M4 F& \! g* K8 g- B+ k0 @. e3 m
    : L. P6 D7 Y8 y5 D; t) G1 x9 `4 t0 s( Q% w
    比较struts和struts2的不同
    : j$ \; C2 M  r% w
    3 P5 {! q" [1 W, M( mStruts
    ! h9 M2 h$ l& K1 W, p5 o' T/ a' B. o1 K9 _8 _, l
    Struts2
    ! N$ ~+ k5 }/ w0 C, G: T8 _8 M8 W' R( {5 _  S6 v5 H- B
    组成        五个部分:ActionServlet,ActionMapping,AtcionForward,ActionForm,Action        十个部分:AcionContext,FilterDispatcher,ActionMapper,ActionProxy,Configuration Manager,Action Invocation,Interceptot,Action,Result,Taglib
      g5 k9 C! T5 }) ~url        .do        .action6 b1 d' {% f- ^* T# W
    分发控制        AtcionServlet        FilterDispatcher
    ! m9 {- B- d( x0 ]# y收集参数        利用JavaBean技术,将数据封装到ActionForm的子类中;! B0 k: A- y6 @; T% T: m
    一个Action对应一个ActionForm的子类& W1 P) l1 q0 c0 q2 ~6 C! c
    0 R# Z) l0 A  o8 w6 q2 h1 C- o
    使用拦截器将数据封装到值栈中。
    # x3 Z# e$ _( S7 b" F使用域模型,一个Action对应多个值栈中的Model
    9 Y* P. B  o+ @% E& n# i: K
    7 L, Y7 t# a2 {% [1 ^8 i6 ^读取配置文件        ActionMapping        Configuration Manager9 c# H' b) _& o3 v! U
    拦截器        无拦截器        执行Action前后有拦截器* K8 @, ~0 T3 [: k
    返回页面        将字符串封装到AtcionForward,进行跳转页面        Action中直接返回字符串,通过Result跳转页面" R& W  o  U7 s1 t
    页面跳转方式        两种:dispatch,redirect        三种:dispatch,redirect,chain( C" T4 o2 k/ C8 }
    值栈        无值栈,Action通过在request范围内设置属性,向jsp页面传递数据        有值栈,Action和jsp页面通过值栈传递数据,jsp页面通过OGNL取得值栈中的数据
    7 J2 Y0 {! K7 T+ V: r3 P8 \配置文件        struts-config.xml        struts.xml
    1 S1 t* d" d3 i/ c  j  S/ o中文问题        不能解决(需要使用filter)        可以解决中文问题:
    & }3 @6 ]" W) T' E  ]1、在jsp页面添加Meta;
    ( v1 r: ]- W0 e1 W& Q. `# ?( X& k. p2 r
    2、修改struts.properties中的设置。
    回复

    使用道具 举报

    admin    

    1244

    主题

    544

    听众

    1万

    金钱

    管理员

  • TA的每日心情

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

    [LV.5]常住居民I

    管理员

    18#
    发表于 2014-12-03 12:49:03 |只看该作者
    其他开发工具和技术* e( {( l; x- v9 s
    Ant; S' F: c7 \0 I
    Ant是基于java的批处理工具- `3 G3 v: V3 c8 J( }
    ) y5 b) }0 N# b) I% b& H
    一、配置ant的运行环境
    3 _& a1 o/ B8 ?" Q) ~6 O, @4 ~: ^1 E! l9 q" e& ]- v* w& ?
    1.将ant的bin目录添加到path中
    $ C4 n5 E0 g, B
    ! x/ U" R8 L# K. @$ _" D2.配置JAVA_HOME( B* Z$ J5 `7 P3 B4 R) Z
    + g- k5 |9 ]; m' B, C+ T( m+ B
    3.配置ANT_HOME+ B$ O- v" }5 g2 \

    8 ]7 \( k8 ~) X8 {& x二、配制build.xml文件,该文件放在应用程序的根目录下# m, J/ N+ q% P& H0 d

    ' ~. D+ z2 D3 y0 |$ T编译java文件
    3 O* j+ b6 p! N) ?/ x8 Q1 \$ e' p5 ^3 p( n. Y% [/ T! L  u6 X& E
    执行java文件
    % A2 U( l/ S4 N" @
    , ~. n& W: I9 n8 f' p& p( H: P* C% icopy- F9 o( ]. u0 [" i" C

    % w8 ?  e2 v. K% r) Z: h删除
    ' @. x: y# \4 ~  E, p9 O7 w- _# m. j6 e5 L$ t# P' O
    打jar包
    , p; M; b7 j& z4 V, R# V; ~; K
    " ~! y% B# {  n" i. b3 q, K根据注解生成配置文件) @3 ]. V/ \- X; R& r; O- A

    ' a. b+ q/ N8 \Xdoclet; w) p$ u# ]; o
    通过注释生成一系列文件的工具(txt、xml、java、html等)& ~+ E* w2 m! U* Z
    , H7 Q" F/ [9 j
    xdoclet本质是摸板技术+字符串的替换; N0 x: j) q( K4 e/ C8 p& n
    " f3 \6 L, N% M3 j
    1.在java文件中写符合要求的注释(将hbm.xml文件的内容搬到java文件中去写)2 b+ O, J$ o) \
    - D6 l" R2 k* ?0 e8 q
    1.1 在类的上面 写与表的对应5 X# L8 x) I: l* [/ [; y1 w

    ( p! A: B) e6 n, U/ t1.2 将每一个属性的注释都写到get方法的上面" t, k7 M. K$ p& ]
    " J, t4 J+ l0 g7 n+ D5 ]
    2.在ant中引入相应的task来驱动xdoclet( L; m+ v# Q- X8 }) m
    9 ^# c, T1 |& L1 w
    7 j: c+ g  a8 v, D; M" w7 T; b
    % F; V! i' f- k5 _0 V2 H  k
    log4j日志管理. b' e" ]/ C" G) Z6 E
    1、是什么?& m6 k& j$ G9 e
    . N. a3 \9 D, v) O3 \6 G( @5 Z
    在开发期间用来测试、对整个日志信息进行管理的工具" P+ ^7 \3 N, l7 b$ o$ e9 {! k
    8 u- n+ C8 c' B/ R/ O' g
    2、功能
    - ^! U* a! u' ?4 F( a& \3 L) y3 l* K4 B9 q: i! _
    1.控制输出的目的地
    ' T3 l( C8 y$ V. O- Z  q! S( L- x% E, T# T: O. r% q. C+ r
    2. 控制输出的格式" H: w) L$ _* R- u1 ]# G
    - p6 w) |( H* D/ _; U
    3. 控制输出的级别
    7 Q) W8 b; j2 T& Y$ y" G3 t+ z
    & P2 V' u- V9 ^8 Q7 c# ^3、日志的级别% u  O, L1 l# K+ Y1 F1 o+ Z1 C
    1 t; B/ E. x8 x) U7 C
    1. debug 调试$ J$ B+ U. h$ c7 Z6 [

    $ _+ l& j$ g, v0 K3 v( G# W2. info 给用户的提示信息+ b7 R) V7 M/ q3 K, D: y8 o
    ; I2 F0 Q8 Q" O7 U5 E% \
    3. warn 给用户的警告信息* N* x' R$ x* `' a

    0 v: ~- v! q# Q9 ?! J4.error 给程序员用来调试; o7 T( e6 f; }7 }4 ?8 Z
    2 x7 n) q2 ]2 C+ J
    Debug—-〉info—-〉warn——–〉error
    7 h- i; ?% e; `, L( E, z( b, A6 b/ ^2 D3 K0 a2 w# i
    4、配置# K' I/ H4 M3 e/ J% p/ j! s0 c7 O
    $ Z2 r$ @& Q& f5 ~; B7 {! ^
    1.配置级别& E9 H/ @6 |, g; A' G
    8 U" V/ p2 z9 h) a3 a+ D
    2.输入源 (控制台和文件)
    6 Z1 c# o6 `9 L2 F0 o& m$ _; O, _2 k
    3.可以进行分包控制
    3 {7 M0 \6 K3 J* E6 c( V6 `! }. w5 v; q( D% B2 C+ w
    Log4f.logger.包结构 = 级别
    , \; y: r+ ~5 d' e$ i* I9 u. m
    & o4 N/ ~  x3 q7 g5、使用
    : H! E: }3 S% |+ P( R% h# o" r. M8 B+ E
    Logger log=Logger.getLogger(Test.class);; Y$ c3 l/ |7 G/ o& d
    # X0 q& X2 L( e
        public
    ; C$ g# V- I' M0 C9 n' [void t3(){
    1 l& E* a2 O: h  l+ Y# V: R- k" g! ~3 q+ o9 P# m; `
            log.debug(“this is debug”);0 V, q" r' _/ {( Z2 u. t

    ' O( F7 i1 x' f, _# u6 m- n0 u        log.info(“this is info”);
    + D/ c* ?- c0 \  Q6 D4 `. D- j# s: L/ Y
            log.warn(“this is warn “);- `) O, p. K+ K2 S4 Q& W

    - C" z  j4 G3 K4 m0 o        log.error(“this is error”);
    % P* b/ O; e, s: g$ l, ^0 f
    - J0 ]& t7 `$ g9 d  Q    }
    # z# q  l$ L8 D/ m7 c
    7 c/ x3 P# g/ H+ ]9 L5 X  ~' b' XJunit
    ! a$ k  [  A1 y1.是什么?: i+ ?5 `! L0 T+ l

    1 }  P& [5 B$ [0 X0 T7 s+ O单元测试的框架9 [1 x) B7 q: l* Q! X* a0 g
    / M9 F3 J  Y$ f' Y
    2.怎么做?
    ( K* i5 p8 H6 O) w9 I3 ?- N
    + c% Q* ~! K' o7 R6 ]6 o) n写一个类继承TestCase
    , k  e% r! M) J6 _% B( p1 E3 W+ ?! |
    测试的方法一般都以test开头并且没有参数
    ' V1 m( J$ \) E" M& O5 |" L
    % x" y$ h! n' i* {在测试方法前执行的方法public void setUp( )
    9 u0 n0 ^6 @5 ^' O
    2 M4 H' ~7 q" |/ R" R* ~在测试方法后执行的方法public void tearDown( ): c! i% V' h: H

    % B1 o% L8 I. D+ d( S* Zerror和故障的区别% \% l. }( {5 W- U* K5 e8 m) n
    # f, E! {2 i' g- a  @2 M
    error :代码有问题
    - l3 v9 f1 P( A0 ]/ W+ b
    4 `8 y7 L9 y$ ]4 G+ h故障 :逻辑有问题与祈望的值不相符合) ?" l- m! N1 ?6 Z7 ]! h& j% j% c3 T

    . D. p# h6 v# q; {$ ]) P1 b" b) m生命周期
    . u3 ]6 R7 ~7 l2 |0 f4 X0 J, p. J
    测试—〉SetUp()—〉testXX()—〉tearDown()—〉结束;
    # x8 z" I* I0 x+ ?# ]7 z# \" W* ]- m7 R3 U/ h% p8 G
    TestCase套件, i- Z7 f% S" |3 G- D; N8 g3 X

    7 w0 d$ j& k+ z4 [% {public class MyTest{
    ) W/ n8 h% B) ]& y. {& D3 k( O( p$ t9 s3 b
            Public static Test suite(){
    8 ~( a% e, Y( H) i; D$ Y' _; A6 f' A* R: g& e7 V
    TestSuite suite = new TestSuite();$ x% V5 x5 i5 l, \. U

    0 `, R3 d: m0 b5 e( Y2 `suite.addTestCase(Test1.class);" {& R  S, r" _  p4 Q2 I3 [

    ) r9 h& ~/ _2 ~6 d4 a, Bsuite.addTestCase(Test2.class);
    3 q  d# h7 G- t0 ]5 W1 C) H/ |0 v, g5 R- T
    }9 j- \2 f5 W0 `! ]2 Q" k3 q+ \* ^

    6 j7 w  s$ Y' F0 [6 s" Y/ w+ k}
    4 [; |- l( b- i3 H0 z
    % W  N+ D4 E7 B& n5 u8 S( j' W6 [% r/ q2 l
    1 M" W: ?  @4 P+ Y8 F: x% E& e
    . \; _  C  Q3 c. XAjax9 E7 G0 D8 ~7 m# g2 D$ u
    是什么?9 ~5 f4 p% @! e# g
    AJAX即“Asynchronous JavaScript and XML”(异步JavaScript和XML)。是一种创建交互式网页应用的网页开发技术。
    " ?5 z2 U' u  b1 Y) U2 ^) z& g: y' F( I
    无刷新页面。0 e2 O" S$ b2 @% C" B/ Z

    / H" q  a& v+ `) L有什么?/ I; T1 \3 A/ h* r: Z  q1 z
    AJAX是多种技术的综合,包括JavaScript、XHTML和CSS、DOM、XML 和 XSLT、XMLHttpRequest。+ U+ _1 b( @( A8 x+ @

    4 N2 U) A3 X0 _( S3 z能干什么?
    9 Y8 C! W+ ]/ S! e7 L3 H0 d* a使用XHTML+CSS标准化呈现;1 h2 J# J$ r  _* w
    使用DOM进行动态显示及交互;/ R7 [4 v6 e  ^( t8 E; h8 b$ Y
    使用 XML 和 XSLT 进行数据交换及相关操作;3 B$ L: ?! ]% c9 x. L
    使用 XMLHttpRequest 进行异步数据查询、检索;
    - V) s+ h# m; B/ k9 V) D7 m( W. |1 R使用JavaScript绑定和处理有所得数据;
    , U4 B% R' M# Q9 F8 M- L5 D5 J+ C; C# n; u( E
    传统的web应用允许用户填写表单(form),当提交表单时就向web服务器发送一个请求。服务器接收并处理传来的表单,然後返回一个新的网页。这个做法浪费了许多带宽,因为在前後两个页面中的大部分HTML代码往往是相同的。由于每次应用的交互都需要向服务器发送请求,应用的响应时间就依赖于服务器的响应时间。这导致了用户界面的响应比本地应用慢得多。
    ( G' d% P6 Y$ [0 |# x  r: i7 X$ l5 r' b' o7 [8 W. o
    与此不同,AJAX应用可以仅向服务器发送并取回必需的数据,它使用SOAP或其它一些基于XML的web service接口,并在客户端采用JavaScript处理来自服务器的响应。因为在服务器和浏览器之间交换的数据大量减少,结果我们就能看到响应更快的应用。同时很多的处理工作可以在发出请求的客户端机器上完成,所以Web服务器的处理时间也减少了。' b3 D+ h/ w7 V
    ( B/ Q+ ?' x" j/ M
    使用Ajax的最大优点,就是能在不更新整个页面的前提下维护数据。这使得Web应用程序更为迅捷地回应用户动作,并避免了在网络上发送那些没有改变过的信息。
    / q2 {& T8 F0 b8 y9 v  S- C, h1 A& V+ K6 L
    对应用Ajax最主要的批评就是:
    3 p' N: `+ ^& Z0 h7 i- D1 它破坏了浏览器后退按钮的正常行为,就是用户点击后退按钮后不能看到之前的数据;
    ( d2 K3 ~0 T4 [# S4 p! Y2 一些手持设备(如手机、PDA等)现在还不能很好的支持Ajax;
    $ N% W( |/ h* q5 f8 k$ z3 用JavaScript作的Ajax引擎,JavaScript的兼容性和DeBug都是让人头痛的事;9 o% z8 o: [& y# P/ n1 T
    4 Ajax的无刷新重载,由于页面的变化没有刷新重载那么明显,所以容易给用户带来困扰――用户不太清楚现在的数据是新的还是已经更新过的;现有的解决有:在相关位置提示、数据更新的区域设计得比较明显、数据更新后给用户提示等;& t4 y" `8 r& t- `/ A2 Z6 f, _

    $ l7 v. b2 r+ l; h, X. B; p怎么做?
    5 ?" {$ ?2 ?; h2 ?3 C5 u( B, v$ H<script language=”javascript”>
    8 d3 s- o, ~  |9 `
    4 F7 P% x9 V8 h! D, x1 r& X1 Fvar req;  o- Y" d6 n6 |( h8 L1 h) `3 E9 \, x
    8 o  B+ ^. T* `6 X9 Y! Z: k
    function add(){- z2 z4 ?( A! ]
    2 n3 Z, g) h5 X+ T* z, y
    //1:创建用于传输的对象$ D- G" P1 Z4 S* a- J
    % T: S$ h7 p, T
    req=new ActiveXObject(“Microsoft.XMLHTTP”);5 [% `0 h, [. z- Q
    * J, `, Z3 y2 w$ m2 G
    // 声明返回后,处理数据的方法2 G9 P6 w2 J+ L$ W' [' b5 y- |: M, U4 w
    . S8 M; |/ l( W% V3 \
    req.onreadystatechange=manage;
    ' V7 {1 K, I3 f9 r$ k3 B, o7 O! b6 E: |% O$ t1 Q$ i% o, [: d
    //2:准备传输的内容' k, Q/ b) p" _* m  d
    ! a. ?* x1 u) V3 X+ n/ `$ x
    var str=”test1111″;
    % c* t$ S3 O9 w3 d; N+ o7 j0 ~3 H
    1 d1 B( N5 H6 A  B' ^- q//3:发出请求* c( r9 c7 s9 T9 P( S2 ^3 A

      P+ l" p  n4 z8 Sreq.open(“GET” ,”/others/ajax/test/t2.jsp?str=”+str);
    0 e# |7 [$ e4 v8 ?" h
    3 e: x: i' v8 nreq.send(null);. M" [1 E- X  _' S1 e* O1 m

    1 i1 w  M6 R, c7 Y+ ?}
    : U# I  e7 x; g4 `$ `$ V# R1 w4 G' o1 R
    //4:接受返回并处理
    # |5 R7 G5 O" d; B7 d
    " A; p+ q# \. {/ rfunction manage(){
    5 Q* S8 I' i7 Y; |% E$ b
    + |6 q1 B- x5 a* ^if(req.readyState==4){$ U; c$ D4 ]0 k
    ; W9 ]; d4 u% K/ L- ^
    alert(“r==”+req.responseText);! d& M6 n# X  ~7 e0 ^

    6 i! J8 d1 _; i5 T5 w  X% S( }( f}* a, i) a) D, z% x; t( S

    6 S4 J" k7 A2 L. i# t0 R, R  Y}
    : T9 A7 c: q  `* v  [  D* u. q3 F  J. m  m* |. o; {& y; D9 r; v) K
    </script>- |4 g, _. `" u
    # c: v7 D3 q' w% s' k% o* V+ T
    readyState的取值如下:
    & O2 M9 z4 w- J1 z: C) c1 U% A3 m" ~
    # C( }$ e2 p! B3 B  0 (未初始化)
    ( w8 W9 F* p9 C: T( O, d- m
    " P) b/ J" k6 I  Z. L% w. [6 \# v  1 (正在装载)3 |; u* W5 X1 K! \, `
    7 ~8 a$ c& g' B1 c! A3 J( |# Y
      2 (装载完毕); k5 j9 _6 L5 ~

    . u- L% R' L6 r  3 (交互中)
    # C  f$ ?  |$ s
    - q8 ]8 r8 a/ K* h( {. h  4 (完成)
    ; c7 K! A5 B, I0 D$ T; H5 A* {2 j
    " o3 g: q, J* H4 B$ h
    $ b6 E$ t( E9 o7 y- g, B9 T
    - w0 n1 }3 s4 b1 Y2 W. A原理" M% Q4 t8 C+ v
    Ajax的原理简单来说通过XmlHttpRequest对象来向服务器发异步请求,从服务器获得数据,可以是xml格式,也可以是一个字符串,然后用javascript来操作DOM而更新页面。. D7 ^4 a! z8 ~" S+ x$ G/ S" u
    3 h; y/ k$ U( R1 x' |; g
    Dwr# \/ I7 w; x* S* S$ B) Y- o
    是什么?
    - |3 n; A3 n. J& l5 |3 fDWR(Direct Web Remoting)是一个开源的类库,可以帮助开发人员开发包含AJAX技术的页面。它可以允许在页面中使用运行在WEB服务器上的JAVA函数,被调用的JAVA函数就像是在页面中JavaScript方法一样。
    / y) z- _0 ~- z2 s" s
    7 Q3 p! P/ _! N有什么?
    4 \/ c+ O& a& t  t. o/ S( V7 a  f: W它包含两个主要的部分:允许JavaScript从WEB服务器上一个遵循了AJAX原则的Servlet中获取数据;另外一方面提供了一个JavaScript库可以帮助web开发人员轻松地利用获取的数据来动态改变网页的内容。1 Y- A# w5 _, R  H

    3 L2 q1 s  Q# m
    % h3 s- b0 _6 i/ j  h/ M
    . ?7 P% M+ X0 P1 ^+ z2 A/ F能干什么?
    + O+ ?3 J) x/ Y+ f4 q7 t% L6 o动态地把java类生成为JavaScript,感觉调用就像发生在浏览器端,实际上代码调用发生在服务器端,Dwr负责数据的传递和转换。这种从Java到JavaScript的远程调用功能的方式使DWR用起来有种非常像RMI或者SOAP的常规RPC机制。3 u) c: u* C% O* m8 d: G
    - v. ^9 A& `5 u4 e0 E. Y

    " k4 o5 L1 O7 x7 y! a" u( k5 @+ m, O5 J7 x
    怎么做?4 D0 o. q% P* W% Y8 M/ i
    ① 编写配置文件' W& i* I# o8 g! d( W- X" h
    3 R: w1 z. Y7 g2 G/ g& c1 J1 R/ A& m
    web.xml
    * T; {% X& \9 S; z0 H' w% p7 v! }8 i7 J9 U
    <servlet>. n! ?9 Z8 j+ L: v
    ; i  z; A  Q, O+ E; i
    <servlet-name>dwr-invoker</servlet-name>9 C1 d2 y, X. a! x
    7 M1 h( K1 h# H1 A
    <servlet-class>
    8 a1 Y5 f' @2 V' i1 `% w; f1 W) z8 O0 v5 I9 m
    org.directwebremoting.servlet.DwrServlet
    3 @: R7 }) T7 m/ H. |, R
    " f- F8 B. w' V1 I5 H. k0 F</servlet-class>
    4 V! W  Y" n$ ^; J' e! U$ ^1 ^$ \" U; H( k" L
    <init-param>
    4 ~0 N' G) G( F+ P1 _# Y& G( G
    ( [% k4 I5 ^* w/ n& ?<param-name>debug</param-name>% Z! j' o! l3 h; Z' R

    0 m0 R. w: M: i' |, a0 z: h<param-value>true</param-value>7 q# u1 ?" m; \8 ^( c
    " u5 ?  [" ]) V( i! K/ n
    </init-param>& Y; N& f8 D1 @% l9 M
    8 _: J' @' `  `2 T
    </servlet>
    5 \7 J- Z. o* A* l7 H  h$ c) O  a( C* `
    <servlet-mapping>4 C, U. I6 ]1 ?. l6 E7 _8 J; y

    ( T/ _, Y: H6 r  m2 v* D" ^<servlet-name>dwr-invoker</servlet-name>
    , F0 f: f& \+ W0 U2 \
    / K1 E/ W* g% M<url-pattern>/dwr/*</url-pattern>
    / ]" H3 L$ P9 \- t
    0 c* Y: f$ q( D0 v5 a* }; E</servlet-mapping>
    / i% c+ g! w+ W% {8 [3 l9 ]" J- I2 r- P
    dwr.xml
    - W: g/ d, \- q; e, O% k+ H3 f9 x$ I. L$ C3 F' X
    <allow>
    ' p" ~( l9 M0 ]4 ?
    * v5 d5 J/ P9 x+ A9 l, \8 l<create creator=”new” javascript=”kc2″>
    : p, D& D9 X5 J6 {3 @' g: P( Q3 |5 t& g* F+ E' o! m
    <param name=”class” value=”dwr.Service” />
    $ I- R( I+ K6 w) v! a
    , N% K2 T# l  `8 ~' c9 t  m& \</create>5 G2 ?- f3 t& ~. ]

    * c' f3 }0 u3 `' S* t</allow>$ ^4 }# n; n! K4 V8 K( H
    " I0 D3 d. [+ i& D
    ②编写service
    # ?# j' X& P3 B
    6 s2 g) m+ A  L, Qpublic class Service {
    ( p" I  E' w& r1 N1 C+ F8 B/ M' F
    public String sayHello(String yourName) {$ i0 A" p3 o; F$ d" K$ Y- B4 y

    8 y7 V) U- u# d6 a( Y; P9 ?//可以是访问数据库的复杂代码5 \$ r2 S/ Y+ X: ]6 q2 ~7 u. W2 M. z0 U

      ~: ?7 A9 [. G4 e( d% S  ?. areturn “Hello World ” + yourName;/ R( i/ G: H3 G, a

    & }& U+ O0 U& m7 l. h$ q+ G4 e}
    : U4 }& A' s: }' h
    - _* j, n8 i' @- t, a+ x}( L2 I# I. y' s3 a5 ]

    ) k: @' _) Q: ?. T③测试DWR
    2 v8 j# I1 H$ Z6 I7 O8 L6 o6 W6 y7 K  [+ q+ O+ v) Y) I
    将代码放入应用服务器(比如Tomcat),启动。5 W9 ^+ W2 _7 p; e0 C5 X/ b
    " K0 f4 R  e2 r" y. F/ K
    然后在地址栏输入http://localhost:8080/你的工程/dwr7 |/ S0 C9 H' u! i" @: Q' f2 _+ J

    & I# ?( g+ ]7 P$ R④编写jsp页面
    " |& J; p2 ?% r9 p* e
    & G! s( {- F/ G$ K1 F% D1) 要引用3个dwr的js,其中engine.js必须要,如果需要用到dwr提供的一些方便的工具要引用util.js
    ( I/ L& ]. ?0 `2 i
    / p' G4 C' Q; p2) 然后还要引用dwr自动生成的js,dwr/interface/service.js,注意js名字要和dwr.xml配置的一样
    ! `9 v$ Q- z4 P4 \3 V& [0 y: Z
    , f8 ~. U: F/ \3 K+ P8 X3) js里的service.sayHello和java类的那个有一点区别,多了一个参数,用来得到返回的数据
    回复

    使用道具 举报

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

       

    关闭

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

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