Spring 优势：

控制反转（ioc）---开发人员不必再在代码中维护对象间的依赖关系，通过配置文件来实现

1、模块之间不进行直接相互调用 2、抽象类不能依赖于实现类 3、应用不应该依赖于容器

面向切面编程（aop）

持久层的封装和事务管理---提供了对持久层的整合功能

提供了对web的各种支持

oop提高了代码的重用 设计模式解决了模块间的耦合 aop解决了某个模块内部的变化

持久化：

1、通过会话bean和实体bean来实现数据持久化（该方法会耗费内存，影响系统运行速度）

2、通过dao和jdbc来实现数据持久化

3、通过dao和orm组件实现数据持久化

耗费内存和性能对比 1大于3大于2

spring事物管理的核心功能框架有3个接口定义：

1、PlatformTransactionManager

org.spirng.framework.transaction.platform.TransactionManager

该接口有3个方法：

void commit(TransactionStatus status)

void rollback(TransactionStatus status)

TransactionStatus getTransaction(TransactionDefinition definition)

2、TransactionDefinition

用于定义事物策略。

int getlsolationLevel():得到当前事物的隔离级别

int getPropagationBehavior():得到事物的传播性

int getTimeout():得到事物的超时时间

boolean isReadOnly():判断事物是否为只读事物

3、TransationStatus

该接口代表了事物状态信息

boolean isCompleted()

boolean isNewTransaction()

boolean isRollbackOnly()

事物管理的方式有两种：

声明式事物管理：

1、配置数据源

2、配置事物管理对象

3、配置事物策略

<tx:advice id="txAdvice" transaction-manager="txManager"

<tx:attributes>

<tx:method name="get*" read-only="true"/>

<tx:method name="*"/>

</tx:attributes>

</tx:advice>

4、配置AOP

<aop:config>

<aop:pointcut id ="busServiceMethods" expression="execution(* cn.hxex.springcore.business.*.*(..))"/>

<aop:adbisor advice-ref="txAdvice" pointcut-ref="busServiceMethods"/> </aop:config>

注解式事物管理：

spring jdbc抽象框架有4个核心包组成:

core(核心包) 核心类----org.spring.framework.jdbc.core.JdbcTemplate

作用：通过该类可以方便执行数据的增加、修改、删除、查询语句，并且可以完成对存储过程的调用

jdbcDaoSupport类不是一个操作的模板类，它是为了提供对DAO的支持

dataSource(数据源包)

object(对象包)

support(支持包)

orm-----对象关系映射

2001 hibernate第一正式版本发布

2002 6月 第二版

2005 4月 第三版

hibernate进行持久化操作的步骤：

1、创建Configuration对象

2、创建SessionFactory对象

3、创建Session对象

4、开始一个事物

5、进行持久化操作

6、结束事物

7、关闭Session

hibernate常用类：

org.hibernate.Hibernate

org.hibernate.Session 作用：持久化操作的核心（线程不安全）、用于读取，创建和删除 映射的实体对象的实例（这些操作将转化为对数据库表数据的增加、删除、查询） Configuration config = new Configuration().config();

SessionFactory sessionfactory = config.buildSessionFactory();

Session session = sessionfactory.openSession();

org.hibernate.SessionFactory 作用：生成Session对象，一个应用程序只有一个SessionFactory实例且不能改变（线程安全）

Configuration config = new Configuration().config();

SessionFactory sessionfactory = config.buildSessionFactory();

org.hibernate.Transaction

用于管理事物 commit rollback

org.hibernate.Query 作用：执行HQL语言并完成对象的检索操作

org.hibernate.Criteria

org.hibernate.ScrollableResults

org.hibernate.cfg.Configuration 作用：读取配置文件并创建SessionFactory对象 创建Configuration对象实例的方法：

Configuration config = new Configuration().config();

hibernate会自动在当前classpath指定路径内查找hibernate.cfg.xml文件，并加载到内存里

还可以直接指定路径创建该对象:

File f = new File("d:\\e\hibernate.cfg.xml")

Configuration config = new Configration().config(f);

实体对象的3种状态：Transient(瞬态) Persistent(持久态) Detached(游离态)

实体对象的操作方法：

save() 相当于数据库执行insert语句（可以将Transient状态的实体对象变为Persistent状态）

User user = new User();

user.setName("ddd");

user.setPassword("ddd");

Transaction tx = session.beginTransaction();

session.save(user);

tx.conmit();

session.close();

Session对象的save（）方法进行了以下工作：

1、将对象加入缓存中，并标识为Persistent状态

2、根据映射文件配置生成实体对象的唯一标识符。具体生成方式方法由<generator>元素决定

注意：如果配置文件中指定了<generator>元素，那么在这里通过调用setId()方法来为其人为

