SSH架构图及各部分知识点

汪星人

: C+ [8 T, E3 Y# _; L1 J
6 {! x: E" N# a" ~SSH分别是指:struts,spring,hibernate
  p; T! G: i) s' X7 N
7 \7 V) R$ x; M0 d下面是SSH三部分简单主要的知识点:
0 Y+ Y1 F3 K: V$ G% X
Sturts:
% p) _0 r+ L& q* [& W2 Q- G9 i
& @, z. z  w9 h0 g8 W' N( eexecute :
+ B; m2 }. ?' D) h! Q7 r0 c( u! T+ z6 n6 D    execute()方法相当于main()方法,有三种创建模式 :
# M( g+ o5 h5 l) J$ d
1 y3 J% Y: S1 u9 ]3 e    1 自定义类,类里面不能写main()方法,写个execute方法,返回值为一个字符串,和struts.xml里面的<result name="字符串">对应就行
     public String execute() {
            return "success";
8 q2 p/ t9 {) J; k* ?2 @. E        }
! z6 X0 |9 G$ g
    2 实现Action这个接口,并实现execute方法,这里的返回值可以是action接口里面的预定义的常量,当然,如果struts.xml里面的<result name="字符串">这里设置不是预定义里面的,这里就不能写常量,因为这几个常量是底层实现了的,别的还是要自己写字符串,和xml对应上
        public String execute() throws Exception {
            return SUCCESS;//写成 SUCCESS常量也可以
$ ^# Y. ~( {9 }6 n) [$ y$ ~6 L    }

7 i: [# V9 z  e* Y7 Q* p2 Y7 w    3 推荐 : 继承ActionSupport这个类,并覆写execute方法,和第一种的写法一样,但是推荐使用这个,因为这个类写了很多方法,方便我们使用
        public String execute() throws Exception {
. U* }6 B6 [- t) }3 T' m9 Y            return "success";
    }

//充血 贫血 模型 :
   　 把增删改查的方法写在实体类里面,就是充血模型
