eeeeee

/**
* 2010年2月26日 cloudy
*/

1、 why
给应用程序（web 应用、桌面应用）的各个层的实现带来帮助

2、what
1） Ioc: Inversion of Control （控制反转）
创建对象以及建立对象间的关系
2） AOP:
面向方面编程 Filter 拦截器的思想
不修改源代码的前提下，增加系统级别（事务，权限，时间，日志）的功能
3） DAO 以及和 Web 开发框架的结合

第一章
1、 spring 的核心：
Ioc 容器：完成对象创建，对象装配的问题
2、 Spring 即可以为 web 应用开发带来方便，也可以为桌面应用开发带来方便；
3、 可以根据需要只使用　Spring 的部分子框架；

第二章
class A{
}

class B{
A a;
public void setA(A a){
this.a = a;
}
}

//对象关系的装配置由程序员手动的完成
B b = new B();
A a = new A();
b.setA(a);

IOC ： 控制反转 又名依赖 注入
将对象创建的控制权以及对象关系装配的控制权由程序员转给第三方
（不需要建立对象也不需要建立对象关系的控制权利）

依赖： 对象之前的关系是依赖关系
注入： 由第三方软件完成

Worker
Interface Axe
StoneAxe
SteelAxe


duration trace
－－－－－－－－－－－－－－－－－－－－－－－－－－－
－hour:int -name
－minute: int -duration: Duration
－second: int -toString(): String

IocTest3
－－－－－－－－－－－－－－－－－－
将XML文件解析。。。。。。。。。。。。。。。。。。。。。。。。。。。Spring的原理工作

注入方式 ：
1、接口注入: Spring 不支持
通过方法参数（参数通常声明为接口）的形式建立对象的关系
class A{}
class B{
public void m(A a){
a.n();
}
}

2、构造子注入：Spring 支持
通过构造器参数的形式建立对象的关系 此时不需要完成 属性的 get/set 方法
class A{}
class B{
private A a;
public B(A a){
this.a = a;
}
}

<constructor-arg value="30" index="0" />
通过 index　可以改变其属性的位置，可以立刻完成参数的传值的完成, 并且严格控制其属性的顺序　

3、传参注入：
　通过　setter　方法建立对象的关系　　　
class A{}
class B{
private A a;
public void setA(A a){
this.a = a;
}
}

<!-- Spring 2.x 中才有scope 属性
在 Spring 1.x 中只能通过 singleton="true｜false"
-->
<!-- scope: 默认的值是：
singleton 单例
prototype: 每次获取一个新的实例
request: 一个请求创建一个新的实例
session: 一个会话创建一个新的实例
global session: portlet 门户网站
-->

实例化对象的方式：
1、构造方法
<bean id="" class="" />
2、静态工厂方法
<bean id="" class="" factory-method="" />
3、实例工厂方法 区别在于有无static 修饰
<bean id="" class="" /> 需要 先将工厂方法所在的类型进行实例化
<bean id="" factory-bean="" factory-method="" />
public abstract class Calendar

<bean id="c" class="" abstract="true"/>
<bean id="c1" parent="c" />
<bean id="c2" parent="c" />
达到配置信息的重用的目的。
4、通过 FactoryBean 的 getObject() 方法实例对象
<bean id=""　class="FactoryBeanClassName" />
返回的是 FactoryBeanClassName 中的 getObject()　方法返回的类型而不是
FactoryBeanClassName　的类型

自动装配：
自动实现对象间关系的建立。
auto-wire="byName|byTye|constructor|all"

BeanFactory.getBean() －－＞ Bean 对象

Bean　对象　－－＞　BeanFactory.getBean() －－> 其它的　Bean　对象......

class MyBeanFactory{
private Map map = new HashMap();
public Object getBean(Strin id){

}
}

/**
* 2010年3月1日 cloudy windy
*/
AOP: ASPECT-ORIENTED PROGRAMMING

ch03:
AOP: 在不修改源代码的前提下，增加或移除系统级别的功能；
1、 静态代理
给每一个目标对象类型创建对应的代理类
如果两个类的话，共同的实现一个接口，并且为了让目标对象的功能增强的话，对应的类称为代理类
如果不是实现同一个接口的话，对应的类就称为 委托类


2、动态代理 －＞ 目标对象没有实现接口，没有继承父类 动态代理就没有作用 Spring 实现
代理类由虚拟机在运行时创建
1＞ implements InvocationHandler
2＞ 实现 Object bind(Object target)｛｝
3＞ 实现 Object invoke(Object arg0, Method arg1, Object[] arg2)｛｝


3、动态字节码生成 －＞ 对于 final 修饰的类不适用 Spring 实现
由框架 CGLIB 在运行的时候创建 生成目标类型的子类型，通过重写去实现


4、源代码生成 －＞ 只局限于 EJB 容器中
在编译的时候就完成，适用于 EJB 容器，可以根据配置文件在编译时生成辅助类型源码

5、类加载
在 JBOSS 中可以实现在类加载的时候改变类的行为，管理 Servlet ，EJB 的生命周期
6、AspectJ
从语言级别上支持增加系统级别功能

AOP：中的一些概念
1、Aspect:(方面） 概念意义上的系统级别功能；
2、Advice 增强： 代码意义上的系统级别的功能；
前增强
后增强 抛出后增加，返回后增加，后增强
环绕增加
3、JoinPoint 连接点： 将增强加入至目标对象的位置；常见的有方法，其次是属性。
4、PointCut 切面： 一系列连接点的统称。
5、Introduction/Mixin 混合体： 凭空新增加的方法或属性
6、Weaving 织入： 将增强加至目标对象的过程：

ProxyFactoryBean的表现形式
public class ProxyFactoryBean implements FactoryBean{
public Object getObject(){
return Proxy.newInstance(....);
}
public class getClass(){

}
public void setProxyInterfaces(Class[] a){

}
......
}

/**
* 2010年3月2日 rainny
*/
事务的作用：将多个操作组合成一个不可分割的操作，同时成功，同时失败，保证数据的完整，一致；
原子性，隔离性，一致性，持久性 ACID
事务的控制：
.开始
SQL*PLUS连接 Oracle
1、连入数据库
2、上一个事务的结束
JDBC: conn.setAutoCommit(false);
Hibernate: session.beginTransaction();
.结束
SQL*PLUS连 Oralce commit;
JDBC: conn.commit();
Hibernate: tran.commit();

.回滚
SQL*PLUS连 Oralce rollback;
JDBC: conn.rollback();
Hibernate: tran.rollback(); 在 catch()语块中

单个数据库的事务： 依赖数据库本身实现事务的控制；
分布式事务： 依赖事务管理器实现事务的控制；

CMT: container（读配置文件） manager transaction
BMT: javaBean manager transaction <-> 在 EJB 中涉及

Spring 简化 Hibernate 技术操作：
1、 HibernateDaoSupport:
.获取 ＨibernateTemplace;
2、 HibernateTemplate:
.获取 Session 对象的代码；
.通过 Session 进行 CRUD 操作的代码；
get/load 操作的是 主键， 如果 操作的不是主键就需要 hql 语言