我的日常

登录/注册
您现在的位置:论坛 盖世程序员(我猜到了开头 却没有猜到结局) 盖世程序员 > 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
    $ }% J" w: w4 b简述JEE! w# F) }+ ]% l9 m+ |5 p/ g; f
    JEE : JAVA  PLATFORM  ENTERPRISE  EDITION' L' K: f4 @' [/ s" T$ ~/ O
    ' o4 a% \( k5 Z4 f: K1 d5 k5 k
    JEE是一个规范集;4 I5 N7 }: I! z  d  \

    5 F. u. E8 o: T8 g! NJEE是一个框架集;
    : ]# Z8 ~" B7 p; _% M4 p
    ' A0 _6 X: U2 c9 t' q8 {5 iJEE是一个技术集或API集;( Q1 A0 U; X% T- U( d1 _  p: T
    4 i$ ?6 J" \* v; g' @! K1 @
    适用于创建服务器端的大型的软件服务系统. A6 ^: M! ~: ~5 O: g/ F
    1 d9 e( |, a  Z5 s2 M5 j

    , J, J3 C6 s. K" k* e3 p
    ! ?+ C* Y6 }8 D, XC/S B/S 模式; `5 r5 p7 g! s3 ~
    C/S client/server即客户机/服务器模式,客户端也参与程序的运行与计算(富客户端、胖客户端)
    7 h0 L; U$ |4 d6 z* N' ^+ b% F
    3 R* H6 Z8 z# z7 Y8 kB/S border/server即浏览器/服务器模式,又称为瘦客户端,客户端不参与程序的运行与计算% H7 l) T% _5 A; m; `$ G) P! B, Y$ K- x
    . B7 V1 M6 d* ^1 ~0 a

    ' ^0 S7 O/ e* b  v& k- S% y1 P% w! L- `: d6 J" k
    企业级应用(大规模的应用)的特点8 g: u. X' c% z; I' ?3 n  q% }
    1.生命周期长、稳定、可靠
    " U" p# n8 ?% E! k/ g( E
    & A2 e6 z3 \- u' i/ Y0 l/ X" `7 N2 E2.组件往往分布在异构的环境中,能够跨平台
    , P  C2 B, t% m8 v  s& R' @% B" s3 w
    7 [  U8 Y8 i2 @3.维护性、扩展性、重用性" I. i8 Q: Y! r0 f/ D7 U
    7 i1 i  T. b9 B, B. J" _5 G
    4.有事务、安全、线程
    3 a( g- A* H6 _- B
    . p, k" `9 f& U1 r' S! Q6 G3 V 1 \. o/ @- z4 j7 |

    $ o" H1 J7 ^: l" n( `什么是业务逻辑?
    4 j+ n. u+ s" i, j9 w; l9 O依照业务逻辑划分模块,
    ( ]! P( p! U2 D. V$ t1 z$ T" R3 G& w# N
    所谓判定业务 就是具有以下特征:
    - h8 t! I( W: D  Y* |4 J; M
    # S0 D- ^* M" ]4 i9 u: [# s+ h1.业务流程! I% ]6 K+ |9 G3 H0 G& p
    % E+ o* P8 V! V% K% {! q8 k
    2.业务判断
    . T4 {* o* k0 [$ ~1 B+ p  k: [$ }6 f: z. {( R' E; k
    3.功能组合
    - o7 Y: y- y8 |+ E5 [! o* Z, t1 |! a
    4 ]5 f$ N& G0 D

    7 ?- P" C1 f$ \0 H; k; F平台(角色)的划分. H, N8 Q0 D0 N* U
    1.平台供应商。提供满足API集实现的厂商(BEA weblogic IBM webshphere)! l! N4 T  a; O! d/ Q: f4 ]; N" W/ Q

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

    7 t+ n) ^0 t+ j5 ^# u8 d3 U  g" I0 }+ ?0 _* s
    java技术分布(设计架构 模块内部设计)9 e# A- L( u& r7 N* C) u
    1.表现层 Servlet、 Jsp、 JavaBean、 Taglib9 A& O- ?, s; q' Q* r' `
    + n. d' i& z' y2 \
    2.逻辑层 EJB(SessionBean)6 ]* I  G" P1 X4 a  g5 _0 G

    . Y; t  K/ l. I2 ?8 S! u3.数据层 ( JDBC  EJB(EntityBean))
    ) r* w% l: o+ L/ ?
    ' m7 w- m% H) ^0 c* T. f4.服务 JTA(JAVA事务架构) JTS(JAVA事务服务) JAAS(JAVA授权与验证服务)# V" H$ z. X3 ~1 N) h( j5 m0 {1 o
    7 F+ a/ J: p0 ~% }- z. J" H
    5.分布式通讯 RMI(IIOP)+JNDI 、JAXP(JAVA 的 XML 架构)( I# t0 s- j6 |
    ' K. P8 R* c* e6 k  M8 U3 M' x
    JAVAMAIL(邮件服务)、JMS(消息服务)、IDLC、JCA(JAVA连接器框架 (成))8 |$ A. Y( U6 \" @

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

    / z8 K1 F6 ~) l/ g- X7 G不能单独运行,必须运行在服务器上
    ' n! ]1 h& l% g. _8 |5 F/ r' b' E6 Y$ L. y( H" Q
    程序(组件)通过上下文来调用容器(context)
    / {& {8 w* g  R' e; |" F2 z. v* T) `6 \& j( S2 v! }, L8 l; X  s, @
    组件通过web.xml向容器描述自己,使容器能够认识组件! S7 R" I$ ?) }' [! E& H" d

    , p# T! x& R  N% }5 B) ^容器通过回调方法来调用组件- i' A  O8 D% ~2 \' I
    " i) X) p/ e$ B1 c0 @7 p
    分为两类:web容器、ejb容器
    * v' P; x$ E3 q; t: O; A7 k8 ]0 R1 G
    " a* _: z4 k/ ~7 _* f7 J$ h7 f% s  T3.服务器 : 提供容器的运行环境,提供大量的JEE基础服务
      _1 p+ E6 |& P$ _( d) ~. n
    ! k/ h4 U: {2 tweb服务器(只提供web服务)9 M8 z# S3 ^$ S( l% y
    2 `) ?# o6 U- t# c; K! @+ e
    jee服务器(提供web、jee服务)
    5 X1 Q2 P: ^- a/ Y: y8 ?
    1 p% g' F) f( q3 ^6 n
    # z; G" }9 _. r& A- m
    # z6 Z" Q3 Q) ~- `什么是回调方法
    & l2 S; H' m/ F由容器自动调用的方法,就叫回调方法。
    3 ~1 T: X4 Y0 [1 l! I# E% O
    % O# ~7 }* \$ r% @
    5 [. x9 P0 _  }% i! z5 @& {1 C  L$ [( r
    RMI远程方法的调用机制# C( Y2 o' V6 {/ {1 \
    例如:A主机有B()方法,C主机有D()方法,A 想调用C主机的D方法
    ( W& w# Y4 W$ Y2 B
    ) R. l, L* H" i. d( e& `! z( b& R8 t, l! t& I) Z* [

    / ?: A! H+ b- }& g( l: F1 @2 d* q 9 @9 N5 g% h' S9 e& j

    6 k! ]5 e! S' ~) ~4 b学习方法3 P7 @6 {1 S2 R+ _# p
    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
    6 }4 `- z# m( |1 q8 X- `8 p
    •     描述war包、jar包、ear包的结构& l0 ?8 |1 Q# K

      2 v( i& c; T2 w' g! a& O% g, ?3 s) e! X! U2 `$ y1 v. c* Z

    war-                            web文档压缩包

    —WEB-INF

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

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

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


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

    jar-                             java文件压缩包

    —META-INF

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


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

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

    –META-INF

    —Application.xml 配置文件

    –*.war

    –*.jar


    " Z" L! V9 d7 M/ N
    • 什么是servlet?servlet主要做什么?
      ; Z1 W7 d2 Q, B: u+ |
      3 ~9 j" L3 H4 J# M( G5 ~
      1 q7 [' I; |" }! w  m

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

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


    ' w+ Y  [* b! _' ]) F
    • servlet 与cgi相比的优点?servlet的缺点
      + e3 _# [0 ]% f( X* Z: X& P
      " ]+ o* V* s- V9 C

      * ^* G6 ?- k0 G- S

    优点:

    性能(线程比进程更快)

    可伸缩

    Java强健且面向对象

    Java平台独立

    缺点:

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


    ( i7 B" S- S9 z# e2 M+ ]$ O
    • 常用的servlet包的名称是?0 O0 U9 q* }- P
      ; N# e% M- H9 R! R- @- r+ n
      ' C* p( O2 H' m) s

    javax.servlet

    javax.servlet.http


    8 d; x8 e4 `4 `" A1 B0 i" a
    • 描述servlet接口的层次结构?& {. u7 H  b+ f. B$ H

      - S6 D( l& x2 ^. ?, ?- j( d/ A0 m  H& V) D

    Servlet

    –GenericServlet

    –HttpServlet

    –自己的servlet

    ServletRequest

    –HttpServletRequest

    ServletResponse

    –HttpServletResponse


    2 r5 T6 D; N% R% F. Z& e
    • 对比get方法和post方法?4 i6 |: V8 W  ^9 h7 ]$ M* e
      % D7 u  B' S5 }; T( {
      % L% j( F. K# w: k( i" D8 H

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

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

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

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


    % p7 k2 p( r6 U- y: g
    • 归类描述HttpServletRequest接口都完成那些功能
      % j% o; R" K: a' q( k
      + ?- F2 h9 n" i
      , r* C; w2 L3 G$ ^
      • 读取HTTP头标; [( k( N6 ^- _7 \) f
      • 读取cookie* A" P9 S6 v4 _# [" P
      • 读取路径信息
        , k* C' @+ i8 f
      • 标识HTTP会话。3 E$ p+ `+ X1 `0 ~# U6 Y# F
        ( e$ `/ e( P" Q2 ]! Y6 a- u
    " v* a' W, x/ K. O
    • 归类描述HttpServletResponse接口都完成那些功能" y) a/ z/ J% n% ^& J
      1 F9 h: U$ j; M! C

      0 z& t0 l' t: A; N& o2 i
      • 设置HTTP头标
        ) v3 g! b2 e; [( I9 U
      • 设置cookie; d3 [- Q3 p$ a% B0 u
      • 设定响应的content类型  D/ C- t2 i7 c
      • 输出返回数据! f4 {' z& c% u+ @

        3 j- F- t9 b# a5 D* T7 W7 u/ d
    , R) f8 e: a* Q5 Q
    • 描述service方法所完成的基本功能?默认是在那里实现的?  o/ b. g8 s* x; e7 W
      6 Y$ x, d) }: t- w; Q$ `

      . T* \6 C4 {5 r+ y; g

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

    实现:默认在HttpServlet类中实现


    4 I( N8 V: g* M; N
    • 如何开发自己的Servlet?描述应该做的步骤和每步需要完成的工作7 _/ i  c0 t* C5 P

      0 U* z- ], Z$ e% a0 x
      - _% ^  S! Y: c5 {( `: z

    1.引jar包

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

    2.开发servlet类

    1)首先继承HttpServlet

    2)重写 doGet( ) doPost( )

    3.部署

    安装web服务器,例如Tomcat

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

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

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

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

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

    4.启动服务器

    " j: _3 G" Y: @% F. R
    • 为何servlet需要部署描述?- o( p# L5 f1 c2 c. O, i, P

      , m6 [3 K( \+ a( J3 }9 [
      + b* p% ^1 d) b. j

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


    0 x7 b0 }: j4 |; V2 J# J& T
    • Servlet基本的描述应该是?请写出来+ @' y* Q9 R) x9 w) c
      0 _* p1 Y7 B8 w8 W: F
      7 j" p; V0 F& k  a+ N/ k
    2 O  \. G3 Z0 [& X: G, H

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

    : z' n0 r% T; A  j
    • 如何在html中使用servlet
      & p( u2 p) z$ S. i3 x  {

      / r' P/ M# y4 [* s/ O! S9 h
      . w, t4 j: H0 w3 |. A

    FORM标记

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

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

    语法:

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

    {HTML form tags and other HTML content}

    </FORM>

    ; L. J1 ?3 d- u% m8 h$ Q( d
    • 如何接受request中的参数; ]0 p8 F) e4 `/ }7 A

      - I6 b6 c) }- |; }% kString userName = request.getParameter(“userName”)方法
      $ S& O+ t4 K6 O% R) m( B
      3 {/ p6 ?/ T1 q9 L( ^/ N+ |% Y
    : ^8 J4 G/ K; u$ D
    • 如何接受request中header的值! ]8 l8 _% @" X0 r
      " z* @4 J4 Y# m! O
      5 @# c* B  ?1 A$ u; [

    request.getHeader(name);

    request.getIntHeader(name);

    request.getDateHeader(name);

    request.getHeaderNames();


    8 k1 t# k" N& Z7 \; b: [
    • 如何输出html& ]2 r: Y) j( Z& g. \  O
      : r: z' M% i1 A7 L/ ?2 p

      8 V& U- X* j  s3 g4 ?) J, T( c

    PrintWriter pw = response.getWriter();

    pw.write(“<html>”);

    pw.write(“Hello”);

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


    ! ?/ c% W7 Z8 U) n
    • 如何设置输出的contentType# O2 C8 P+ Y# b1 E4 _8 x
      - G* ?# N- L! O, z, k, W' U

      ; U# `' M0 J2 \% m3 b, N# g

    response.setContentType(“text/html”)


    " R1 X! S, w! I. [, {4 Y. v2 c
    • 描述servlet的生命周期?
      8 I" }1 S) k7 F# l7 V4 J' J8 ]

      % H7 |" ~8 P: P4 K  P& u) e1 ?% D' R- Q  ~' }: {

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

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


    # {. D+ W+ |! ^' }
    • 描述init,service,destroy方法的功能和特点
      9 U6 Q  k# X% P5 R
      . K. Y# f3 Q9 Y* Q. b& d
      4 n) {2 s8 P4 I! S: |

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

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

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

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

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

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

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


    / W1 C: l. X0 B; D- Z# l  o! W' W
    • 什么是回调方法?有什么特点?
      7 ]; s  H- y! R; @' Z0 p+ k

      5 y  W: L. k1 c; b: a" n6 y( |/ [
      , ~" t  H9 D4 ~, O

    由容器来调用程序的方法

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


    9 u- q8 J5 _$ g: X0 n0 J
    • 如何设置初始化servlet的参数?7 ~3 F/ ]# C7 V4 R, B* ?

      + F( u5 N+ L) X在<servlet>中添加如下配置* y; Q3 J: F2 p4 n' B6 f
      * n* r. O5 \) ?

    <init-param>

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

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

    </init-param>


    ' z  Z( c3 ~8 M) }
    • 如何获取servlet初始化的参数
      & p! b3 ?5 K- N) B" T
      ; ?" G& q5 O0 B  h. `& h

      . D+ Y0 a9 }% M& L5 h+ b

    public void init() {

    greetingText = getInitParameter(“greetingText”);

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

    }

    ; |8 ^0 G" s5 [
    • ServletConfig接口默认实在那里实现的' h  e" i. K9 ~# r6 o: P7 w
      * }! L# g5 Y9 Y; k. {% M
      9 c! b! {+ d% }- y

    GenericServlet类实现ServletConfig接口


    $ P0 |; F7 \) u  a8 ]" h+ R. |! {
    • 什么是ServletContext?有什么作用?
      7 g9 G4 P" z- S5 g
      + a2 K; [* X' \; N6 e6 [
      8 o" c# Z9 _  ]4 u4 p7 k/ I

    Servlet上下文

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

    : x- Q! N6 Y  a0 m  a! E/ q
    • 如何访问ServletContext接口?是在那里实现的?% Z& \# |, n3 t0 O) X2 V# o; {! B
      - Q4 ~, m7 Z0 v2 ~; j5 ]3 Z! B9 X

      & l: }- n1 n& X$ e* K% o2 X

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

    GenericServlet类实现了ServletContext接口。

    / y  y' {+ o7 N! S( U. E' T4 B
    • ServletContext接口的功能包括?分别用代码示例
      1 h: I! Z0 P: H6 }$ B- F1 B

      6 ~# E4 e5 Y+ d5 i- p" r( i2 n; U, K4 O# _6 }

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

    getInitParameterNames() : Enumeration

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

    setAttribute(name:String, value:Object)

    getAttributeNames() : Enumeration

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

    getResourceAsStream(path) : InputStream

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

    log(message:String, Throwable:excp)


    . y1 P% U& y, f2 E3 |
    • 如何设置ServletContext的参数?4 H2 @5 _; l! S4 g1 i* ^( |, F
      ; N7 \0 \3 l; ^+ ^: h7 Y5 \
      3 d" O# c1 s1 S5 g& ]

    <context-param>

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

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

    </context-param>

    . e" \: X$ r) `5 d3 `
    • 如何获取ServletContext设置的参数值?
      * V1 c  r0 }4 m# `: t& `8 @9 X0 j$ ~
      / Y( O% W' X/ |6 C7 ]
      $ u- L: ^" H$ |2 \! ]

    ServletContext context = this.getServletContext();

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

    : f1 z; X1 U  F8 v
    • 描述Web应用的生命周期?
      9 R( q0 M; ^0 L' J/ D& L
      # m1 f& l# `: C8 B! g) @
      / }! ~5 Z6 G; `+ O: O

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

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

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


    ( R5 b7 I# X4 K1 L8 `9 D1 ]0 n# B) w
    • 如何用代码实现监控Web应用的生命周期?
      6 v) M$ T; Q8 C$ j+ C

      , C9 q* f% j/ K/ g
      4 w- R: u& f; [/ ~4 R  Y/ c0 R
      2 z3 Y. m+ o6 U; |: }. Z

    public class Test implements ServletContextListener{

    public void contextDestroyed(ServletContextEvent arg0) {

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

    }

    public void contextInitialized(ServletContextEvent arg0) {

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

    }

    }


    . V0 s! c& u. {

    web.xml文件中的配置:

    <listener>

    <listener-class>

    com.csy.Test

    </listener-class>

    </listener>

    - g$ _& P7 l2 ~7 N. E# d% V
    • web应用中如下错误码示什么意思:400,401,404,500
      9 s! {2 o7 a7 Q7 m4 d

      + p  b4 r/ P" L! b# f+ u
      400 Bad Request//错误请求
      401 Unauthorized//未被认可
      404 Not Found//没有创建
      500 Internal Server Error//服务器内部错误

      2 M1 c4 {# x1 O
    + k2 ~/ j. D! ]  v
    • 描述Web应用中用声明方式来进行错误处理的两种方法
      % U3 L; k& x! {7 t3 e1 ^

      , ^) _! J3 r7 _  q/ J0 G( f
      . c0 L- ^& w4 S: Z; Y, M6 X

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

    <error-page>

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

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

    </error-page>

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

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

    <error-page>

    <exception-type>

    java.lang.ArithmeticException

    </exception-type>

    <location>/error/ExceptionPage</location>

    </error-page>

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

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


    # R. G2 \6 Y" O- E1 Q8 A
    • 描述记录异常日志的方法,都位于那些接口?
        v  y* h% r6 b4 w; L% U
      3 ^5 t! m9 i, C% _2 {1 E; j
      6 M8 w; g1 \$ Q

    GenericServlet:

    log(message:String)

    log(message:String, Throwable:excp)

    ServletContext:

    log(message:String)

            log(message:String, excp:Throwable)

    ( }" W3 {, Q: t6 c( R
    • 什么是会话?
      6 k9 }+ D! J4 \, |

      9 w: T& _% X) O1 x  D0 h% X( L! R/ G" B6 x7 F2 O' r; V

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


    * f- O& k2 F6 Q
    • 如何获得会话?
      6 a; t1 X2 [( z

      2 _& c2 G9 p! [
      HttpSession session = request.getSesseion( );

      ! g. ^8 D7 f5 d3 {" a* |
    5 g; L0 k# T5 C  T
    • 会话Api的基本功能?
      & @5 Q- l7 `: v- d4 f! B* Z
      2 w3 N6 K2 u  W/ k7 [# W
      9 }% J% {4 W8 @; M0 U6 T

    getID() :String! T2 g" h5 r+ M7 S) c& B

        isNew() :boolean. m; E8 n) u% H# r! m  t2 W, c

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

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

        removeAttribute(name)


      D, [8 h  s7 d4 G
    • 如何销毁会话?
      + M# \! E+ t3 u! v8 N: X2 C, H; m
      3 u; V$ j, @* E6 F( e& @

      2 u+ j' O% c5 x1 z3 \0 S6 u

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

    <session-config>- B: {8 j7 K) I

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

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

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

    invalidate()! O/ e* ^' @6 `4 o$ K

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

        getLastAccessedTime() :long1 Z, A* ~) A7 Y0 ^# n% K

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

         setMaxInactiveInterval(int)


    3 n! k; g; {& g5 K
    • 描述会话保持状态的基本原理
      ) ^+ z4 b8 m, p  k; e; d5 L
      8 |- k9 g6 L" {

      8 H9 F4 o& F/ D. q% a

    1 Z! h+ L2 ^0 {

        client server2 u1 k4 C, M, [# g

    $ t) }* d2 w' g# `

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

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

    request (cookies); D" J$ d1 l' z1 }( F

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

    . u& |, Z. V/ N! G4 ^
    • 请描述session和cookie的异同之处. R+ w+ M% ^1 D* e4 A/ P5 P! ~
      ; ^8 p0 K5 k; X: c5 y) K

      ; h1 A7 J+ S& T7 o6 F" J8 V; k: A6 S

    6 E3 W3 f2 V7 ?/ w" ]
    1 X% I6 F% w4 s9 m$ o6 O
    • 如何读写cookie,代码示例! G$ f1 V9 }7 C& q5 G8 ?

      6 W+ u0 @/ S8 C: Z1 z* w" \4 J
      : ]9 i- |7 K. X& F! x: r

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

    response.addCookie(c);

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

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

                String key =cookies.getName();# |; ]. P: s# Y$ r5 S" {

    String value = cookies.getValue(); , l8 O" F* K$ t0 L

    System.out.println(“cook”+i+“:key=”+key+“,value=”+value);( R  `4 U8 u" u- A. h5 g

         }

    ' r8 _) x: C) k
    • 什么是URL重写,如何实现,代码示例
      / j  r, c9 i2 v5 D; Z# u

      8 q7 L' X+ L5 |: O" b# z% [, H/ \

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

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

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

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


    # C# ~$ p$ y/ [! F5 e( I, N0 Y$ ]* N- F' }1 ^0 j7 {7 o
    • 描述web应用的4种认证技术
      . n6 n5 }; v* t+ a" w/ t

      + E, }# W. o- q% R! n1 ]3 u' F
      ' q! H4 ?! W5 v4 P( N6 L$ M

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

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

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

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


    # e6 s/ O. m9 s$ ?
    • 什么是授权,什么是验证?
      7 W' ]2 K- a! q/ i) Q
      9 R8 K9 L2 C+ q9 z' C( X
      ; ]" O$ ~6 H/ k5 W& k* A

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

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


    : `- ]* g9 }: p. |8 l2 u5 m
    • 什么是HTTPS
      $ n8 J6 h1 k  H8 d' |
      3 j; K2 @, t& N) l6 g( A

      9 h5 n) A$ n/ O2 T1 r. N* ?, \

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

    + H  h3 S/ D, V8 U
    • 什么是审计?
      - z6 @/ z1 E2 P
      ! Z& H8 r; _, A
      . E9 m, ^' V8 n

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


    4 v' v0 n. b' W
    • 如何实现声明性授权8 P. p, F( f% P+ l/ W* d1 e+ |

      , n( F( x. N5 u- Z3 f+ M' A6 m. r# _% c/ ]

    1、标识web资源集

    2、标识角色

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

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

    在 web.xml里配


    ; K0 M" F+ Q; b& D2 [( G4 q! b
    • 描述servlet并发问题?
      * R1 M4 w2 e) }: i4 x
      5 B+ ]& e, T# V1 a7 y! m( L9 y
      ( b3 D0 o) t. G9 P1 H

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

    7 t& t0 C; V8 b# g
    • 描述Web应用中的六种属性范围
      . q5 {2 o2 r7 J( g' y8 R2 z

      * v6 q3 z- ?' W( T! h! b" a1 p8 h6 O

    局部变量(页面范围)

    实例变量

    类变量

    请求属性(请求范围)

    会话属性(会话范围)

    上下文属性(应用范围)

    ! q" G. [2 Z. s: a2 G9 Q
    • 指出上述六种哪些是线程安全的# a; G# q8 Y1 x- ~9 n8 o
      ' {; l% M1 o4 {+ s2 z8 `

      1 K7 t2 Z5 v7 j* P

    局部变量和请求属性


    * v) X: x7 V; g( S. a
    • 什么是STM?如何实现?
      / D/ a6 F/ f2 P6 {$ ^

      # P  L4 |: K! i
      , m* K, @1 R1 F% }5 ?

    SingleThreadModel接口

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

    2 {8 g1 Z/ O( x! m, z
    • 如何实现并发管理?' i; J0 s+ n6 ~+ e* e

      1 T/ l5 ~6 g9 `3 Q
      8 G; L( l* [7 h. l9 l1 a6 _

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

    使用synchronized语法控制并发

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

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

    # B2 k/ a  [1 l# Z! _
    红红火火恍恍惚惚
    回复

    使用道具 举报

    admin    

    1244

    主题

    544

    听众

    1万

    金钱

    管理员

  • TA的每日心情

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

    [LV.5]常住居民I

    管理员

    13#
    发表于 2014-12-03 12:45:45 |只看该作者
    Jsp+ _& g, Z4 Y7 J3 v
    什么是Jsp?, _6 ~8 |$ R  u% g) M" c
    Java Server Page    结合java和html在服务端动态生成web页面的技术" [& S; O# B. Z$ s* U
    ! S0 d0 \3 d0 d0 S1 `* U
    7 e/ A9 b0 n& {& Y" U8 I
      S" Q0 h  b9 T2 F1 c
    描述Jsp页面的运行过程?
    + m/ i& z$ G/ T& a4 q) Z第一步:
    3 j4 d$ Q8 k  w8 ^. i- s, a4 h: m4 g, Z" ~# @, g* \
    请求进入Web容器,将JSP页面翻译成Servlet代码4 s" i- |8 Q  \$ ?# F# B

    ) `- Y9 G3 \. ~, d" k& @/ J. |5 i第二步:* V& Z" }2 L1 p5 }; F: P
    # h" T$ \8 O0 {$ \9 o7 g7 t
    编译Servlet代码,并将编译过的类文件装入Web容器(JVM)环境, e! _3 I  m" o$ @- m

    6 }3 t- L5 E9 ^6 p3 ]第三步:! k$ e7 I9 @. q4 X
    , ~" v: H! a$ A: @* N+ v$ b$ N% C1 X
    Web容器为JSP页面创建一个Servlet类实例,并执行jspInit方法2 ?, g! i8 |7 }* F0 B0 E  B
    ' j$ r. K! X) K5 C) C$ Y
    第四步:+ h& N; {- M3 e- Y3 y) w) L1 c
    ( h4 m" N) L2 O
    Web容器为该JSP页面调用Servlet实例的_jspService方法;将结果发送给用户6 M" b* d; u7 S

    3 S, x; K3 Z$ i( d
    $ u2 o8 Q5 w& T/ s2 o2 @) I. r$ F# e) P% J. s" q0 Z3 n+ ^9 i
    描述Jsp页面的五类脚本元素的功能、写法、并示例
    4 b& z  U- C8 g0 Y5 A& y& N注释 <%– –%>- M: P7 x! n! M0 c8 d6 P% _8 |) x
    5 `* V9 f! g4 ~+ b; k  `, ~+ \( K
    <HTML>! y3 W& A, A" p
    / D8 x9 Z7 v$ E3 E0 h& y: _1 ~
    <%– scripting element –%>
    . T. K, i& I- `
    & N$ O! g' ?' b& i3 M, @& s% T, F</HTML>
    5 u( G4 b1 c# [5 ~, V; X# ^0 B8 Z- K( }; r
    指令标记 <%@ %> 指令标记影响JSP页面的翻译阶段) g; |  S2 ]8 ^% D0 L

      ?* ?! l+ @) F& S<%@ page session=”false” %>
    * o  \6 T1 r' E  z7 v; i% s
    1 U) b$ q2 s( [( s- X7 u  q' z6 r声明标记 <%! %> 声明标记允许JSP页面开发人员包含类级声明
    3 z& N! ^; U% Y/ s5 ^. }. n4 \9 l, T0 I, m0 B7 l) h/ }
    <%! public static final String DEFAULT_NAME = “World”; %>
    + g2 m1 t2 W# o  ^0 L( y4 @3 }8 ~' p
        脚本标记 <% %> 脚本标记允许JSP页面开发人员在_jspService方法中包含任意的Java代码4 Q' a# l- z* `+ v; |
    7 ]  B' A* o: i- S6 a6 q
        <% int i = 0; %>7 L5 A  b7 |, Y+ K9 I: U; g

    1 l- a: g, {) |- b- J/ f表达式标记 <%= %> 表达式标记封装Java运行时的表达式,其值被送至HTTP响应流 <B>Ten is <%= (2 * 5) %></B>: _' V1 y$ ?  R) A: ]1 f8 X. z
    ! i2 s* L$ X4 }' @1 N

    % _- R- h8 Q1 ~% Y+ |# M. k0 R3 p; b' r6 B3 b
    描述Jsp页面中的注释种类和写法! I# x$ o# A3 E5 N3 x! y; s
    HTML注释
    & u4 o2 ~. I6 S
    ' A% H9 a' `4 ?1 V# T) W' y( ?<!– HTML注释显示在响应中 –>! ^9 o* q2 G8 a# ~8 D* Q- g$ ?( Y

    , [+ b5 ?( N4 C- g* H& ~JSP页面注释
      E$ B, d, {' y+ ~( r
    - n4 l% q( h7 V/ l, c2 k- g$ G<%– JSP注释只在JSP代码中可见,不显示在servlet代码或响应中。–%>
    3 r! V! m- O* J1 z+ r5 f8 j* R* K: g- [0 U# H6 z
    Java注释% L; t; R- F/ P( |2 k0 K
    3 ?7 D+ W) E9 Q+ e- a8 U8 O9 Y9 R) w
    <%: o; ?+ M3 ^6 I1 j- n1 g
    ! @6 ^1 s5 r9 g
    /* Java注释显示在servlet代码中,不显示在响应中4 d( i/ j- e8 g! C) @  W$ |- W
    7 }' y, n& T; H
    */
    ( J  P( d8 x( R4 ^3 w6 o# u8 M( S1 X9 H1 J; P' v# c3 R
    %>
    " S$ L9 k2 J+ a% m. Z
    - m7 h0 ^" [" |8 ]( m) ^ $ Z" ?( T# r) w1 h. D/ N6 O/ T1 i

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

    0 T/ x' Q7 a: u+ g  |* k* N) G- c
    9 O: G5 }$ ^5 W( H: V' n8 }描述Jsp页面的声明标记的功能、写法、并示例
    5 B2 U: \9 v+ b  R4 R; a声明标记允许JSP页面开发人员包含类级声明
    ' d1 p3 m" P. f( a7 }/ C" c
    . H8 t7 r" {, O% n% J4 }0 a& S写法:
    : _" ~& w! |2 l4 D- {/ T( D- Q  K9 W' x
    <%! JavaClassDeclaration %>
    , H( c5 V& n: v+ O8 D+ F% P5 ~8 s7 M9 g8 G! M, R; U
    例:
    + q6 ^5 o5 I% k: @/ W6 k! Y' O% G- @) w% A+ X" O0 r
    <%! public static final String DEFAULT_NAME = “World”; %>( A) z7 O, c  W7 H4 S8 d
    % _+ M) \/ }9 \  ?/ U- y( u
    <%! public String getName(HttpServletRequest request) {* i5 Q. N1 ^6 F7 k! q0 z" X
    / C; b4 \, {( l, }6 N
    return request.getParameter(“name”);
    % s( r2 h+ d" U5 d: o# W1 q/ k# B
    3 q' l; ?( H5 a' ], a- H( K6 M}
      a" v/ d! v1 }7 o* Q
    4 ]* r' v0 R7 t, A# `3 Y%>
    , M# N. A% o5 ?- ^. \  R+ Q$ r# \+ P' L4 y8 R' J
    <%! int counter = 0; %>  w. V8 C  D4 u6 `

    / ?1 p7 n# u$ z; C! X1 q4 v ! j: X6 e3 |& |9 _: I' l8 x

    2 F: c; O3 F1 x9 W1 q# F描述Jsp页面翻译成Servlet的规则; N* O* a5 L5 Q2 M
    jsp中的注释标记被翻译成Servlet类中的注释; Q, f: N7 ]9 p7 t# V
    8 }- w. w1 h9 p
    jsp中的指令标记被翻译成Servlet类中的import语句等
    1 l8 d9 a/ V, ]. j- J8 b- b$ L5 t' {
    jsp中的声明标记被翻译成Servlet类中的属性# M; K$ s" |4 \
    # J2 J4 b+ ~) E, T
    jsp中的脚本标记被转移到Servlet类中service方法中的代码2 T9 U3 j+ F/ z. i$ l2 _( e( \/ h7 {
    + ?0 o( t& w' c  G& ~
    jsp中的表达式标记被翻译成Serlvet类中的write()或者print()方法括号中的代码
    . c5 {* j, W( q5 F4 j
    7 C7 Q+ H# h  ?/ t* w: l1 `! T ! p6 b4 o( Z+ ^
    9 X; e* o, U# ~$ [" w. w2 V
    描述Jsp页面的九个预定义变量的功能、用法、并示例- d( t/ k+ C4 d
    request 与请求相关的HttpServletRequest对象' t! M" K* K; S$ |( H/ v
    % W. H9 I: r; Y# h
    response 与送回浏览器的响应相关的HttpServletResponse对象
    + O8 T/ v& `( E6 g8 w: T% r8 M! B; H  i5 U& _- u
    out 与响应的输出流相关的JspWriter对象7 F+ r" i& N2 t0 k

    3 T" G8 f+ J& U$ z    session 与给定用户请求会话相关的HttpSession对象,该变量只在JSP页面参
    ( v5 D' d: F6 y5 ^
    # _2 P0 ^( |" s) k) C/ M与一个HTTP会话时有意义/ P% u# H, _6 k
    . ?9 J% ]2 q8 d5 G7 |# u2 ]; [
        application 用于Web应用的ServletContext对象- y/ m# v, P0 X0 [" J* K# b( }
    7 ~) A4 R! g; g$ z! i- s
    config 与该JSP页面的servlet相关的ServletConfig对象
    ( s5 {  i5 Q% L& r2 r
    + t' t% \4 a# y4 J- epageContext 该对象封装了一个JSP页面请求的环境$ R) F  P+ L) Z9 B" h

    . |7 L# z: `& |. m/ m0 ]page 该变量与Java编程语言中的this变量等价
    " F+ A5 \9 J0 E0 i+ c9 V1 v% P6 h' ?1 `$ K* e# [5 {% s( J: h
        exception 由其它JSP页面抛出的Throwable对象,该变量只在”JSP错误页面”中可用) F# C2 P7 p# V  d" d+ V
    7 {! E8 T3 ]! v, R8 a0 h
      S2 T  ~9 C7 N' \% c

    ) ^/ T% l+ W* Y1 c: |page指令的功能,写法、并示例,并描述它的如下属性的功能和用法:import、session、buffer、errorPage、isErrorPage、ContentType、pageEncoding
    ! `" o0 |8 r1 z" a7 g* X+ fimport import 定义了一组servlet类定义必须导入的类和包,值是一个由! G) {- E2 r1 B  Z9 e
    0 Q( r8 p. A4 `  ?$ T- }, U
    逗号分隔的完全类名或包的列表。
    - n. Z; E) `4 O! y/ N8 R( R8 ^9 e. O2 H' S
    session session 定义JSP页面是否参与HTTP会话,值可以为true(缺省)
    ) `/ Y# X: m% ]0 S$ ?* K2 z. ^+ r6 q5 }: _5 ?1 T- k$ E" ^
    或false。
    ' S; b/ ]3 w- P' x- f2 j
    6 M2 e3 q' F5 a  jbuffer buffer 定义用于输出流(JspWriter对象)的缓冲区大小,值可以为2 R  e! I3 k) V& p; \

    , o) T+ W& E: T, ^! Wnone或Nkb,缺省为8KB或更大。! x: Q! A# v" h4 R! Z6 O& r3 w
    ( a6 i5 R/ _: K; u
    errorPage 用来指定由另一个jsp页面来处理所有该页面抛出的异常6 L. H: D  e  B3 T) ~. `! X$ h9 q

    + K+ _7 i8 n  ?0 B9 b# ?3 ^isErrorPage 定义JSP页面为其它JSP页面errorPage属性的目标,值为true或) j8 ^6 ]! L& Z& A; X; K5 u  e. y

    + i- G1 M: ^; ^2 Xfalse(缺省)。
    1 ^9 J* [& k# q/ v4 ~: b! u6 {
    - d# k0 j7 U# x6 ?9 n) y. XContentType 定义输出流的MIME类型,缺省为text/html。
    * q4 l" c0 r( [! l4 O( V" A) Y( \" X/ b! D; ]
    pageEncoding 定义输出流的字符编码,缺省为ISO-8859-1. ?' @" l% l2 u& k
    1 e8 d8 P  @, @; x. I5 m

    0 w& b" p4 s* |9 E# S. C3 c1 P+ w+ c3 c8 D& y( F
    描述MVC各部分的功能?MVC的优点?MVC的缺点?. ^; j6 V2 ]; V9 ^
    MVC各部分的功能:( V4 L  e7 X6 p8 b+ N

    ( I  Z) P! X' n+ h" C! ]Model(模型表示企业数据和业务逻辑); }  T4 E: ], o$ z

    5 p. A: T* O" R4 M封装应用状态. k8 U3 I: j6 Y% n

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

    $ o6 G% B# R2 l8 `. B! a; T3 O4 f选择用于响应的视图
    , c( H+ i) B5 z7 n  J
    0 J0 w/ e+ Z' qView(视图是用户看到并与之交互的界面)
    , m. `8 N* }4 ^! A
      b$ \6 w; F- Q  ^/ j& ]产生HTML响应
    1 n  t/ z& w5 `0 u  c) v. [/ n2 [" G( I# _1 C' {
    请求模型的更新
    & Z1 \/ t$ U, L; ~  l
    * a  y' w7 T$ ]+ L6 ~5 o7 i提供HTML form用于用户请求
    % v# P# ~" f/ H, z! x8 T4 H& U( s
    MVC的优点:- w/ o8 K+ J6 E! ^; k3 |& {, T
    , ?0 s+ e8 D/ G) e
            低耦合性:视图层和业务层分离8 a0 D1 K5 M2 V& W- V8 R4 `

    / R* R' z& z! A高重用性和可适用性% Z' I0 W) f2 b* }+ S8 d% [5 Y

    . h2 E8 s5 \, n较低的生命周期成本- d- e% R) R2 h$ i8 `# t
    3 `) K" M; E$ J* Q2 V2 p+ x' N% p
    快速的部署$ R: ]/ K* s8 C# H7 C/ q

    + `3 ^8 |7 F- y% C7 r/ L" n可维护性
    ' x/ Q: ]4 j( Q& @$ A$ H' M$ }+ {
    ( N( R! M) l5 i' T( c) I有利于软件工程化管理& i6 n2 H2 R$ r9 I
    : A/ @( c4 M, a" |( L
    提高软件的健壮性( g1 J# ?, G) Y+ S/ ]5 f1 E9 d

    " D" o2 \5 }% wMVC的缺点:* s) y! y) I# \% B5 ?) D( S6 @
    7 z5 k  T$ U1 E" ?& c
            工作量大,增加工作的复杂性,MVC不适合小型甚至中等规模的应用程序* E4 Q: a( y- G, ^3 M- i3 T3 d
    : U3 J6 ~# b* p4 R& q- O4 D" l
    ) ]5 I4 o& F* ?- R

    " q, s4 }; @& J4 _4 @什么是Model 1结构,以及结构中各部分的功能
    ) W! m! ?: b1 z1 ?8 B结构:jsp+javabean
    , K9 g& t! m0 N" F# D8 r# D
    4 M& J6 `  \% _/ M# V3 d$ BModel1中使用jsp来处理web应用中的视图控制部分
    . w; K0 Z* _- @1 U* V4 B4 o$ j1 n; |8 C4 ]: U, p
    Javabean收集参数
    % M1 O9 e% r/ P+ ^1 Z1 o1 }. i1 s3 }/ V- G: J7 N% c& u4 p
    6 y4 t, }0 q2 f! Y

    / M1 P0 p" p, {7 S' I# f什么是JavaBean?9 F* t! o7 A7 Y+ y
    用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包,并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。& N  l/ E# L: V2 W

    6 w3 b+ D- Z: r: L+ y, a( H ! B( k8 O/ }5 C5 f' Q% R4 e
    5 l) t! F5 W$ J# D0 p: \
    JavaBean的规则?, k- y9 G! [+ f9 ]
    使用get和set方法定义属性$ ?+ J' e* j7 D# z
    ) R+ x1 B% D* V2 |" W
    一个无参构造方法  b9 q! n* y- P

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

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

    : S1 ~. ^6 R+ Rjsp:useBean
    0 Q3 m5 |+ K6 h& z4 k, [7 u0 i& q4 ~# M9 ?& w) ^
    jsp:setProperty
    7 Z8 V/ }8 T$ ~, c6 h$ m- ?- J! E; @/ z2 Y, R
    jsp:getProperty2 v% `; ~# X8 ^4 Z; I
    3 U7 N, v+ q6 s8 ]- v5 Z! o
    jsp:param! d; R3 y9 {9 c  V, ~0 Q5 c

    ) [. u& ?2 _- C0 Y+ Bjsp:include) ]# w7 ~& V5 z" C8 U
    6 e+ Q  |1 T, s3 I: K
    jsp:forward
    % j4 y* V" A7 r( w& P7 J
    + u( n+ }; L* C* F8 V3 {
    + `. [# R) C6 z4 U' ^( @5 b, ]
    7 |' r2 o. I0 [8 a用代码示例如下标准动作的使用:useBean、getProperty、setProperty
    . o# [1 N: F9 p+ I<jsp:useBean5 D% j- V8 N# t0 V5 y
    2 e: D$ S# o. h$ J0 M+ W! u
    id=”myForms”% H! l9 W* b' O
    + ~8 Q! y' H% f. d  Q" ~9 V. \/ B6 U
    class=”com.base.mystruts.forms.MyActionForm” scope=”session” />
    3 c4 p! T( t& Y
    4 W; s, m/ p! L. z2 Q  Q5 t8 C& R    <jsp:setProperty name=”myForms” property=”name” />; V: Y* O& A; N$ u8 o8 m
    / r% r' ?. {+ {$ k7 v) J6 N
    <jsp:getProperty name=”myForms” property=”id” />
    . o# F8 H; f/ u4 i  Y! \4 m  ^9 Y
    ! Q7 O) i* J& @0 j

    : ?2 w7 |6 F# P" g% m+ k描述说明Bean的四种scope2 }% g5 H+ {) e' ]6 \8 k
    page
    # W. h9 F" ?# o. X/ {! g# c- f* _$ x
    request
    1 o4 A+ @0 r8 W% }
    " ^  k# [: h: X, bsession; Q8 F$ t6 u* z" J3 {
    6 B% q7 k* v8 m/ e; A- z
    application
    ( z/ y# T2 ^. r, Y
    3 p6 Q3 a/ T- P0 u5 I. s 7 c0 \$ E9 K# [: C8 @
    9 x# K; U0 `& h$ i& X
    描述说明页面上的字段和Bean中属性的对应规则
    * A* l. \! m! vid 指javabean的变量名* ]0 I% ~5 w6 q2 z$ j2 R

    . G0 v! @. {1 Z; R# _6 P! v3 ]% dclass指javabean类的全路径
    % Y: n% g- U' Y; g5 a* y: z
    ! a' ^/ [; e& {$ Oscope指javabean的应用范围2 d7 _5 S. J: m1 ~' h7 R
    $ J6 n& N! Y0 ^. h
    name指所用到的javabean的变量名
    , O0 b. A  L4 Z2 Y# ~( `4 i. m
    " U$ f: \2 G) A. A7 I    property指javabean中的属性$ O8 o$ l% J5 o' f  ~$ |; |
    , r8 O- K$ e& H2 @$ d4 j: i

    ' x- u8 E4 n& ~, l9 k; h
    - a) f$ k( L0 A$ P8 H4 U6 n描述useBean动作的处理过程0 m( I: t2 G* x( T4 q. [
    使用id声明变量
    ; I: a, z: p! S4 N8 |2 @+ s- ^: b! }
    试图在指定的范围内查找对象* l$ E$ c% `0 F7 W1 l/ G. {! ~
    0 {2 h3 F6 b( n, N4 J3 _% n
    如果没找到
    ) Z7 U1 }& w7 K& U. m; k
    - _: N8 o; E, ~* y" l% }创建一个类的实例* @" F# r8 Y( |/ K# W

    + {7 W# |) W2 t& y: m7 T2 b执行useBean标记体初始化对象5 k2 t! [& A' Q. @
    ( I, o! `/ l* X' J# T# g) N& V  A
    如果找到* [! Q8 Z. @8 [/ ]' }
    % }/ x8 b9 \& i" F+ E4 b% W& a
         将对象转换为类指定的类型* t4 L' {# c# i$ M+ q6 c0 z
    - [3 A5 S6 B* x/ n
    8 |) x! T! ?3 j" \
    1 |% w8 ]) y/ d/ |
    描述forward动作的功能
    : {+ B& j4 n, d使用脚本代码处理请求时,可用jsp:forward 动作产生一个不同的视图,
    % Z5 y+ Y* A6 e
    : Y5 p, p4 N' K  Q使用同一个request:% s4 |9 N; V4 N# M; u) M6 L
      Y9 J. v( n. P

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

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

    * O6 h# a- ]4 S1 @$ r$ T. S' ^存储请求(或会话)范围内的域对象
    5 g% t1 K$ q+ ^. H
    / r# h  C* x) Q3 l7 S1 e选择下一个用户的视图# L) L3 y+ `- Z( u
    - p6 q8 h/ m" J( N5 q+ b# G6 U
    JSP页面视图:, k5 V4 z( s. m; B  U: v$ H% X/ `

    ! N+ Q/ c9 U/ O/ w, U) Z  c! b使用用户界面(在HTML中)) U) M' |. J2 W/ _' o" V
    , \6 w( Y  S* o1 X
            访问域对象: s% g9 X% t/ o- g% g2 x
    ' Q( p: a  e7 T: }/ c
    * d6 t. J/ I! p- k( R, Z

    ( p. ?' g# G& t如何获得分发器?分发器的功能?0 E+ X' Z& y( W4 n
    上下文对象中的分发器:2 c2 [& ~. G) D$ a' ?8 ^6 ?7 f
    9 E: l6 @; h) C" g- \9 x) T
    ServletContext context = this.getServletContext();
    . H/ {3 e" l3 U1 y4 |2 n! ]. n9 o; _' R' X" }3 d7 L$ ^; B3 o
    RequestDispatcher servlet = context.getNamedDispatcher(“MyServlet”);
    : `$ C) G7 F% R) F  M! K' u4 ~* o- [! K! H
    servlet.forward(request, response);
    1 M. w9 T) ]: F& B9 j+ h5 K* k4 c% W( O% W/ Z
    请求对象中的分发器:# U  G: w# L3 \

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

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

    3 t+ n: E, U" ]0 c  Adispatcher.forword(request);
    . n9 H. P$ ?" M& }& K! o. h) x% \4 _2 V8 v. R
        特点:保持请求的传递(上一次请求中的数据,在下一个请求中仍然可以得到);
    , u. e$ @* {* |% h: \/ M
    5 H3 S- O; I, D  S, o        转发的页面只能是同一个Web应用程序的其他Web组件( X: {6 X2 a% F* v, ^, U* x
    * d* ~% h- W5 s4 w$ Q& z% w
    使用重定向跳转页面, i' c- T9 w2 B' B0 L7 q% t
    response.sendRedirect(“url”);
    , p( Z5 A: D- C- T. m. z# }0 O9 E# [* q  c4 U  K  A1 @7 r% |. z4 w5 K
        特点:产生全新的请求,(上一次请求中的数据,在下一个请求中不能得到);' @2 L$ V9 Y* u: U" G! M
    - \4 e  W2 B! b6 p* g
            重新定向的页面可以是任意的URL
    * W/ \, c" f5 ^/ i' w6 W' g# P6 X* G7 f5 V4 n7 m7 w
    3 S. F2 P: c8 t7 Z# z. n

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

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

    * X! S$ F) Y/ _3 T1 a$ e: d2 O包括:/ L1 U$ f7 t: m2 H' Y3 K

    " i+ R8 [) C* K' F8 V7 B一个标记库描述符文件(*.tld)
    ; u/ d$ d1 ^8 u5 ?0 ^8 _. `# u8 M3 x5 K- D1 T' ~  U
    所有相关的标记处理器类(*.jar)3 |! U2 e" B9 ~" \" A' o

    7 m* B/ m1 Y/ Z4 N6 Z % g2 F+ a. k9 T
    # e# D/ n6 B1 ^% k9 J  Y' J) {
    描述使用自定义标记的步骤,以及每步详细的工作  d& y. Q# y# Q+ O2 z: `3 F
    使用自定义标记前,要拿到.tld和.jar两类文件/ {4 c5 q3 B- _( S# D: v8 M. C; C! I6 n
    ( R3 A, e, U5 t7 v0 `7 C! Q
    把.jar文件放到WEB-INF的lib里面。2 {$ z7 G' n: E; A* b4 l
    把.tld文件放到WEB-INF根目录下。
      S# R! Y8 k9 Y/ k% M6 f在web.xml中配置。: S: V: b% i/ a2 ?3 U
    <taglib>$ H" ~/ ^2 f- F, W* r% p# c* R0 N
    * t+ O1 ?9 K/ S. L4 H7 q. N
    <taglib-uri>http://java.sun.com/jsp/jstl/core</taglib-uri>
    % v3 R" r$ O; l; y% j6 c1 |/ v+ y( R
         <taglib-location>/WEB-INF/c.tld</taglib-location>
    / c' ?3 J5 @8 ?0 F2 s6 a% }& M0 {
    ( t* a, f$ O/ |( n) U- Y, @6 B: b, ^</taglib>% N/ h6 q3 r1 D5 I' [
    ' ^, G8 u7 o3 `+ `( v/ {) F
    在页面中引用。
    ) O+ a* F- c% A8 L<%@ taglib uri=“http://java.sun.com/jsp/jstl/core” prefix=“s”%>: m+ Z: s& ~3 E+ B
    # E& d) ~: F& g' ]* Y
    uri必须与web.xml中的uri对应
    8 Y1 m0 C) N2 {/ w% B) u9 p' {$ M" T( {0 n1 ~" p
    prefix是前缀,用来区分是哪一个taglib) {) O5 D3 S# R: z5 l5 c

    ( \" t8 O, r- d使用标记4 d. z$ ^' d7 p+ L# i
    格式:<prefix:tag名称 属性>% y5 w3 O# E6 m3 K. V+ q
    1 N6 N3 k. e* T% k% b
    <s:forEach >
    回复

    使用道具 举报

    admin    

    1244

    主题

    544

    听众

    1万

    金钱

    管理员

  • TA的每日心情

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

    [LV.5]常住居民I

    管理员

    14#
    发表于 2014-12-03 12:45:59 |只看该作者
    在tomcat下配置数据源
    3 q% o. P7 ^7 v2 t5 `1、服务器与数据库的连接
    $ j; R( L4 w/ G% p& W( ^  I9 b: h5 \
    配置server.xml文件0 c0 ^% K% K) c
    * a) H+ S# W  E5 F: c- Z( r! n
    1.oracle
    $ ^8 ^9 P% f# k3 Z% |1 H
    " S- g# U$ T% a6 |8 _; }6 L<Resource name=”jdbc/company” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”0 |; Z7 L, h( ~1 f7 [( f

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

    ; Q. G8 m: R$ E0 ]+ [0 NdriverClassName=”oracle.jdbc.driver.OracleDriver”$ y6 _* |, |3 ^. u  F, S  `
    ) R8 [  }2 ^- h) H& ?
    username=”aa”0 I/ T# G; t- c! a( o. {- i
    * N- a& u, [. q) I
    password=”aa”1 R) N5 w7 }$ q8 Q8 n1 L

    % }6 X9 [3 R5 y6 S9 Z1 H+ }maxActive=”50″
    " r; O; z  j* s/ x, \, J; ^
    8 [: t+ u- Q- `+ tmaxIdle=”10″. I& B' F- e- Q( x* k( f. R
    , |  ]8 s6 m( c  o- B* S2 A2 p7 F9 `) L0 f
    maxWait=”-1″
    3 t+ R. q9 G+ x4 y9 o3 N
    . {7 y( W9 [2 g2 {; v/>
    ' U, q: b6 O3 Q) x% o- Q
    4 G6 q1 a2 j5 q/ }" ]6 @& n2.sqlserver
    1 o$ j5 s: j  I) N  ]' t* @
    3 c/ D$ e8 T. `8 g* G/ Q8 R<Resource name=”jdbc/webpage” scope=”Shareable” auth=”Container” type=”javax.sql.DataSource”
    ' @) c" P8 r7 k2 e& G/ Z  c% K3 k
    , X3 s, }- n  K3 ^7 ]        factory=”org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory”
    8 T9 k8 \3 J  Q" D
    . w3 [+ S; ?  [) D* b* Xurl=”jdbc:jtds:sqlserver://localhost:1433;SelectMethod=cursor;2 ]+ R0 D1 K& f3 Z, g& R1 Z6 d" H

    * q8 l' F- f6 O+ {& ?$ F& yDatabaseName=webpagetest”+ r7 ^  A. [( h) I$ h7 ]- C

    * ~- v3 X, T0 J5 m3 y+ O2 qdriverClassName=”net.sourceforge.jtds.jdbc.Driver”
      ?  U- [- Y8 w5 k$ ?  g7 [$ b, x1 E6 t; h7 F; i! ^
    username=”aa”
    % Q/ {; _  n# v. E, M! M. B5 D9 m- c- {$ {( r6 X2 w+ a
    password=”aa”/ c4 y; h& @8 p
    # V& c, o$ ]/ {/ T* t
    maxActive=”50″* z) C2 P" g/ g' f; b' a9 b+ o
    : D9 b' `7 j& |8 c
    maxIdle=”10″5 y6 u6 B; Z6 o+ ]3 n1 D$ I

    ; v1 Q. u6 u$ ZmaxWait=”-1″
    4 Z7 V, M& @9 ?3 @) @+ _" D! C
    # t" V* A* c' M9 X' C* f/>$ q& o2 P: y" m
    ( N! `4 e. w4 g" F/ T
    2、配置自己的web应用的xml文件. K; S2 x, S9 c

    ! S5 m/ V5 V8 X4 ?6 N; E 9 c  m3 \9 R  f9 k0 O7 \/ r
    / F- [$ Y! N6 D
    <Context path=”/eb03web” docBase=”F:/workweb/eb03web”
    $ c$ e0 z, p9 n  ?- V- ]% s" W+ K  _$ Z: s) n$ \& q1 J
    privileged=”true” antiResourceLocking=”false” antiJARLocking=”false”>- Z7 a9 Z4 s  R9 T  ~& K, D

    8 o' y! M0 `$ T8 V1 i<ResourceLink global=”jdbc/company” name=”jdbc/company” type=”javax.sql.DataSource”/>) ^8 J( f( }! z8 J4 J

    2 c0 l& D5 t+ s. r. t</Context>
    ( O# J! ^. C- s" M: W% w$ s0 @
      _( A  r/ k8 {, _5 m 9 i6 L7 Z  c% f) M
    ' }# I! }# d1 y. p, m7 A
    3、配置web.xml文件! J2 }7 `# B8 Z7 o" G

    3 q0 \8 a" E6 o9 J+ t& l, g, `与服务器建立连接6 E' j3 O! ^9 J$ K
    ( w$ W' V4 _6 y! n4 J% n# g
    <resource-ref>
    % d+ }) K9 m$ L% J5 B
    9 n& b8 @+ P+ x* G<res-ref-name>jdbc/company</res-ref-name>
    ) q6 N' n6 s1 m9 ?$ ^# ]1 C/ `! ]& C3 E
    <res-type>javax.sql.DataSource</res-type>5 K$ S( ]) p4 E$ v
    & D1 `& c% {4 _, f# m
    <res-auth>Container</res-auth>/ T+ d  {  ]1 k2 @& `8 n$ V
    7 e; J  L$ h+ g$ `+ l( t
    </resource-ref>3 T% t* _1 V7 q& q; o* n& ~
    ; n' i- u# \6 D6 m" j
    4、在应用程序中不直接与数据库连接,通过DataSource连接池建立连接
    , n0 O# @  S& u+ |9 n' P
    1 Y9 Z) \. Y) s0 E7 k; E//1.在程序单独用时设置系统的属性,在tomcat下可以不用配置,
    & F4 o( b4 M  J+ x% c5 f
    7 W% i1 p% J  A4 A7 f$ ~6 FSystem.setProperty(Context.PROVIDER_URL,””);
    1 C# p) [8 j" u# y
    ( I+ Q7 Y; P; YSystem.setProperty(Context.INITIAL_CONTEXT_FACTORY,””);
    2 N# `7 L9 i. j* A  a% y: V3 h  A( m3 q1 D
    //2.创建一个上下文对象# C( ?, z. j0 v7 O: j0 r
    # k) n% c; D' t5 d9 r1 y" a
    InitialContext context = new InitialContext();
    # J9 O9 s* b) U; K1 q, B
    . @$ U, @8 Z3 ?1 p  k//3.通过上下文对象在连接池中查找DataSource
    5 ]# H5 U/ p2 [7 ]- \
    * {- L$ k* n; \! \" yDataSource ds = (DataSource)context.lookUp(“java:comp/env/jdbc/company”);0 D; V5 n) x. Z7 B; u! g9 S( ?
    . ~8 o9 U0 s  w, Z
    //4.通过数据源建立连接/ J% T2 h# u+ `5 [

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

    使用道具 举报

    admin    

    1244

    主题

    544

    听众

    1万

    金钱

    管理员

  • TA的每日心情

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

    [LV.5]常住居民I

    管理员

    15#
    发表于 2014-12-03 12:46:30 |只看该作者
    ORM对象关系型数据库映射! O3 @" n) W3 j; ?7 {
    (Object Relation Mapping)
    8 t' W, n0 j; S2 b
    / D6 g6 S4 _9 ~; f' Y一、映射的特点
    / U0 u  ~7 p) f' |; y, B) U1 \; D. M6 _/ b: t, H! p6 _, b( ~7 a
    1.一个对象可以对应多个表
    9 w. [  M$ N7 z& r$ p6 [2 O. Z  ]) s$ }& S
    2.一个表可以对应多个对象
    1 p  K# y8 c4 l' ^
    ) h) ?! d% C8 E5 p3.对象和表的关系不用完全对应
    ; {  r% a; i7 o# v8 F, l' q- h' i) H9 b! s4 m
    4.对象的属性的名称和表字段的名称可以不同
    ; a# S* s' B0 [+ j+ |2 a
    ( ^* k9 N, x8 ?- r+ g, a5.类型可以不同,但数据类型之间可以转换) {3 m1 ]8 z0 f4 B1 a6 ?& E# e+ d

    . Y$ X2 w/ W# }6.对象中必须有主键,数据库的表对主键无所谓% J$ B, q% X: u8 j
    7 e( u* i* o* |, g) ^2 h
    7.数据库中有主外键关系时,对象中可以有,也可以没有& p5 g; X9 \1 p( z! G  a; i( y4 `
    9 k7 N( h+ ]( k9 f

    4 L, r( D- X9 O) q& O
    ! I; \3 e2 ^! r% H8 a/ q" H( ~+ ~" r9 d二 、有一个映射的描述文件————>xml
    3 `  [# ]; d3 f; F: ]" S! {" c4 c7 a8 ^* }
    三 、怎样实现描述文件————>一段程序
    0 Y! I6 B- H0 u2 ~# X4 x5 U6 I) K
    对象 映射(mapping) 数据库
    5 S; T/ k" ]1 H  f% _% _. r. n+ e. a7 b* z$ |
    user
    ) o: N) s/ n  c
    3 r/ J$ v% h( c. E; g9 [. zid=11) U3 ]/ n* p2 G) i/ I5 z% T
    & k1 G9 G& j% X/ Y! L. {- W3 I
    name=”张三”———— > (1) —————> tbl_user(id,name,age,tel,address)
    2 g* ?' x7 s' R6 S3 L% D- |# N  {) O: N- H! C( @+ l
    age=25 <————(2) <————
    ( D; Y* r0 u+ ~8 E3 {, X: f- ~7 k' j1 @
    . M3 R1 p  }5 ^+ ~# u
    ' {& J9 N. q! H: G- {. r
    (1)从对象映射到数据库
    7 F- ?2 e$ V8 c& }3 J  x
    ( m% H: R4 z! L& m8 c3 i1.JDBC
    - t- J# X6 G9 W& H% v; d/ O4 ~2 Q( g
    2.根据描述文件来动态拼接sql9 X5 e4 K  L: m$ F- w
    7 s! L( \# I9 C0 q& P! N
    3.执行,添加到数据库中( m( h. ?* n& h, y$ e5 ~
    6 [/ @) h1 p$ H5 s
    + o- e) p+ E7 p. K0 }

    3 p  F. S- h, N! t# P( I(2)从数据库中映射到对象7 R3 ^" I4 o" u# [0 j- f4 n' D
    & R7 H" W+ A" v$ i
    1.JDBC
    0 J, e, \6 r( P9 l8 W' g& G: v
    . q# U6 a& o, m0 r2.拼接查询sql4 v( k& h$ C5 T. D) {& [
    5 h4 y. i7 B  U1 [' E& A4 k( K# P8 j
    3.ResultSet
    . m6 V, W- D/ Q. {" X' _5 y! l2 ]  W
    4.Model : |* h4 ^: u& `

    " W, |9 t1 P- t2 [% } 8 |$ @& H9 T# t2 t( C# [7 k

    5 J4 c! O9 x8 X4 h& Q8 d5 J+ Dhibernate3 g* S: Z- f2 E7 H* G3 n5 \
    开发流程:
    ( a' b( x# a" _$ ]% o8 V/ t* p3 x8 }
    是什么?7 ]. n; K7 y$ j4 M- {% o: n$ ~
    hibernate是一种基于orm 的轻量级的框架
    ; y* U2 B5 |" s$ s7 s. P9 Z
    8 o9 B0 ~4 t" ?  ^0 ?0 x' B
    6 l, ]0 s  M6 |9 I# k, ^+ f8 D  Q/ q5 N( b4 s% u
    有什么?
    ) B: C. I+ z: m" ]1 V' o1. session 保持连接状态(依赖事务和连接池)
    - T4 U' f* ]  t* J  j. A, o/ ?& D6 ~' Z/ q4 f! q4 R/ d
    2. Transaction事务/ a" H  F% u, t

    - o% _- l! ?( P# k6 e. `! k* M3., z; y3 z2 P9 p; ?1 P2 M# B
    Connection Provider 连接池+ [" g) x' q+ K7 V/ V

    7 }( ~" e) S4 [
    ! ^! V2 ^# o) j. V" D; ]# n9 b0 X6 Y+ ?1 m
    能干什么?
    ) V# ^+ i4 R5 u, N) J1.orm$ V2 Q6 h. f3 i2 I! d

    8 h8 U, b8 X/ Q2.提供操作数据库的接口,简化数据持久化的编程任务5 {! ^5 T8 R: j3 W: I: X( q
    5 x1 A7 r  {' x
    ' c2 K9 U/ z8 v5 ?9 l8 l! o1 u. J
    " v+ O# ?5 c, q# p% f
    怎么做?
    ! o, L; B5 q" a4 C+ T, M9 r/ M" w$ |1.搭建hibernate的运行环境,将hibernate的包和hibernate所需要的包拷贝到lib 文件夹下
    ; F- Q, b% @/ F" g! C9 H+ B/ o' _, y* I4 T0 q( y, @+ s/ q3 ?
    2.O(vo)% A) Q+ A4 R" Q3 v, P6 f
    7 X; \* `, G0 v+ A
    3.R (关系型数据库中的表)
    , y% N8 v- ~( {+ K! {* g* V, I' Q3 G/ U; m" ^
    4.配置文件5 e6 L( N1 [( R# `9 J7 V& W
    0 w5 p6 N$ @8 U* w. A) t
    4.1 cfg.xml 放在classes根目录下,默认名字为hibernate.cfg.xml" X8 E# y  C$ E' ?# p4 B' X: j
    & t" ^5 w( I# u# }  P+ h/ Q
    a.与数据库的连接8 `# M% _" y! Y! O. G6 v  w
    5 o& b$ M# Z& n% E- T# S9 I
    b.可选配置
    1 O3 m5 w- z# [% E0 x) b: c/ c* r1 g- }; o% V
    c.映射资源的注册# ^' s, @* R. E7 t
    / q) u! F9 l7 |! w: A+ d
    4.2 hbm.xml文件 名字与类名相同 并且与类放在一起2 @1 |6 K# @, f  i' K: h

    / h$ }6 J6 D5 d. f6 z2 Q4 Ea. 对象与数据库表之间的映射
    : i3 x* m- B. f6 V- j. d& b
    5 G3 U( V8 y3 J6 V* Fb. 对象的属性与数据库表的字段之间的映射
    7 M7 d) j* {& S* B0 E+ V8 Q$ L; M% E2 ?# w( i9 i, z
    c.组件之间的映射
    0 }, ]" t; U, A& x0 G2 i9 J* |$ ~
    d.对象与对象之间的关系映射
      d& D: v1 S% H/ e1 h0 z" H8 [# N/ g- J2 v. s; A8 Q6 _) F
    5、客户端
    ; D* k6 G" O1 Y# H5 E) B3 l$ c. W; }2 _1 n7 g9 E
    1.得到SessionFactory3 _5 T* c5 `- a' F1 \4 }8 ]5 j
    " }3 }% U4 _& h: ?9 d5 Z  [
    2.通过SessionFactory 工厂来创建Session实例
    8 C/ W. `& g  x7 v% D; {: }9 m1 B
    3.打开事务% W: G0 H" F7 @
    0 d- }: k! h5 ]3 Q
    4.操作数据库
    ' d, s, x* k( b1 U5 L. p/ S
      w, M) L% O2 O$ i+ R5.事务提交8 n6 |5 L0 e# W7 q4 o2 \. v

    9 _- Z+ b$ ]  b( g+ H6.关闭连接
    0 A1 z$ v! N8 c
    / g  p; \. n( v( b. r2 b1 }" ~运行流程:& }* g% @, |! X1 w4 ?) S7 r

    ( s8 P6 K+ z9 s' ^* u/ U整体流程
    8 r( n# V4 H& r/ \8 l' D1.通过configuration来读cfg.xml文件
    $ p1 j% {' `! S' ^6 \
    ; D6 @3 l" D! m+ ]7 p2.得到SessionFactory 工厂(根据数据库的连接来创建sessionfactory)
    + P6 {, |2 [% Z0 |" Z! ?; U, ]3 U
    7 Q0 W8 L- A7 S/ U! ~3.通过SessionFactory 工厂来创建Session实例' n  z- E7 _% P8 r
    ! C6 p5 g9 E( e# K/ |7 @: u
    4.打开事务% t) _6 ]6 P/ O4 A8 s8 _
    0 ~8 @/ w0 @  D$ a$ N5 `. K9 |& \( s
    5.通过session的api操作数据库* Q5 a6 g+ ]8 C) ^$ Y
    % i6 R/ m* V3 `* s. `- C! p
    6.事务提交
    5 z4 n$ A& C' G) f8 r. O2 t+ v' Y
    : V3 g  o7 u9 _4 m2 v% z$ f, z7.关闭连接3 O0 a* z# b: z8 j2 {
    5 ^( ]9 B& G* b- j% e
    0 R: k7 D, [" P/ R" K% e$ N
    6 Z" Z  d$ ^& f: v8 j( \  y
    save
    2 ?/ `# j2 `" k  D% `0 S% a1.to—>po
    1 H- A2 \2 @; \% {! L* L
    4 _0 a: h  J+ Q$ ~* T! `2.根据model和cfg.xml中映射文件的注册来找到hbm.xml文件
    ; y8 b2 W7 l) g# O3 Y* s. J; o! F  X- y
    . d0 k+ d( T+ h( L3 u3.根据hbm.xml文件和model来动态的拼sql* b0 k  K: C4 T  P
    ( b6 o. R0 F' w: i
    4.客户端提交或者刷新内存  p2 L  u$ ~( L; V  S1 S
    ( Z. ^9 I: E* E! x) g4 R8 h
    5.执行sql,值放到数据库
    % u3 g% \$ H! e* m# K# S  X  I
    / `( r8 t+ E: z0 G/ G 9 y0 q* [. l9 c% y1 @9 H+ i

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

    + Q7 E' H2 {$ t& m: |3.根据model和hbm.xml 文件来动态拼sql
    # V0 [  H2 l. y) ?, ~" V  }. h" `/ T5 ~: d" x- k* _
    4.客户端提交或者刷新内存& d8 t3 ~( ^( i8 n3 Q% m% F) A- T
    6 F* g2 s, `, k8 x% [  P: m+ m
    5.执行sql7 B# O( ?/ w, ?$ m) h  Y8 K& Q

    , N, a7 K# l3 z' j. ?5 b9 d# d ' M; e/ `. Y$ j3 {
    3 U8 U7 h+ d7 D1 w& k, L) \, V
    Query9 g5 w) G/ e  K& I0 c+ C- q
    load2 c. a/ t7 z  V& |$ i' r) E- o

    5 W1 h8 F1 W4 o- D! ^9 T& z2 Q( P1.根据model的类型来找到hbm.xml文件
    / q  q  q; a$ h7 _; O& H% |3 h1 c" t, T
    2.判断id对应的对象在缓存中是否存在,如果存在,就直接使用,如果不存在就进行下一步。
    6 v6 ~6 Z! `5 j. U7 w' r9 ]
    ) P0 b9 B$ {4 B3 t0 X0 ^3.用id做为查询条件来动态拼sql
    * f3 R2 M0 v; ~8 m/ ^) z( p: K+ v' w- n2 |4 P
    4.执行sql 查询(先在内存中查找,如果没有找到(会抛出例外),就去数据库中查找)
    7 q- \) C6 E3 E, d" Z: l  h% r9 v$ ~
    5.返回一个model类型的对象; |6 y3 o) X8 d- z$ ]
    4 a; j5 m0 Q( x! g- A, |) {. H
    get
    / h" S& w9 P4 }8 i7 p- p3 l2 p  s3 B3 `0 w: [; q
        1.根据model的类型来找到hbm.xml文件
    ) l; M/ K& P4 |( [. J
    " g6 d* t/ o3 B0 N2 t3 }2.用id做为查询条件来动态拼sql
    2 H" X7 Q8 [5 d
      a. J9 C5 o+ H- f3.执行sql 直接在数据库中查找,如果没有查到就会返回null
    9 r8 F# {9 V; X1 z( k4 X  N& U: \, k+ H- g7 I
    query9 Y- c( f; D/ B. m
    ) N4 Z2 F" L5 D
    1.分析hql语句,得到model的类型1 a$ f6 K. x" |5 i
    6 ^( [, j# f2 f6 @) J
    2.根据moedel和cfg.xml文件中映射文件的注册找到hbm.xml文件
    $ ]! k3 E1 Z% I( Y/ @9 V
    - G% ^- _: C4 `2 A6 N3.根据model和hbm.xml文件来动态拼sql
    , T" J. W# J  b) r' c! |8 C! @0 b8 y4 V0 V8 F$ O9 j- E
    4.执行sql查询数据库
    ' Z& E) }$ j! L
    * q8 ^' s" g$ S, T5.返回一个resultset) W1 P" e1 U: }8 ^$ M, w5 Q3 q
    8 O9 s9 U- Y" t! ~
    6.循环resultset的值,放到model中在放到集合(List)中* K( j# p# J) W8 D8 C* `- T7 L; q
    . u/ t' o: Q9 v: {

    / Z% I4 j+ T- q& }: p% k: s9 ^
    - u: d8 ?/ C2 K3 w, l8 h谈谈hibernate缓存机制
    ! G! A9 m* I+ Y4 }/ R! [+ l3 O2 M9 H% m0 f' C1 W
    缓存其实很直观的理解为放到内存或者硬盘上的一块区域,缓存就是一个缓冲的作用,有很多时候,我们的数据需要经常访问,如果放到数据库中,不是不可,只是效率上低,如果有了中间产物来代替数据库,就省很多事情了。打个比方,去买酱油,不一定一定要去酱油的生产工厂去买。代码中需要数据的时候,可以先到缓存中查找,如果存在,就直接拿数据,不存在就去数据库中取,也省了很多事。. i/ f5 F0 S4 B$ A' k) p# b" w4 {
    , x( N- X1 o) P. I- @0 `
    * ?7 S2 s6 ?9 Z8 H1 e

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

    . d( i6 T. G- @0 B0 d/ K 0 W8 o) m. c0 e/ X* i7 ?: z1 i4 R

    : Z* z/ r% k- ~1 H( `* F| 一级session缓存| | 一级session缓存| |一级session缓存| |一级session缓存|; {/ u4 |) ~0 _* s$ v# M2 ~! H

    ! ~5 t' z. a7 u| | | |# R, O/ U; C! _* Z4 W
    1 d* C# R' W2 p# L4 A6 x& Y
    | | | |
    9 X* w" \* }  ^/ U  K1 G$ d. F7 d6 Z# h+ @5 ?3 O- k6 j+ J; g3 X; a, ?; K
    —————————————————————————————————
    7 g3 S8 a. I7 V- r3 E9 H3 G$ B
    0 E- K3 A, l2 j0 A5 R& e4 _sessionFactroy级别的二级缓存
    - {% t5 D% E2 V6 v: G2 r
    # J9 O* ~" ?& {+ Z! v——————————————————————————————————————-
    7 {6 u+ B6 Y) M2 K) Q4 l, y2 f* C' @4 l: }- h% U$ U
    |
    + B( U' b$ C9 O; V) ~2 }6 q: X/ q; W) g
    |  `+ P3 ^1 s: f. N+ `9 ]
    6 S9 p3 R( O% G' i+ v
    |
    * C% U  @1 y' J0 b4 V% U
    / I+ d$ \) \" w( C# W——————————————————————————————————————
    8 |; o0 f5 [9 x9 L
    # N7 w, W1 P2 H. t6 d$ nDB
    7 _; \* D) a, x
    ) Q: e$ l% u3 N: i—————————————————————————————————————–
    * Z% W# f% u+ @1 W. l/ R! s
    ( S; N7 \" a" V4 X
    回复

    使用道具 举报

    admin    

    1244

    主题

    544

    听众

    1万

    金钱

    管理员

  • TA的每日心情

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

    [LV.5]常住居民I

    管理员

    16#
    发表于 2014-12-03 12:48:12 |只看该作者
    Spring
    * {) j. y$ R$ R. I9 D; N! z
    • 是什么?! Q& e  n3 h0 Y: s

      ; m# b. [8 x3 x: S6 B

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


    " I8 a( |1 v, E/ N! q2 N4 J3 @
    • 有什么?* `% `- J- o5 x6 D; R

      1 _. v$ b% c: C9 T3 X. q

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

    每个包的功能:

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

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

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

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

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

    AOP :面向切面编成

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

    + Z: `3 I& a0 Q; N+ F( h" P! A
    • 能干什么?6 J9 t9 l8 P* v. M8 J% Q+ l
      : r! e, H" A" z2 ?. ^' q* |" l2 z

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

    + B. U  P: l; ?/ u8 T
    • 怎么用?! @/ c/ E* |6 `, \5 ?) V! K
      ; ]$ c. \$ Q. y
      • 搭建web工程,引入spring的jar包
        + C( v* V6 y& T- ]
      • 在web.xml中添加如下配置
        % B; B; w" Z9 u6 B, k
        4 g& b, @, j) \6 }

      ( y& O+ u$ @$ ^& ~& Y  j. O6 e
      2 i" y4 K% N4 T: Q

                contextConfigLocation$ ~: b# p/ c, ^9 g/ J

                classpath*:applicationContext*.xml# c& _. F( J2 g- w0 i

        6 E0 i* `% }' s# X; n

            
    " m; p. D, H- u2 M

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

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

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

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

            
    * V' B, q5 H! H

            
    " f% Z  @, i( m4 O  Y

                struts2- z7 v& {$ B/ m8 I: ?: N; Y

                /*0 X& {7 |2 @! ~0 J0 l0 r


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


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

                3 F- h) j8 e+ l& Z) _

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

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

            

    • 部署/ @0 T8 B2 E$ Y. g

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

    ! u7 `* y0 y/ ?* g6 s7 W
    2 p! |  B* ^& C) p( W1 p5 Q
    1 v/ Q, Z  H4 O5 w$ B/ @7 V6 x, z% Z
    • 容器和bean
      2 D: Y: J" V6 b" e/ a' q; v

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

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

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

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


    7 W: p  s7 j7 {8 W6 E2 r: ]. p: Q( Z! m
    • IOC控制反转
      9 }) C; I4 E2 h* P) i  @+ q% U" }8 N  L9 V2 X

      9 y0 M: f+ }7 o/ T : A8 N4 b" @0 \) b; k1 _; O
      从前的应用程序想要得到A的实例他会直接主动的去拿,当用了sping后,应用程序由主动的去取变成被动的等待,由spring来控制应用程序所需要的对象
      6 Y8 c* e: B% F. Z- K; F
      • IOC的优点
        . J  `" Q$ V/ K" z
      1.可以通过IOC来获得实例
      2.可以通过DI来获取注入的资源
      • 配置IOC的原则8 U/ `+ z' _0 {; W9 r: S" J7 S
        • 一定是可变的资源才采用依赖注入
        • 一定是层间的接口或者是模块之间的相互调用才采用依赖注入9 j6 v' _. ?; k$ g, v
    * [- X9 W! m3 n0 t1 A( ?' ]0 k
    • DI依赖注入
      * i  b5 ]: ~8 G; d: [8 \3 h  Y

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

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

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

    例如:

    在配置文件中


    & J& Y' ~' @* v; Q. b+ V
    1 S/ e6 w  a3 W, u' U! I4 K" ~0 _8 U) R' P% I

    在应用程序中

    Public DBDAO dao ;

    Public void setDao(DBDAO dao){

    This.dao = dao;

    }

    3.构造器注入

    $ {; j% p( w! _

    4.ref 表示参照其它的bean

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

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

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

    6.lookup注入

    7.singleton

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

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

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

    8.DI的优点:

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

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

    4 W3 W% w4 o3 S1 C
    • Aop面向切面编程
      ' U" z1 q! ?9 z/ `& o

      6 y3 U0 R# I' E& Y

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

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

    2.AOP的思想: 主动—->被动(追加功能)- |, @6 Z! y1 n$ R) j! Q

    3.AOP 的概念4 O' I8 \' |4 [/ ?! y2 j

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

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

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

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

    5.引入 :扩展的功能

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

    7.aop代理 :实现机制

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

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

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

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

    3.找到切入点

    4.确定连接点

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

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


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

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

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

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

    所有的入口必须从一个代理(ProxyFactoryBean)开始- s/ y- O& u8 \/ B( j

    8 [* [' s# c/ M: r' n

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

             
    + H$ P2 X- I$ H( n, t6 j; \# @7 v8 m# g5 T% X3 {

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

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

            


    * ^7 F' N8 K* jexpression=“execution(* com.javakc.aop.MyTarget.t*())”/>% _& n# b3 O# X

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

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

        3 `% a& p5 c7 B. O2 p) f: J7 T" j$ h' {

    4 E9 t" {" U! `* F4 Z

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

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

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

    1.@Aspect声明一个切面,将一系列的共同的功能定义成一个切面/ c* {: |5 H& `- r) W6 H

    直接在类上定义@Aspect7 M1 F0 k+ I, B5 T0 N

    2.@Pointcut声明切入点8 `( F$ m( q1 A, y5 t

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

    2.2、可以使用匿名的pointcut0 g% X( v' ^, A, B! `* @

    2.3、执行切点的几种方法  `/ U  [: U. u9 d; J) U4 ~+ I

    2.3.1 execute(public * 包结构.*.*.(..)) 可以指定到具体的方法7 ?7 `5 r' _5 f: b0 T  o  b# K

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

    within(”com.javakc.spring..*”)9 p' J, N# f! l# N: u! ]  n

    2.3.3 this 指定到实现接口的所有的实现类0 f0 g; Y1 l( a8 v; O% R  D$ ^' d

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

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

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

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

    追加的方法的参数名字一定要与retrning的名字相同3 @6 ?: ^/ v. t3 J& R+ i

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

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

    得到目标对象的方法的返回值,来作为参数,进行下一步的处理,参数没有顺序,按参数的名字进行匹配6 c$ V; ]4 ]) F* }, o" I7 h7 \

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

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

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

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

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

         (1).@AfterReturning(“execution(# f( X) ]/ o9 m

    * com.javakc.spring.schemaaop.Api.test4())”)9 Y1 a3 V( m. P5 R' Q8 w

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

    “com.javakc.spring.schemaaop.TestPointcut.t4() &&; p+ D9 m' Y" G& W' `# p

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

    @AfterReturning (pointcut=”com.javakc.spring.schemaaop.TestPointcut.t4() && args(str)”,returning=”retVal”)0 x8 X1 p/ D2 X( E* f! Y7 }% {

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

        System.out.println(“afterReturning1=>”+retVal+”=>”+str);7 B" D$ c; s3 Q2 F6 f7 p

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

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

         注解@Around环绕追加功能;% e' \' O1 Q6 n3 n/ y

         在执行目标对象的方法的前、后追加功能;3 d. s# c2 ~4 [9 \+ d1 K0 b

         必须有参数;第一个参数的类型必须为ProceedingJoinPoint;6 c" |* ^/ s7 {; F" Z" m3 a

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

    目标对象的方法% n$ |/ n1 K) x) n4 k7 i. `

         1 定义一个pointcut,通过方法名来作为pointcut的名称来引用' Y: h: k. _  a5 F7 a4 R

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

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

    && args(str)”)5 I) w' I' N% S8 A" G3 y

    2.直接引用匿名的pointcut* s' i1 C0 }: p" _" i& [

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

    * com.javakc.spring.schemaaop.Api.test1())”)4 D+ k  r9 i: ]6 B

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

    * com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)6 j' T! O* J! r+ D! g3 U

    // @Around(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”)3 `6 ]: B% b4 W% N; W' V

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

    public void testAround(ProceedingJoinPoint prj,String str) throws Throwable{7 m! l4 j* }* T0 X

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

            Object obj = prj.proceed();9 V) q$ D7 v& H* d! ^4 r1 A

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

        }% h- G' J5 }5 O0 _

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

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

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

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

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

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

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

    (1).@Before(“execution(* com.javakc.spring.schemaaop.Api.test1())”)- E; I1 b4 o- `& V

    (2).@Before(“execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)”)) ^/ d! u- I! e/ G, u. O

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

    // @Before(“com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)”). h# h0 ?* g" O, P+ v6 i

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

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

        System.out.println(“before1=param=>”+str);( i7 q# Z! ^$ d) j" l

    }2 `1 }: A& k: B3 Y


    " \6 F" S/ z7 J2 M

    5.4.4.@After% h# S- D  J8 V2 W$ Z3 p, R

    注解@After在执行目标对象的方法后追加相应的功能! `. g3 I/ V7 |- \0 s( z4 G0 m" U

    1 定义一个pointcut,通过方法名来作为pointcut的名称来引用: O- J* b% ?) K0 s+ c  ?

         (1).@After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)5 U) y4 ]# x8 X3 y

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

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

    @After(“com.javakc.spring.schemaaop.TestPointcut.t1()”)9 V0 x; u6 h. |1 [1 r7 D& X: d# m

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

        System.out.println(“after1== >pointcut”);* q7 R. B- d4 S, T: a

        }' h! Z% W2 M7 P' q4 @

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

    9 c" E* s  U$ Y* P

    : |% m4 y. f2 y9 Y$ E2 }; i
    • 描述一下spring中BeanFactory和ApplicationContext的差别* |4 w1 w1 E3 @5 W, X
      : q/ a& k& \; |9 {# p. {$ J

    BeanFactory是一个Interface,这是Spring的核心。它仅仅只是提供的一些基本功能。ApplicaionContext 也是一个interface,这是从BeanFactory继承过来的所以它具备了BeanFactory的所有功能。但它也从其它的类或interface得到了一些特性。比如提供国际化的消息访问,资源访问,事件传播。

    但其主要区别在于BeanFactory是延迟加载,如果Bean的某一个属性没有注入,BeanFactory加载后,直至第一次使用getBean方法调用此Bean时才会抛出异常;而ApplicationContext则在初始化自身时检验,这样有利于检查所依赖属性是否注入;所以通常情况下我们选择使用ApplicationContext.

    代码示例:

    BeanFactory beanFactory = new XmlBeanFactory(new FileSystemResource(“beans.xml”));

    ApplicationContext cxt = new ClassPathXmlApplicationContext(“beans.xml”);


    3 Q1 d9 [! e% g
    • 谈谈spring对DAO的支持; o% v) ^2 ]1 r- {6 \  K) Q( _' ~
      ) F; K% ?2 m5 k" [& v

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

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

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

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

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

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


    - K) G7 g8 q- j" ~# R: f2 w; r. _" b0 N$ K6 W
    • 谈谈spring对hibernate的支持
      , o0 V8 Z$ z1 F$ W
      * l+ C. i7 ]6 S" Q; |+ |

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

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

    1、通用的资源管理: Spring 的 ApplicationContext 能管理 SessionFactory,使得配置值很容易被管理和修改,无须使用Hibernate 的配置文件。详细配置如下:! @7 j2 j) p3 R, C1 [- `, i

    1 I0 a% O: d0 r' q

            class=“org.apache.commons.dbcp.BasicDataSource”>* w' R7 ?1 }7 T7 X  Y7 S. Q, B  |

            - `/ v/ l% R* d. O+ R0 T. V+ }

                oracle.jdbc.driver.OracleDriver1 X5 W; S; j, ~; a) l, `6 d

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

            ) p3 z7 U- v+ h( O* \

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

            ' t8 j( h' Z6 o% M( r& s' e

            7 G( C  k$ K1 @% V$ w

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

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

            
    4 G& N( v( k. N9 h

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

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

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

    ) ^; l& k/ D0 \$ _0 d. y; ^

       

            class=“org.springframework.orm.hibernate3.LocalSessionFactoryBean”>) l8 o+ G! x' y- s5 ?

            1 K9 v  _! S7 C5 T

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

                ( p5 O; C& I3 Q# ^

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

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

            $ A6 j( V8 [/ c) H

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

                ; s7 o" \2 f1 F6 I( j" C4 K/ M+ z

                    hibernate.dialect=org.hibernate.dialect.OracleDialect- V) i" W! t8 d

                . U  @6 f3 K) t. Z+ q- a8 K

            # P, x+ X- T# {+ k; a3 I% U

        ) E4 H" E3 ]* O. h7 }/ A) U

        ' b4 }! K, j8 p% K

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

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

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

       

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

            " ~+ o( X8 N- ]8 l- \0 {

                java:comp/env/jdbc/myds; z) T; `  Y: j. q

            6 t; u7 V9 q0 O, l  p' g4 c

       

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

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

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

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

        ' a9 ]4 W: B- [& ^8 U: f

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

        " [7 e9 Y# \; j( g0 B  P


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

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

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

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

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

        ) u" z& t  [; ?% p& I

    + E5 Z( {, q6 J, K0 c8 H; Q

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

              ?5 h, G2 T! @6 U

            2 \" g2 k$ Z$ N  h3 S/ I

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

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

      P$ i: i% o6 e8 V5 A: x
    Spring2.0之前事务的写法
    6 N% |. u% A& {, \4 }% \% K

    ' d. ?) f) E3 m: I& x8 z" |5 X# z
      u* ?1 e( ^& U- L        class=”org.springframework.transaction.interceptor.TransactionProxyFactoryBean”
    ) i2 y; E; B6 H! |$ Q" u. `$ T& O

    - d* c) S! K4 G        abstract=”true”>7 M; T( V: o% X! S0 U) N! |
    " t* ^" c% p+ S: L/ C
    ( N5 j# X% J' \+ c& g
    3 V& T- ~0 b0 n. Z' r0 f' X

    2 w. d6 `3 N0 `5 f( `                PROPAGATION_REQUIRED,readOnly! O9 H0 n, L! `
    - D/ v5 `6 k1 i! B1 n3 n
                    PROPAGATION_REQUIRED, s1 p/ ?; S5 v1 C' t7 b; x
    / U, w# s8 t2 t; T. J

    0 g: s4 @, }. i9 l, |4 Z8 P% f* D# r! p2 Y

    $ e# T& ^' y, ~% W$ F" b: |
    / r+ {' P. }+ D7 g# _- Y- Y

    * h  S4 B2 p( q  y
    • 谈谈Spring对事务的支持
      5 x" n  v: v, u: ^  s/ `6 |' P
      & R1 b8 z' u/ |! T

    4 B0 g5 @# w; a
    1、声明式事务管理:

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

    2.做法:

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

    2.2

    2.3 注入数据源


    0 j- u6 J( m0 P" ^) `$ z
    ! x# a% K* r7 v6 h% l/ t! H/ k% ?2 ^. g/ m, `0 h# ?) D* s7 |! b# Q: j
    $ @$ g, l( d: C
    - m8 W: ^) I1 a) F3 Y* ^1 R
    , s% |1 b4 F6 P/ [- W6 h, }

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

    8 n2 [8 H& ?6 y

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

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


    ( ?! q: L! D9 |! Y% ~/ t# U% l( k9 `: ~6 n0 F0 e
    , J4 M) t! k) C

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

    2.6 定义切入点

    0 `  D- Z9 v# {4 [% }' C

    1 h3 a7 [) J, E5 ^
    & F6 g" ]# Q2 H6 W  w# g+ [; ]) M. Y# Q, b, R) H- |
    , t) ~* a  X  }1 X

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

    1.注解@Transcational

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

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

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

    9 c) l: G! u: Y3 K- K7 j: \: s

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

    如何在Spring中使用Hibernate的事务:( M9 e" M! |7 l$ T+ D


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


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

    / e) \9 Q/ J6 F% h% U

    如何在Spring中使用JTA的事务:" q9 t% s, E: I" ]

    5 [9 ~8 R" U! J2 l2 B: D$ C
    红红火火恍恍惚惚
    回复

    使用道具 举报

    admin    

    1244

    主题

    544

    听众

    1万

    金钱

    管理员

  • TA的每日心情

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

    [LV.5]常住居民I

    管理员

    17#
    发表于 2014-12-03 12:48:32 |只看该作者
    事务
    & u8 h5 p: o1 F$ u. j4 |- D( DACID
    ; P- g/ S; R5 K0 b' H* k' A0 A% W(1)原子性(A):一系列的操作具有不可分割性,要么成功,要么失败8 m, d, A' ^1 L5 S. v& j

    7 I/ h( d' e! y! d1 y$ t(2)一致性 :操作的前后满足同样的规则,保持平衡。/ ^# L% K! k0 ~  b/ ^
    2 T7 v. r$ o" `3 K. {$ F7 H
    (3)隔离性 :在事务运行的过程中。事务内的数据对外的可见性和可操作性(必需由数据库的支持): f. {* r. Q5 h: u

    & a- J" S$ I' N( i(4)稳定性 :保证数据在事务的操作的过程中不会遭到破坏,而且是永久性存储的& {! {! ^( N* f- i! p3 _
    7 {( z- c/ t8 s: U" G5 i
    $ S, C& t+ b  C0 n* m6 o! h3 d

    / j$ }( R+ c+ Z" C事务模型' q7 P1 W) c, h/ P) ~8 n$ m) [
    (1)经典事务模型又叫平面事务模型(JDBC) 事务不允许嵌套
    ) A. \# l( T7 p9 l5 p' U2 ?* n* Y0 Q  O% p
    (2)嵌套事务模型
    - J: g+ J9 K* ?. Y# w6 p$ F8 s, e/ [. s9 b: Z8 ~. l

    $ s/ j" u+ T* j' g
    ' W/ s/ U& O0 b& d& l9 \事务的两种方式9 h* }4 ?& X! ]! A: f, {# E6 S: P
    (1)声明式
    8 v8 {& L# h" s
    # {5 C0 y4 |* Q9 t# b* W2 I2 S在配置文件中设置以下6项
    % L' c; E9 O" `- Z% r4 [$ q3 t* r5 s6 v9 A% I/ I
    (1).required# U* w' J' @+ Z; `! d" v, v
    8 `* }0 d) L. g5 A4 B
    如果客户端没有事务 在bean中新起一个事务
    3 i" W$ F$ r  p" T7 u( K9 b7 N* d3 m6 H4 M, ]% j
    如果客户端有事务bean 中就加进去* h6 x7 f: L5 }5 [- L' d2 v  S

    8 A4 y) z" V( c3 s" k2 Y(2)、 requiresNew
    5 P  `- I3 @) H6 F, m/ c3 Y) w1 j: d( U5 [! U8 V: u8 J
    不管客户端有没有事务服务器段都新起一个事务0 D( F9 I  S9 {  ], ?

    4 x# S6 Z" \9 ~, C7 `# M如果客户端有事务就将事务挂起
      m% Q0 h; {! d+ j# |6 M% r( u- }& h& S8 \/ Z
    (3)、supports6 H; ?( d1 K/ D; Q5 G5 Y

    # B! u! e& K) J) p; y! d如果客户端没有事务服务端也没有事务
    $ F6 A* F# D1 X& I. {8 |$ A7 b) Z% o# I! u* Z/ [& O- g2 }" s$ y
    如果客户端有事务服务端就加一个事务
    7 q5 _8 o' g! n  @- |
    + M9 ~, A  ^, a% U: Q(4)、mandatcry, e5 p0 b4 ]# A
    % V, R3 A' a% Y! d- ~6 E; ?6 t/ Z! O( x
    如果客户端没有事务服务端就会报错
    7 }3 V7 r6 N7 j  U# N+ t( `; n" U5 H
    , s" g! o1 \: v如果客户端有事务服务端就加事务
    ' I8 ]/ @" f( j8 c) Q5 d( |! [! k; {/ `7 J; D# e# h6 c
    (5)、notSupported/ H2 I6 E( z  M0 \, n. t
    " O9 w2 B* t1 p( ~3 I* }- S
    不管客户端有没有事务服务端都没有事务; a# p7 h; m5 N( y- _0 y
    ) }# n; T: B# O, M8 t: X
    如果客户端有事务服务端就挂起: H9 o0 a( X$ O2 A% r/ f# Y  a7 q; B

    ) o8 @9 o: ]3 ~) ^1 J& O! L1 W9 V(6)、never- T; v2 g! r# e; z

    ' _! K  T. ~! u) Y1 k1 R不管客户端有没有事务服务端都没有事务4 `# _( X) V! [: }/ _3 n, B  \

    1 t2 B% w7 ?2 f: |如果客户端有事务就报错
    ; [6 `$ E- v6 x5 c
    " c; y, H; O- c/ ^6 p) [: H(2)编程式事务0 D4 g# c* v# I  ]: a6 |' b

    9 w1 A1 E9 l6 O* D6 R# ^Javax.transaction.UserTranscation
    , n- [' G: w# ]! E# s# F" @+ }, N& s* a# D7 G
    JTA 事务可以精确到事务的开始和结束
    4 K8 w4 V, S& J3 M/ {8 C2 C
    ) u  @( |% c8 ~/ M$ }( o
    ( k- _0 A  m- Z+ W: W9 Y- m5 B7 _0 p6 p3 \8 S3 N9 z5 ?
    事务的隔离性# j+ [+ z- N7 ?
    Read-uncommited, o- K4 z, X3 Q1 m9 r* c6 P/ i

    8 t% J! n7 g+ u. {读取未提交的数据(基本上没有锁)脏读,存在不当读取的问题。3 T6 A% w% R, t0 x2 Q; W

    7 \% w: e! G9 Z3 d  f6 s$ B" [Read-commited7 w- B6 m' R' H' h, w' O9 k# n

    # @7 P8 }% x; t) f读取已提交的数据(行级锁)
    7 w2 ?+ i/ K6 R. `3 G5 c5 D/ D5 q# r. R4 K
    无法读取已经写入,但没有被提交的数据。8 l9 J/ f: Z' r) r

    5 F) |* ^! @- o! r4 B+ q7 Z" e( JRepeatable_read9 |+ T: z; P9 D- V* x8 I1 @! U

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

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

    . d: P, y2 T2 D. K; ?$ _% ~2 n4、根据动态输入改变输入流' f+ K, \1 G1 E% u
    ( E  [- O$ p$ L! y9 P  O" O9 \8 g" R
    要完成上述四步,我们需要创建
    7 J( Z! k6 l; ?- \' H
    7 ]' ]- B' Z2 q7 C, i* B1、一个ActionForm1 x4 h3 r+ V; A

    * i+ u0 M+ g5 Z' L) }' h2、一个action
    ' h- _$ E, z, Y- b, O4 X6 X( v+ L9 E6 l; _7 [0 S& Z6 X
    3、一个配置文件struts-config.xml
    ; K. ~/ l! b  ]' J2 A( s! _3 V# U4 K) q# ?# ]7 J) S
    4、创建页面6 O! y3 ^# k, ^7 D
    % m  ^# o+ b" ]2 Z8 L
    创建ActionForm
    - w8 ~, L& `$ n6 y, @
    8 t" k3 U0 O9 g1 ^1、写一个类继承ActionForm
    " ^# `$ ~1 j) x2 r6 U% S
    % a" Z; c! |* q% {! I4 T( B" G2、私有的属性, Q$ f3 `% Z7 p! Y6 P. S4 I

    . n" v6 Z4 }) t( D  T& l3、相应的get、set方法
    8 z& F7 T' D! x# U! w% W" D7 T
    & g; K! t- a+ T6 T+ n7 r+ D" t8 \8 `4、重写tostring、equals、hashcode三个方法" g  B3 v: b& }5 O
    3 T' t2 C" `4 W! p5 u
    创建action0 d0 i7 j0 @- g. v; F

    # {( R3 c" D- G! E5 y1、写一个类继承Action2 ~: [( L, u* Z: ]. h; g
    ( s  J+ e1 K. o8 Q
    2、实现一个公有的方法(回调方法)
    7 @- ?4 T2 R" p! B3 k+ o2 _2 v9 R; ^7 r
    ; m$ n1 g2 T7 Z: A3 @public ActionForward execute(ActionMapping mapping,# M6 m' i( u0 [
    6 T4 n8 J' |$ k. q1 g2 }
    ActionForm form,6 a" N3 Q5 g" G- H0 p+ n) J$ {3 P

    " h+ p$ o+ R9 P7 G3 R+ qHttpServletRequest request,
    - l. y( l4 F1 U, V  a8 D6 L# s& @! Y( {) t$ V
    HttpServletResponse response)" {2 _' E8 S+ l- r+ O
    7 @; Q$ k2 L* q1 s8 S
    {
    0 [0 _8 _8 X7 t, Y& s0 r2 C' a# f2 x+ H5 c' d
    //1.收集参数
    9 K6 R9 f0 w, c( d9 T: `$ E! f5 P# q. o; W5 M8 b
    MyActionForm myForm = (MyActionForm)form;& w. i3 E2 F" \# N) i- Q$ \

    ( e3 ~. _% F( e2 Y( U//2.组织参数! M- w+ U# ]5 \. U) D. I
    + e; }9 V, W! p: U

    - V! Y, B$ T, r6 m) C1 M: u. _! K  a6 E
    //3.调用逻辑层% y$ v: \, r, d4 b: J" L! Q

    ; |8 h& D( w5 Z# _3 `' X8 rboolean flag = true;$ J9 s" J4 v/ i0 a

    7 L1 f: u, N3 g" ]//4.根据返回值来跳转到相应的页面+ r5 d5 }8 ~( J+ A% {

    ; ?. t& ^+ P! jActionForward af = new ActionForward();6 E+ t; C1 L/ C6 u$ \
    4 T# D% |1 h' f  c
    if(flag){
    / k( q# Z6 K9 K8 J* U, @/ V) J$ i$ B9 n9 q; f4 z
    af = mapping.findForward(“1″);# c  M& R% d, {  o5 Z

    $ f. b; \1 |( Q# n0 u" k}else{5 o9 v* o9 n' D1 S+ f
    % }  Z) L3 V1 e: i9 Y  T
    af = mapping.findForward(“2″);
    6 t! T5 N, H5 H1 D( a+ n
    9 l2 J$ C/ |. }0 x}
    9 C$ M0 f& ?8 P9 r8 {6 q
    " M- d2 {% L/ A) @return af;
    5 t. w) k+ Q( l' ^0 D  N2 ^1 z! V" c+ n& b9 v
    }$ o$ _. F3 b+ A8 ^, T, P
    7 l! w% v2 a# t0 P6 ^$ g" ?
    配置struts-config.xml文件
    . G: u+ T1 F, q$ V; {; U4 L% q9 ?7 K4 G8 _, E, R
    1.<form-beans>
    9 ~; c9 ~6 i2 R5 c  I- J
    3 i/ A2 W3 `. Y<form-bean name=”myActionForm” type=”全路径.MyActionForm”/>  T9 r( i- B  _; q) |

    , \5 T7 Q, I9 ~, t<form-bean />: c) @4 s+ V. ~
    . N% o. w' r1 q: K. V+ i
    </form-beans>
    6 V5 T7 n7 t' t. w; Y6 k7 g/ c9 w& |
    2.<action-mappings>
    0 w, I! U$ k& A( W6 ^  |* w+ E1 S% `& \: P
    <action path=”/sll”% A4 k% X* X3 G! d: K! N5 _, c& ~

    3 W% T6 |5 L. m8 C  P" Fname=”myActionForm”
    ' z; w3 D% a" @% o1 h; b* i4 ]+ b' F
    type=”全路径.MyAction”! |! I$ R) \5 \/ |2 X. s

    ' ?6 ^/ F; C( ascope=”session”, L" n( c; R. x$ ]
    : O# ^" V; d& O: f# t, T! L
    input=”错误返回的页面”>. Q* ~) Z, R1 @5 k. c, Q

    . J9 j: A! R2 j! C) K8 Z! p<forward name=”1″ path=”/1.jsp”>7 X0 S/ v" G/ ~3 E! }0 u
    : J+ \: I: V4 m5 s. Q
    <forward name=”2″ path=”/2.jsp”>
    1 W6 k! [1 h5 H" a
    * v- @4 T* m) n3 h* k</action>8 b8 ?  l2 }( T/ M5 {

    ' p& G6 ^* w1 J! Q</action-mappings>( y( P  l, O) Q6 g3 `' g4 @. g
    # [- a" b* }( k' ^; T
    步骤:
    * D* O, w: E+ C9 H& V8 C
    ) z4 s$ g1 `* i* a+ z5 Z: B4 i/ |1.创建一个空的web应用
    0 s6 e, L( q* X+ z' m  N% A" z+ x$ T/ x2 N4 @% t* J
    2.将struts的包放到lib文件夹下) P! H# W3 `/ x6 Y1 I4 ]/ F

    ) A9 j8 e5 O2 C" h7 ~3.将.tld文件文件和struts-config.xml、web.xml放到WEB-INF的跟目录下
    3 L) e" |5 H! D3 w7 k, A0 e' C0 U0 w" @: |; N$ t( L
    4.配置struts-config.xml文件和web.xml文件+ j0 @# l# ]: A6 r* ~; [9 b
    0 Z' f) m+ |4 }% p5 t  V* O
    5.在页面引入tag文件uri7 H! m9 \" d& x) F- `

    ! |4 H# Q) B) k) ^- `; _7 dSTRUTS运行机制' c3 I+ l1 ^& Z3 m
    7 n# J% d# Z# D0 u
    1、界面点击产生请求2 L. t& O. [  @) G
    : O, I/ U* n# s5 z2 t
    2、容器接到请求
    & ^2 h5 x, S4 w1 v1 V- c' d
    3 z# W4 Y+ d4 {1 C) R3 U2 b3、匹配web.xml文件中的*.do来调用ActionServlet8 Y3 v: X! Z' h! d/ N
    : |( `0 M7 o/ p% r
    4、ActionServlet的处理! P( u# f  F: x9 e( F. N& E. Z0 N7 [
    1 o  q3 b% G2 T4 _% O" N) e4 p
    4.1 读struts-congfig.xml文件形成ActionMapping
    # P8 @& w7 e/ T  z: A1 F
      @# Q7 Y0 t, U4 A5 o# E4.2 通过path 来匹配Action类,通过Action的name属性来匹配ActionForm类
    . `+ Q8 U% @- f/ ]9 P/ k  X. t6 g6 y3 ~' L
    4.3 通过反射机制来给Form添数据0 u6 P7 I# T% r) O7 e
    & X# v2 a+ L9 P! q+ {, n- p
    4.4 由ActionServlet转调Action的execute方法( r% Y5 C) i$ e( {" J  [
    $ ?$ O* t: a% W9 q6 }
    4.5 得到execute方法的返回值,跳转页面* a& Y# Z! d; V; ^

    * V2 \* ^- ]1 z1 g" z: @4.5.1 RequestDispatcher7 g( G( j# J' O3 R% Y1 t; ~7 D

    $ }8 M: B6 ~2 r# e. d/ X2 s* ~4.5.2 response.sendRedirect(“list.jsp”);
    ( _0 C& D' j2 u* B) D
    8 a9 o' Q/ a7 r# s
    , Q7 @. l# r/ S9 o9 k5 J5 A8 Z, i- P  {! D! a5 k7 T8 w
    进入execute方法6 p1 G! q) B% ~2 t: U9 g# T

    $ T1 Y6 t1 |& T+ S. H; c5 b1 收集参数7 U7 _8 W' }% R. n! u+ y. g
    8 j3 y7 P) j; Z1 w
    2 组织参数
    2 o& G8 P& S' u% {
    . w& D( n6 B$ s# V7 K3 调用,逻辑层
    ) W8 n% V1 V$ A! y- w
    ) i$ w% B. {7 g' v. K$ s. A4 返回值, Q+ i" Z: c: h( l, x! r

      s6 Y* @8 ^" q4.1 选择下一个页面 (ActionForward)! R- b$ v6 M. }3 e/ f

    8 A+ _, k1 F8 @4.2 把值传给下一个页面+ L( F7 A$ m1 i0 ~2 i+ ~# l
    0 `* E5 C' h% j) q: b1 a
    + W) n, D! k" F! e. i3 z* k, }' K. \; m
    * _7 K- A# L& R# C( l( U
    比较struts和struts2的不同
    , C# O' f8 z* w: ^3 P) F; B, t& Z9 c7 b5 y& p
    Struts- Q' I7 Z* b6 p2 f

    + v8 Y4 \3 E( T/ j9 NStruts2
    / H; o! q) z; h7 [, q6 y5 k- J5 s; ?* f" `$ l& G0 `
    组成        五个部分:ActionServlet,ActionMapping,AtcionForward,ActionForm,Action        十个部分:AcionContext,FilterDispatcher,ActionMapper,ActionProxy,Configuration Manager,Action Invocation,Interceptot,Action,Result,Taglib
      c( y6 c7 ]$ X1 W  K5 M' vurl        .do        .action
    6 B" Q% ?5 r& L分发控制        AtcionServlet        FilterDispatcher& b. s7 J' z, T/ e& e+ A
    收集参数        利用JavaBean技术,将数据封装到ActionForm的子类中;
    9 A; e" t- j* ]  Z# ~9 ?一个Action对应一个ActionForm的子类  l" F/ N4 l1 P; `7 J
    7 |2 Y. l& M. J
    使用拦截器将数据封装到值栈中。3 C0 D' }, x5 X1 W. {% h( E% ?$ u
    使用域模型,一个Action对应多个值栈中的Model
    + ]) _" P5 Q2 m- v2 f0 T+ k
    1 ]3 b; m/ C; K* Q读取配置文件        ActionMapping        Configuration Manager! Z% m0 N% x2 k  ~! q" O
    拦截器        无拦截器        执行Action前后有拦截器5 o/ ~4 N) r. O5 N) L
    返回页面        将字符串封装到AtcionForward,进行跳转页面        Action中直接返回字符串,通过Result跳转页面# S+ v( R* u" x% q9 @# ~
    页面跳转方式        两种:dispatch,redirect        三种:dispatch,redirect,chain
    6 [3 L( l5 E7 N+ f2 |值栈        无值栈,Action通过在request范围内设置属性,向jsp页面传递数据        有值栈,Action和jsp页面通过值栈传递数据,jsp页面通过OGNL取得值栈中的数据0 R% I. h) A5 H& z
    配置文件        struts-config.xml        struts.xml5 B7 n9 Z; |& Z4 ~: B
    中文问题        不能解决(需要使用filter)        可以解决中文问题:$ F# d6 K8 {3 L, K
    1、在jsp页面添加Meta;% _0 n* t  c, H3 g& z0 H( H
    " @2 y, F. d4 }
    2、修改struts.properties中的设置。
    回复

    使用道具 举报

    admin    

    1244

    主题

    544

    听众

    1万

    金钱

    管理员

  • TA的每日心情

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

    [LV.5]常住居民I

    管理员

    18#
    发表于 2014-12-03 12:49:03 |只看该作者
    其他开发工具和技术7 F0 g) H5 v0 \/ h" _2 E* r8 N
    Ant4 C5 j! ~* Y' `, T# g: N
    Ant是基于java的批处理工具6 ?# c7 I6 d5 b, T" x9 y4 B% g
    % ~. q9 V( D# i9 j  w4 A7 t
    一、配置ant的运行环境0 S" q8 O1 a' p; |

    ) x$ v  Q+ v. h  @& k" G1 t& t0 i1 ]& [, Q1.将ant的bin目录添加到path中7 I! ^+ a! M9 k6 G0 f- f

    0 w6 h+ _# I4 T6 I1 q/ c) ]9 D2.配置JAVA_HOME
    8 h8 x0 A' _, Q! A  }$ x9 Q) V0 G1 P$ a/ D6 b. m
    3.配置ANT_HOME
    * \2 _3 w6 N7 B4 J- V! ^$ u: q6 o1 b; r  t4 {  i
    二、配制build.xml文件,该文件放在应用程序的根目录下
      b9 M% E5 w  Q6 H, H% }- i0 X* L# X8 d  n. c$ P
    编译java文件- a' q( m5 q) H0 F. d) {! S
    7 u# b$ P; Y  n
    执行java文件
    5 l1 M* p9 C0 ?3 \! U! b! f/ \, i/ s! C- y' l
    copy* I7 [. |; {- i  B* c$ n2 `: ^4 x
    9 i4 I, X( t- C5 P' Z9 Y3 Q
    删除( ?+ k. l; M, M% q, H
    4 g+ e  }, C- T3 a7 G7 T0 J) n# C
    打jar包
    ) b/ A% O* _( M. A2 e7 d1 Y$ Y
    / z- a: O" Q. c根据注解生成配置文件
    5 Y! J9 _# L. f. {- f3 p# u) f: i/ F; c! c
    Xdoclet
    1 k' X1 \0 f* M7 i通过注释生成一系列文件的工具(txt、xml、java、html等)
    1 b9 e1 l" |6 B2 Z% |7 `7 b8 i" K' N, X( J! E' [5 W( X5 P
    xdoclet本质是摸板技术+字符串的替换
    9 Q3 C0 r7 v( L7 U
    1 t  V& ^9 u/ W5 q* Z+ U1.在java文件中写符合要求的注释(将hbm.xml文件的内容搬到java文件中去写)
    $ p5 j' H/ w0 q7 a$ N* j
    , Y5 [/ Z% e! [. }4 v% }1.1 在类的上面 写与表的对应! Q1 q( u) W) G, o' ]: y9 _
    6 n& N# T& x% g. H/ ^5 M
    1.2 将每一个属性的注释都写到get方法的上面; x# q: u9 w- R* L& j, J
    # W" O1 x/ y8 K" L
    2.在ant中引入相应的task来驱动xdoclet
    / J2 Q. Q9 `+ M& b$ Y5 R1 R/ ^+ p, v) j5 x- E) U- b% A

    + M/ i- h7 [% a, `/ R4 ]0 \- b2 D/ W+ m! l5 y+ t
    log4j日志管理
    ' ?4 }$ B, ]7 ~) {" R1、是什么?
    # t! s- Z! B# i# M, [$ `1 m! B. r3 B9 Y5 t4 Q' h  Y" Z$ _) V
    在开发期间用来测试、对整个日志信息进行管理的工具
    + q1 y! }, h. t# e- k7 C* S/ f% I3 {0 G6 b
    2、功能
      [6 J$ V7 S; {) K* c, M/ M1 @$ E# c8 Q
    1.控制输出的目的地9 x" |& D& J1 ]* l# k) B- J7 t
    - B' _  j  ^3 D
    2. 控制输出的格式
    / Z8 ?: S; Y" E. b, ?# X7 w6 ?7 S) @; M) _% t
    3. 控制输出的级别0 {3 R; m1 _2 d$ C
    2 x2 I7 T- S  @; B# V3 _  B
    3、日志的级别
    9 i1 ?' }( T# {4 l4 Y
    2 D# H9 R  z) e+ y+ J* y1. debug 调试! S! j9 Y+ A% g9 |% b
      e1 @! ^5 T8 c3 Q4 _
    2. info 给用户的提示信息
    1 k: ]8 C) _4 X4 @1 x& X7 s2 x/ v3 {/ c& g1 U  {
    3. warn 给用户的警告信息
    ( C9 A, G& d/ _; Z" ~6 ~) S8 i5 [: r, h1 R+ B5 z
    4.error 给程序员用来调试
    + t) l) j% Z8 V. c( ?+ S# S) i
    - X$ ^4 N, V/ @# y, b5 |% fDebug—-〉info—-〉warn——–〉error3 d- x6 L) x+ S0 {8 Y7 `9 d

    : d+ i) P6 `, X; r4、配置
    ) f5 C' J" l" {6 D7 `' u! a+ l2 j5 M" o
    1.配置级别
    6 j* }3 h2 |+ K6 A5 W# N1 S
    + h2 l4 k3 E3 D# G: D; {- P2.输入源 (控制台和文件)* S; I& g/ h) H' N, Y

    1 p2 h% {/ R, G% m3 I% Q3.可以进行分包控制& z" ~  Y$ \4 j# ?) h

    3 W& l) Q. J# q% wLog4f.logger.包结构 = 级别. Y, [5 t; ?4 e, ~

    ) x0 Y- s" D, O0 w6 j1 X0 k' W5、使用. |6 R. V3 u* ]/ ^' p9 w' a, o; x
    2 I  ^( T" v3 N0 S
    Logger log=Logger.getLogger(Test.class);
    ( E& o  |% X* K+ j+ M6 G' x
    # c% ^) r* \% j+ z: {2 ?7 ?! u' i- m    public5 r" f5 W! G# m4 [$ z% v6 M9 @
    void t3(){
    1 f2 Z) m- \- {7 ^( I1 c- T" [+ U6 D$ t1 ]- S+ ^+ u' {
            log.debug(“this is debug”);
    ( N# f* x' [( h6 X
    , s, b! F* R" s7 W6 _; x        log.info(“this is info”);
    1 C& X$ q- k8 C  C) B  V' G0 [8 j* |2 k6 N% T
            log.warn(“this is warn “);
    9 F5 V. F+ \: v+ `3 E. E4 Z) b
    2 ^( Q  p) Z' V. O/ H3 G+ r        log.error(“this is error”);
    " @; C7 a* u4 W3 h) \* D; v* _& n+ R3 D) D9 N( I- _
        }
    $ J1 S, S* W4 S' E8 ]- ]; S6 u6 Q1 T3 A2 N) `# p* O5 k. u0 N
    Junit. N! b7 q9 q# W4 F( t, B; r% ?
    1.是什么?8 p" w6 p( ]7 e4 z$ Q

      `" j  M* w$ V% w) D" m$ p5 ?单元测试的框架/ i+ n7 b# w# y+ r0 x. d- U( ~& ^
    6 z: u$ G3 u! z+ z: R# f4 A
    2.怎么做?4 v+ i* j$ D# c+ P( }
    ! W9 `+ K) ^0 C. y. f: A. i
    写一个类继承TestCase1 i( Z6 T5 K+ ^1 {1 O; p* \

    : h" ?( [* _7 ^. @+ l3 x测试的方法一般都以test开头并且没有参数: f& ]# C$ r3 V3 v" ?! [- F
    " r9 c" C4 e# S9 Q
    在测试方法前执行的方法public void setUp( )' a# l/ X8 U9 `. N  ?

    0 D9 O! t( m9 d) q4 n$ K8 X在测试方法后执行的方法public void tearDown( )# Q; a. X% n0 M+ Y2 U$ Z2 J- ]9 }
    6 }- d" `+ h) U# F. m7 ~
    error和故障的区别
    ( ?: `/ @/ e! }" R3 E5 I: B" H" }2 E
    error :代码有问题5 f! A: R% S$ M' K
    8 K5 E; K1 f$ {9 k6 i- A9 c$ q+ }
    故障 :逻辑有问题与祈望的值不相符合
    1 i5 `# j( B: b
    : ^" K& x$ J. R2 a; R$ p生命周期
    / Q# m! p1 ?' ]% ^& p
      [' T2 p/ O7 _6 s2 d测试—〉SetUp()—〉testXX()—〉tearDown()—〉结束;
    1 C: J/ D  y3 Q$ x
    ) s/ I( U6 I- V4 I, YTestCase套件
    # e: Q  O: `1 y% P6 Y% O- h
    : ]  X+ b( f# \public class MyTest{7 ^$ B2 q* V# m
    / ~- `: C, U+ k+ k  v5 y7 E, z
            Public static Test suite(){
    " u! Q6 a/ j& \/ V; y: i8 W. z& W; ^: X7 {2 X! ]$ K6 a0 ?. }$ ]
    TestSuite suite = new TestSuite();
    : J  Z9 T5 x# i8 ^3 Q) X+ s
    ( n+ J3 _% R2 L7 bsuite.addTestCase(Test1.class);
    5 C4 K( k" G8 q" y/ y6 }  F2 X! H5 N9 |" |4 ]; [4 e) V  `
    suite.addTestCase(Test2.class);
    % s0 F' v/ I9 f. X, ?6 d+ ?0 n. x+ M+ U$ E; O
    }
      d+ _5 B# U& W, M! T
    7 a4 L, {& A* s}
    . Y2 O. z6 H8 O7 b: p: \8 R! ]  d. k4 d" q' |

    3 u. V8 T# Q2 T+ G; M* I8 i# H' R# J! V) `, S. D$ Q  l% I
    Ajax2 A7 T8 b1 y# G2 Q
    是什么?. U/ ~! z; O# x, N& o/ G5 {
    AJAX即“Asynchronous JavaScript and XML”(异步JavaScript和XML)。是一种创建交互式网页应用的网页开发技术。
    - P% o$ m* h- Y( P$ v8 t4 r7 j$ e' w  }/ @
    无刷新页面。
    4 }/ G. m: |! v' Q, n$ {1 F9 j( x: m1 u$ x5 x
    有什么?
    % l: \* q! Q/ c# i4 R. Z- d* u* dAJAX是多种技术的综合,包括JavaScript、XHTML和CSS、DOM、XML 和 XSLT、XMLHttpRequest。" n9 o6 O- P( y$ u8 X+ }$ D. K( k

    / U9 o4 {' ?. r4 R0 p. d- n8 f能干什么?* B6 C$ \3 B# \
    使用XHTML+CSS标准化呈现;
    # O  F& V( Y  p使用DOM进行动态显示及交互;
    9 A( O/ A4 X9 n使用 XML 和 XSLT 进行数据交换及相关操作;
    5 w2 Y. g5 K  j$ W/ }使用 XMLHttpRequest 进行异步数据查询、检索;8 t6 ]  z6 H/ R, f' g
    使用JavaScript绑定和处理有所得数据;- ?% w; J2 \7 T- N
    , \7 _1 E1 ?: m8 w
    传统的web应用允许用户填写表单(form),当提交表单时就向web服务器发送一个请求。服务器接收并处理传来的表单,然後返回一个新的网页。这个做法浪费了许多带宽,因为在前後两个页面中的大部分HTML代码往往是相同的。由于每次应用的交互都需要向服务器发送请求,应用的响应时间就依赖于服务器的响应时间。这导致了用户界面的响应比本地应用慢得多。4 M! p0 ~" B$ B' Y
    . D6 M; X# l3 k6 X( L) M' P
    与此不同,AJAX应用可以仅向服务器发送并取回必需的数据,它使用SOAP或其它一些基于XML的web service接口,并在客户端采用JavaScript处理来自服务器的响应。因为在服务器和浏览器之间交换的数据大量减少,结果我们就能看到响应更快的应用。同时很多的处理工作可以在发出请求的客户端机器上完成,所以Web服务器的处理时间也减少了。  z) I2 R7 }3 W+ R8 G8 J" g

    ! j  U( [- h" N. I+ y" C- C# j使用Ajax的最大优点,就是能在不更新整个页面的前提下维护数据。这使得Web应用程序更为迅捷地回应用户动作,并避免了在网络上发送那些没有改变过的信息。% T' H! Q! U6 F: I# x' k
    ) q) f9 ?  k! V5 _7 I( b, z( Y
    对应用Ajax最主要的批评就是:
    1 \$ {% X2 Z9 w8 M5 z9 e4 p- u$ }1 它破坏了浏览器后退按钮的正常行为,就是用户点击后退按钮后不能看到之前的数据;  Z! Z% y* l$ {' k
    2 一些手持设备(如手机、PDA等)现在还不能很好的支持Ajax;; S3 O2 @$ t; M
    3 用JavaScript作的Ajax引擎,JavaScript的兼容性和DeBug都是让人头痛的事;
    7 V+ Z* X5 z9 B- p2 u4 Ajax的无刷新重载,由于页面的变化没有刷新重载那么明显,所以容易给用户带来困扰――用户不太清楚现在的数据是新的还是已经更新过的;现有的解决有:在相关位置提示、数据更新的区域设计得比较明显、数据更新后给用户提示等;% q# I6 z; Z9 W
    , D; }8 Z4 P& p4 P
    怎么做?4 G( m% Z, L+ O" s
    <script language=”javascript”>
    / b7 j/ l' W2 w% y9 d/ K2 g3 C& d" a. r7 f
    var req;
    $ ]& K/ Q. c% P+ ^
    ! a$ D9 I! R' T+ H1 ]5 cfunction add(){
    0 Y6 `3 d( m4 `9 c% U
    6 ^5 U. ^1 _) n" \//1:创建用于传输的对象
    4 [2 C: F$ j, @& S/ E0 Q! A/ r# [, d* D
    req=new ActiveXObject(“Microsoft.XMLHTTP”);
      ?, g$ P- N/ m2 q% W5 h. @0 Y! h4 ~) p5 E
    // 声明返回后,处理数据的方法4 G" u* J" N( m% k7 O
    # n+ B8 P# L% `
    req.onreadystatechange=manage;1 X/ o5 [  `% m% \) o% ~/ M

    0 B6 _: \. F+ J; v) H; {* r- g//2:准备传输的内容3 |) q9 L8 o6 g" b% y* s0 |% _
    8 \8 t0 f- a, j$ m) A
    var str=”test1111″;0 w: y' y  |+ w. r1 Q+ j

    1 H3 _' H' f% L$ H# `//3:发出请求. ]/ r7 E6 }- C1 H1 C( d
    ! V) G( F% a: y* i
    req.open(“GET” ,”/others/ajax/test/t2.jsp?str=”+str);
    0 B( a1 V5 `6 c( `% x0 N/ P8 a0 t. B+ P9 v/ C
    req.send(null);
    ( @. _/ Z) }4 D& W' v* o2 `& Z8 g
    ' G& w; r3 h% a# P}- u/ g2 U; n/ w) x- r  G* J7 Q
    5 I! H( Y: x7 a/ ~# O* }; T5 A3 q
    //4:接受返回并处理& O  G! k: L7 E. }' @

    7 H# F& z2 y7 Vfunction manage(){
    ' g# P9 P. N5 x) f- o: |4 j% J4 O4 U
    if(req.readyState==4){9 z# t  t! A: e: I" q* j" A
    ( V2 i; x& E' N- M
    alert(“r==”+req.responseText);
    9 k- n* |. b- Q: y3 u
    & O. T% w) l, t8 h2 {}+ e. q$ |- p4 _# ~6 d: x" ?

    $ p( G+ s4 D" n- ?! s& }! @# m. v}
    7 o, H3 s3 |  Q/ y
      G& z  s+ ~- j3 h7 T4 ?* g</script>
    ; C2 g  {  B& |4 J/ t- D# V+ u7 i/ L  j( K( p0 P3 b: b+ m
    readyState的取值如下:5 h: @. ]+ H" p9 ~+ v  `

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

    ; I6 @& Z# k7 j. g, u, o  3 (交互中). z8 y- |9 R4 k9 }: g+ q6 w4 P0 V

    * ^( a, p  U' n1 `2 d% z8 ~3 a7 B. Q  4 (完成)% r+ O) x. R- b$ g$ z. W& W6 t& n# e
    : B) i7 f  d6 ~

    . |; t; \1 ?% W  j7 h. t) _) {7 l% \5 Y& A5 r& P
    原理8 V; k0 ?& g! r  \$ _
    Ajax的原理简单来说通过XmlHttpRequest对象来向服务器发异步请求,从服务器获得数据,可以是xml格式,也可以是一个字符串,然后用javascript来操作DOM而更新页面。- \8 ^& Q; l8 ^: N. ?* ]. i; `

    4 J* i: q& T' oDwr
    9 M& x2 n" J( C' y1 C, U是什么?" ^. n2 |1 t: P9 G# l
    DWR(Direct Web Remoting)是一个开源的类库,可以帮助开发人员开发包含AJAX技术的页面。它可以允许在页面中使用运行在WEB服务器上的JAVA函数,被调用的JAVA函数就像是在页面中JavaScript方法一样。
    8 \  R3 V: c" B6 v3 v; j& E
    / U: T" \2 |: m$ k8 v) L- p有什么?
    / o: B  K4 m$ {它包含两个主要的部分:允许JavaScript从WEB服务器上一个遵循了AJAX原则的Servlet中获取数据;另外一方面提供了一个JavaScript库可以帮助web开发人员轻松地利用获取的数据来动态改变网页的内容。$ f7 Y0 n2 z/ K! Q. ?
    2 ?! [8 a' L' Q
    : h1 N( m. N" ~3 r+ E/ x/ Y
    # h% M; u1 H% t1 T6 U; \
    能干什么?
    ( g% H' y1 _" @/ X' H动态地把java类生成为JavaScript,感觉调用就像发生在浏览器端,实际上代码调用发生在服务器端,Dwr负责数据的传递和转换。这种从Java到JavaScript的远程调用功能的方式使DWR用起来有种非常像RMI或者SOAP的常规RPC机制。  X, }4 l" M5 f5 A# T6 {4 a, c
    ) w. F  }+ w2 h2 y
      G) M, H5 [+ K/ R  n5 M

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

    - p8 M( Y8 M2 k# W8 c7 O. D$ F<servlet-name>dwr-invoker</servlet-name>, w3 H3 [% p2 }' @! d" L

    % j* J: `' I6 p* ]<servlet-class>: A$ g2 V2 r: Y+ `& L" Q- A
    ( d7 z  I) M9 {/ W9 M3 c
    org.directwebremoting.servlet.DwrServlet8 K9 g% v  Y8 Q' ~/ @+ E( O* L

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

    5 @$ C- V8 g; y! A<param-name>debug</param-name>/ @5 N" F6 R9 S( {$ Y0 U" F0 c

    ( w5 x" W! M- a<param-value>true</param-value>
    9 G/ _# s$ C2 M( E5 I, \4 o, W$ H4 s0 `, o' k% Q
    </init-param>4 _# [8 ]' {7 h/ ^+ C8 {1 D' S; m" m

    4 i  V2 u, Q; x</servlet>
    1 r; ?$ W  h% @+ W5 x! P
    ; Z$ }2 P: p% X$ i<servlet-mapping>- U6 ]% i( B1 J; ]* z1 k# J: {
    . h1 s3 x$ Q+ R( n# e
    <servlet-name>dwr-invoker</servlet-name>% {) c1 X* X- f& Y
      b9 I, e2 ?; {% a2 ~% R4 p
    <url-pattern>/dwr/*</url-pattern>& N* Y8 k5 w* P

    ; }' d: `1 A5 Y</servlet-mapping>( ]8 C" P" J! ?. J; Z; [- [! x* v
    4 N. Q# Z3 _$ x6 u# b/ {! I
    dwr.xml0 w" O0 x" q9 ^5 ~  s6 [# C
    , X1 O! e- S, S1 @
    <allow>9 D8 n( X$ q2 B( x7 @5 ~6 l

    ! g) v8 Z* w# }<create creator=”new” javascript=”kc2″>
    - U* l! m6 J, d1 o  w' K" ?) B" n# \  B
    <param name=”class” value=”dwr.Service” />' o) Y+ p$ a6 O: o

      j# D( ~6 X/ N$ U" f</create>
    ' j6 @1 z3 E  _2 F8 D9 v. U! w, `* U( \- a8 E+ \; t! @7 E; n, |
    </allow>
    ' @2 m' ?4 O/ w) [; D* d+ P' i" Q% I1 c" J+ J6 l8 A2 \/ |8 o- M6 t0 a5 y
    ②编写service- t+ P6 [6 M! D1 ]+ K

    6 J$ t4 D# L+ m# ^# k7 d( o; mpublic class Service {
    # U9 h! _5 x/ X4 q
    $ I; S8 j+ k* z/ m4 e+ Wpublic String sayHello(String yourName) {
    : [- p3 m8 v, `6 I4 |2 e6 U" _! d& [/ V6 K9 b. M! }" ^7 K
    //可以是访问数据库的复杂代码
    0 O9 ?% z  m3 m$ ?1 c# D6 l
    2 B# Z# L% t) I+ F9 |, R# ?return “Hello World ” + yourName;
    - R' z- m5 a% V
    - ?( g2 I" b7 w6 k. ~2 i5 Z}
    6 O8 S5 K/ S' H; r! ?8 Z4 u$ O: S  [' q, V1 Z. J1 N
    }1 |. q+ d; U* p( ?- }/ G
    ' K( F0 B; M# R# r) r8 ?" w" L
    ③测试DWR
    % F7 }" l) U1 @+ E! C; k  v2 z& X; l2 G9 m! `
    将代码放入应用服务器(比如Tomcat),启动。
    % I# p' s$ W" u) G$ r5 c6 ~* A# A- k  N' W# g9 V
    然后在地址栏输入http://localhost:8080/你的工程/dwr4 l5 k  O/ X+ O. a# `" s, o
      G+ M0 c5 \7 M1 r
    ④编写jsp页面  t  U- I+ `; Y! C% P! T" U0 T! G1 I$ Z
    ' Z! @& b( V5 c5 }, d! d( T& d
    1) 要引用3个dwr的js,其中engine.js必须要,如果需要用到dwr提供的一些方便的工具要引用util.js
    ( V6 I: c. k6 Y9 M/ d0 ]
    / b# o1 P# [2 ^: O8 o& w  D- z2) 然后还要引用dwr自动生成的js,dwr/interface/service.js,注意js名字要和dwr.xml配置的一样
    ' @" w0 P' B5 o' f) J0 g7 W+ W8 g8 C" r; O% p9 |) |) m
    3) js里的service.sayHello和java类的那个有一点区别,多了一个参数,用来得到返回的数据
    回复

    使用道具 举报

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

       

    关闭

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

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