设置主键的做法将徒劳

3、对于指定了<generator>元素的实体对象，如果希望自己指定主键值，可以调用Session对象

的save（）方法的一个重载方法save（Object object，Serializable id）来实现

update()

User user = new User();

user.setName("ddd");

user.setPassword("ddd");

user.setId("234234");

Transaction tx = session.beginTransaction();

session.update(user);

tx.conmit();

session.close();

当事务结束后，实体对象的值才会更新到数据库中

注意：不是所有更新操作都在事务结束后才执行，当后面需要执行同表数据库查询时 ，为保证查询结果的准确性，这时候数据库更新会被立即执行。

通过在同一个Session中调用get（）或者load()方法，也不能导致数据库更新语句立即执行

saveOrUpdate() hibernate依据实体对象的状态决定执行哪种操作，如果传入实现对象是 Transient状态，那么执行save（）操作；如果传入实体对象是Detached状态，就执行update（）

状态；如果传入的是persistent状态，就直接返回，不进行任何操作

delete()

User user = new User();

user.setId("234234");

Transaction tx = session.beginTransaction();

session.update(user);

tx.conmit();

session.close();

get()

通过该方法只能得到唯一的一个持久化对象，如果该对象不存在，那么返回值为空

load()

通过标识符得到指定类的持久化对象实例。和get方法区别是要确保要得到持久化对象实例的存在

否则将产生异常信息

contains() 用于判断一个实体对象是否与当前session对象关联，可用来判断实体对象是否 处于persistent状态

evict() 用于移除实体对象与session对象间的关系，将实体对象由Persistent状态转为Detached

创建查询对象：

createQuery() 创建一个query查询接口实例，该实例可以利用HQL语言进行数据库查询操作

Query query = session.createQuery("from User as u where u.age > :userAge"); query.setInteger("userAger",20);

List list = query.list();

createCriteria() 创建一个criteria查询接口实例

OBC查询，将数据封装成一个对象

Criteria本身只是查询容器，具体通过调用add()方法进行添加

List cats = session.createCriteria(Cat.class)

.add(Restrictions.like("name","Ix%"))

.add(Restrictions.gt("weight",new Float(100)))

.addOrder(Order.asc("age"))

.list();

相当select * from cat where name like 'Ix%' and weight>100 order by age asc

createSQLQuery() 创建一个SQLQuery查询接口的实例。可以通过标准的sql语句来执行操作语句

createFilter() 通过一个对象的集合一下查询的HQL语句来生成一个Query对象实例

hibernate三种检索方式：HQL（面向对象查询语言）、QBC和SQL

对HQL进行查询，参数有三种处理方法：

1、直接将参数拼接为HQL语句

Query query = session.creareQuery("from User as u where u.age>20");

List list = query.list();

2、通过参数名称来标识参数

Query query = session.createQuery("from User as u where u.age > :userAge"); query.setInteger("userAger",20);

List list = query.list();

3、按照参数的位置设置参数值

Query query =session.createQuery("from User as u wher u.age>?");

query.setLong(0,20);

List list = query.list();

三种绑定参数的查询方法建议使用第二种方法

第一种拼接语句不易维护，每执行一次都要进行解析和运行，不利于发挥数据库缓存的作用 第三种方法维护麻烦且不直观

返回结果集的三个方法：

list() 返回一个list对象，可以按照索引的位置随机访问结果集中的对象。

采用该方式hibernate将所有数据都转化为实体对象，不管是否用到该对象，照成资源浪费

iterator()

返回iterater对象，只能按照从前到后的顺序依次读取数据库记录。

优点：不用一次读取所有数据并转为实体对象，避免了资源浪费

缺点：只能按顺序查询结果集，不知道结果集中记录的数目

uniqueResult()

返回唯一结果对象，在确信只有一个满足条件的记录时使用该方法

hibernate3新特性，支持批量数据更新和删除，通过Query对象

Tansaction tx = session.beginTrasaction();

String hql ="update User set age=age+1";

Query query =session.createQuery(hql);

query.executeUpdate();

tx.commit;

session.close;

Tansaction tx = session.beginTrasaction();

String hql ="dekete User set age=1";

Query query =session.createQuery(hql);

query.executeUpdate();

tx.commit;

session.close;

hibernate映射：

Jakarta commons logging（JCL）组件：日志组件

1、fatal 非常严重的错误 导致系统终止

2、error 其它运行期错误或不是预期的条件

3、warn 错误使用api

4、info 运行时产生有意义的事情

5、系统流程中的细节信息。

6、trace 更加细节的信息

web应用体系结构：

1、表示层（struts------action、actionform、struts-config.xml、jsp）