( _' K0 K; M  F3 Y　　不写在这里面,就是贫血模型
- k2 N* r" c0 \0 o  q7 x6 ^　　pojo:就是一个实体类
  J0 b' p! [+ `* p" E0 F8 ^
7 e- ^. G' f5 X0 N7 H


//拦截器调用 : 调用拦截器

4 i4 J8 O9 p  q. F/ ^    先从最近的模块找  模块(包:com.jaovo...xx).xml ---> struts.xml ---> default.xml ---> web.xml;
    一直到找到,都找不到就报错

, m4 J4 u3 y5 a' d+ c; T, ~( J//后台设置的东西,在Action中设置request和httprequest的区别
% v$ {) O4 K: D5 q
! T2 ]) \5 M9 f6 j- k9 U    <!--
    后台设置的东西,在Action中设置request和httprequest的区别
  s& f' y! o9 {1 c$ j, f* H    在前台通过request,session,aplication可以去得到
  f, k* Z7 i) [    在后台设置的request全部复制到了HttpRequest中去
+ P) A8 [5 o5 R: [9 W; k2 U) J; E    jsp页面中的是HttpRequest(request)
     -->
& U, q9 a4 [6 T- i  L    <s:property value="#request.request_"/> | <%=request.getAttribute("request_") %>//前者是获得Action里面的  后者是获得request里面的(原生)

0 I0 a( b, s& N  F  C) I% c9 D
request : //每次请求,都会创建一个新的request对象
$ P* ?/ |& v) \) a
4 x' H( ?3 H3 M7 D, ~3 ]' F! g2 F( W% fsession : //只要在同一个浏览器,就只创建一次,作用域是整个浏览器,关闭浏览器,session也随之消失,如果没有,就会创建,如果有,就不会创建
# c* D4 ~( U0 F/ j* l# \+ b2 q3 K
; J2 ^/ l3 _' {. Y- C/ z" w; S4 q& qapplication : //只创建一次,可以跨浏览器使用,如果没有就会创建,如果有就不会创建

# Q3 A' D% s. I( F  m4 p
Spring:

; a3 X; a4 d% `, X- w/ `
3 `+ ?- v" s2 S6 n    1 控制反转 IOC : 控制类的实例化,以及他们的调用关系
    2 动态代理 AOP : 主要是事务机制的控制

- X$ \5 t. j  Z! g/ I* Y3 f    四种方式读取属性 四种读取属性的方式:
7 [9 L& |2 d$ q" I8 p! H/ z    1 DOM : //把所有属性都弄到文档对象中,全部读取  一个报错,全部不读取
    2 JDOM : //把所有属性都弄到文档对象中,全部读取  一个报错,全部不读取
    3 DOM4J : //把所有属性都弄到文档对象中,全部读取  一个报错,全部不读取
    4 SAX : //用IO流,一个一个读取,读取一个,放进去一个 哪里报错,报错处往后就不读取,前面读取
+ P) L: h/ W. E) K% R; d8 {
        DOM :  == Document Object Model : 文档对象模型
        SAX : 基于事件和流的方式解析xml
/ x7 w( z6 x5 ?        sax,DOM : 这两种已经加入java的核心包,不再需要第三方宝
" q' p, R9 M, v) N: y2 L0 O. o        JDOM : 是DOM的一种增强版本
+ t+ E' r% v5 H0 A! B9 r. R) W        DOM4J : JDOM的一个子项目
6 [9 L* @8 D+ Z3 K, g3 W5 T
1 D+ A3 O: I3 y5 v//解析XML文件,解析XML文件的方式都大同小异 :
2 Y2 L& N! m7 G3 G
        1 获得根节点
4 k# ]2 l  ~. \8 a9 i        2 遍历根节点里面的子节点
# \5 \, m/ v2 X        3 获取子节点里面的属性
9 R, v0 V  E  T& U        4 遍历节点里面的内部(子节点)节点
( z) b) i' Z) N8 m3 ]# q

+ t" e4 x9 u/ D# P1 m
+ M) _" H  ~( J: xHibernate:
3 h3 ?- }- @1 E  o# r/ P  J
操作数据库7步骤 :
        1 创建一个SessionFactory对象
        2 创建Session对象
5 L" Z" {+ B. N        3 开启事务Transaction　:　hibernate中,然后数据库操作,都必须是事务的,哪怕是查询
        4 执行数据保存操作(必须提交,才会执行对应的操作方法)
. v5 o3 L5 B) ]        5 提交事务
        6 关闭Session
                session.close();
9 u4 n. {* d% G5 K/ Z7 i                getCurrentSession();不需要手动关闭,opensession需要手动关闭
4 s8 y. s0 i0 j. `. Y+ M: q        7 关闭SessionFactory对象
//三种状态 :

  p9 F% y( M" B* y4 |( A( f- h" J* ~        瞬时状态(临时状态)--->持久状态(保存到数据库)--->游离状态(保存完成后关闭session对象 (session.close()))

( c) Q+ L- B1 i6 S    //三种状态的区分关键在于
. s; r2 w* `. C7 B! t        1 有没有ID
        2 ID在数据库中有没有
" l! h/ K# x- \; t        3 内存中有没有(session缓存)

Transient :

) `$ L$ l1 h: s( X" Y8 `    Transient(瞬时状态) : 内存中一个实体类对象,没有ID,缓存中也没有
    //实例化实体类的时候,就是瞬时状态
$ U+ P$ i0 i1 W
5 Q; Y9 e9 p& M' \2 F4 }# a* A* ^ Persistent :

9 E, A4 a4 B% ^( h1 q    Persistent(持久状态) : 内存中有,缓存中有,数据库中有(ID)
    //保存到数据库中,就是持久状态
. \; h6 ^) Q% I' a2 q9 h
Detached :
. n3 w$ h5 S4 k
4 E$ b2 F; }; T# l% I    Detached(游离状态) : 内存有,缓存没有,数据库有,ID
    //关闭session对象之后(session.close()),就是游离状态
% T; m2 E% E$ C6 A" q
    //这三种状态需要关注的问题是在该状态下,如果进行数据库操作会发生什么结果,比如改变属性的值会不会发出update语句
6 L4 d3 y/ V3 O) U. Q4 D
        瞬时状态 : 不会发出update语句
, {: p# I/ W& X; T* k: U3 ^; h1 l        持久状态 和 游离状态 都会发出update语句
2 Q4 i) U1 `. B

刘继仆

很不错，讲得清晰，