2、业务层（spring------事物管理、会话管理、业务类）

业务层主要功能：

处理业务逻辑和进行业务判断

事物管理

通过使用接口和其它层交互

管理业务层对象的依赖性

可以增加表示层和持久层的灵活性，使它们之间不会有交互

实现一个业务的上下文，便于表示层调用业务层的服务

管理持久层的实现

3、持久层（hibernate----数据源连接池、查询语言支持及hibernate其它服务）

4、域模型层

数据库的隔离级别：

解决并发数据访问，可采用锁的机制来实现数据访问的排他性，从而避免两次更新问题的发生

锁分为乐观锁和悲观锁两类

悲观锁（pessimistic locking）：悲观地认定每次资料存取，其它客户端也会存取同一笔 数据，因此将会锁住该笔数据，直到自己操作完成后再解锁。（注意：如果在网络系统，该方法会照成效能上的问题）

hibernate缓存机制包括：一级缓存和二级缓存。

主要表现：通过主键（ID）加载数据的时候、延迟加载中

一级缓存：有session提供，它存在于session的生命周期中，当session关闭时候该session管理的一级缓存也会立即消除

session提供的干预方法：

evict()---将某个对象从session的一级缓存中清除

clear()---将一级缓存中的对象全部清除。（当进行大批量一次性更新时，调用该方法，避免内存溢出）

例：

Session session = sessionFactory.openSession();

Transaction tx = session.beginTransaction();

for(int i=0;i<100000;i++){

Costomer customer = new Customer();

session.save(customer);

if(i%20==0){

//将本批插入的对象立即写入数据库并释放内存

session.flush();

session.clear();

}

}

tx.commit();

session.close();

二级缓存：与session相对SessionFactory也提供了缓存机制，分为内置缓存和外置缓存

外置缓存的介质是内存和硬盘，SessionFactory的外置缓存被称为Hibernate的二级缓存

二级缓存的工作：

1、在执行各种条件查询时，如果获得的结果集为实体对象的集合，那么就会把所有的数据 对象根据ID放入到二级缓存中

2、当Hibernate根据ID访问数据对象的时候，首先会从Session一级缓存查询，如果找不到

并且配置了二级缓存，那么会从二级缓存中查找，如果还查不到就去数据库查询，把结果按照ID放入缓存中。

3、删除、更新、增加数据的时候，同时更新缓存

适合放到二级缓存的数据：

1、很少被修改的数据

2、不是很重要的数据，允许出现偶尔并发的数据

3、不会被并发访问的数据

4、参考数据

不适合放到二级缓存的数据：

1、经常被修改的数据

2、财务数据，绝对不允许出现并发

3、与其他应用共享的数据

二级缓存的配置：

<cache usage="transactional|read-write|nonstrict-read-write|read-only" region="RegionName"

include="all|non-lazy"/>

hibernate二级缓存的步骤：

1、在Hibernate配置文件（通常为Hibernate.cfg.xml），设置二级缓存的提供者类

2、配置EHCache的基本参数

3、在需要进行缓存的实体对象的映射文件中配置缓存的策略

<property

name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>

ehcache.xml 二级缓存配置文件

<cache usage="read-write"/>

hibernate优化时要考虑的问题:

1、数据库设计调整

2、HQL优化

3、API的正确使用（如根据不同的业务类型选用不同的集合及查询API）

4、主配置参数（日志、查询缓存、fetch_size、batch_size等）

5、映射文件优化（ID生成策略、二级缓存、延迟加载、关联优化）

6、一级缓存的管理

7、针对二级缓存，还有许多特有的策略

8、事物控制策略

数据库设计阶段考虑的3个因素：

1、java建模

2、数据库结构

3、业务需求

影响系统性能的操作及处理方案：

1、批量插入、更新和删除

使用正确的查询方法：

执行数据查询功能的方法有两种：

一种是得到单个持久化对象的get()方法和load()方法 二者区别是是否使用二级缓存 另一种是Query对象的list()和iterator()方法

list方法和iterator方法的区别：

1、执行的查询不同

2、缓存的使用

3、对结果集的处理方法不同

4、使用正确抓取策略

面向切面编程：

Aspect（切面）：对象操作过程中的截面。如权限检查、日志、事务处理等。

Join Point（连接点）：程序运行中的某个阶段点。如某个方法调用，异常抛出等。 Advice（处理逻辑）：某个连接点所采用的处理逻辑。

PointCut（切点）：一系列连接点的集合，它指明Advice在什么时候被触发

AOP通俗定义：在顺序执行程序时，可以插入一些特殊的逻辑来实现特殊的功能。例如：日志和数据库事物管理的实现

AOP把软件系统分为：核心关注点和横切关注点

核心关注点指事务处理的主要流程，也就是解决方案要做的事

横切关注点，是与核心业务无关的部分，它常发生在核心关注点的多处，如日志-权限等

AOP基本术语：

连接点（jion point） 对某个方法的调用点

切入点（point cut） 切入点表达式与连接点的匹配时实现aop的技术核心

通知（Advice）是指在某个切入点所执行的代码。分为多种类型

切面（Aspect）是指对关注点的模块化的处理，也就是切入点和通知的结合体

引入（introduction）是指为对象增加额外的方法或属性，从而达到修改对象内部结构的目的

目标对象（Target Object）是指被一个或者多个切面所通知的对象

AOP代理（AOP proxy）由AOP框架创建的对象，用来实现切面契约（包括通知方法执行等功能）

织入（Weaving）指将切面连接到其他应用程序类型或者对象上，并创建一个被通知对象

aop对通知类型的支持，通知类型包括：

1、前置通知（Before advice）指连接点方法之前执行的通知

2、返回后通知（after returning advice）指某个连接点方法正常完成后执行的通知

3.异常后通知（after throwing advice） 连接点方法抛出异常退出时执行的通知

4、后置通知（after advice） 无论任何情况下连接点方法退出时执行的通知，也就是无论连接点方法正常退出还是抛出异常都会执行此通知

5、环绕通知（around advice） 指包围连接点方法的通知

注意：所有的切面和通知器都必须定义在<aop:config>元素内部。

切面声明：

通过<aop:aspect>来声明，必须放置到<aop:config>元素内部

<aop:config>

<aop:aspect id="myAspect" ref="aBean">....</aop:aspect>

</aop:config>

<bean id="aBean" class="..">

</bean>

切入点声明：

通过<aop:pointcut>元素进行声明，位置可以发在切面声明里（相当于局部变量），也可直接放在<aop:config>元素内部（相当于全局变量），两者作用域不同

<aop:config>

<aop:pointcut id="businessService" expression="execution(* cn.hxex.springcore.*.*(..))"/>

</aop:config>

在<aop:pointcut>元素中，id属性定义的是切入点的唯一标识。expression定义的是切入点表达式，用来确定某个方法是否与该切入点匹配

spring会利用切入点表达式来判断所定义的切入点与当前执行时的连接点是否匹配

切入点指定者（pointcut Designators）

切入点表达式是通过切入点指定者来进行定义的

规则如下：

execution

execution（public**（..））匹配任意公共方法

execution(* set*(..)) 匹配任何以“set”开头的方法

声明通知：

前置通知<aop:before>

返回后通知<aop:after-returning>

抛出异常后通知<aop:after-throwing>

后置通知<aop:after>

环绕通知<aop:arount>

几种通知共同的属性：

pointcut：切入点表达式

pointcut-ref：执行本通知时需要满足的切入点

method：在该切面所执行的方法

args-names：指定传给通知的参数

<aop:aspect id="afterReturningExample" ref="aBean"

<aop:after-returning

pointcut-ref="dataAccessOperation"

returning="retVal"

method="doAccessCheck"/>

</aop:aspect>

spring ioc容器的根基接口：org.springframework.beans.factory.BeanFactory 常用类：org.springframework.beans.factory.xml.XmlBeanFactory类

容器初始化接口：org.springframework.core.io.Resource

Resource resource = new FileSystemResource("/usr/local/bean.xml");

Beanfactory beanfactory = new XmlBeanFactory(resource);

ClassPathResource cpr = new ClassPathResource("bean.xml");

BeanFactory beanfactory = new XmlBeanFactory(cpr);

ioc容器的使用：

1、业务处理对象 有IocService类进行模拟 属性：message 方法：display()

2、XML格式的配置文件 定义IoCService Bean 对message属性进行配置

3、IoC容器初始化和业务方法的调用

spring IoC容器除了可以管理业务对象外，还可以管理访问数据库的dao和表示层

IoC框架对常用的对象实例化方法和设计模式都提供了支持，主要有以下三种：

1、使用构造方法创建Bean实例

<bean id="constrution" class="cn.dao.hx.Constrution"/>

2、使用静态工厂方法创建Bean实例

<bean id="constrution" class="cn.dao.hx.Constrution" factory-method=""getStaticFactoryBeanInstance/>

3、使用实例化工厂方法创建Bean实例

<bean id="dynamicFactory" class="cn.hxex.springcore.DynamicFactory"/>

<bean id="dyanmicFactoryBean" factory-bean="dynamicFactory" factory-method="getDynamicFactoryBeanInstance"/>

以上配置相当于：

DynamicFactory df = new DynamicFactory();

DynamicFactoryBean dfb = new df.getDynamicFactoryBeanInstance();