Spring基礎知識（三）

Spring_day03總結

今日內容

l Spring的事務管理

l 三大框架整合

上次課的內容回顧:

Spring的AOP開發:

* AOP:面向切面編程,是對OO思想延伸.

* AOP底層實現原理:動態代理.

* JDK動態代理:針對實現了接口的類生產代理.

* CGLIB代理:針對沒有實現接口的類，產生一個子類.

* AOP術語:

* JoinPoint:可以被攔截點.

* Ponitcut:真正被攔截.

* Advice:通知，增強的代碼.

* 引介:特殊通知，類級別上添加屬性或方法.

* Target:目標對象.

* Proxy:代理對象.

* Weaving:

* Aspect:

 

* Spring的AOP的開發:

* 配置applicationContext.xml生成代理對象.

* 使用ProxyFactoryBean類生產代理:

* 根據目標對象是否實現了接口，選擇使用JDK還是CGLIB.

* 缺點:需要爲每個類都去配置一個ProxyFactoryBean.

 

* 採用Spring自動代理:

* 基於類名稱的自動代理:(採用後處理Bean)

* 基於切面信息的自動代理:(採用後處理Bean)

 

* Spring的AspectJ的切面開發.

* AspectJ:本身第三方切面框架.

* AspectJ基於註解開發:

* 定義切面:

@Aspect

 

* 定義增強:

@Before:前置通知.

@AfterReturing:後置通知.

@Around:環繞通知.

@AfterThrowing:異常拋出通知.

@After:最終通知.

 

* 定義切點:

@Pointcut

* AspectJ基於XML開發:

* 引入aop名稱空間.

<aop:config>

<aop:pointcut expression=”” id=””/>

<aop:aspect ref=””>

<aop:before...>

</aop:aspect>

</aop:config>

 

Spring的JDBCTemplate:

* 配置連接池:

* 默認

* DBCP

* C3P0(*****)

* 引入外部屬性文件.

* 在DAO中注入JdbcTemplate.

* 在DAO中不直接注入模板.Dao集成JdbcDaoSupport.

* CRUD的操作.

1.1 Spring的事務管理:

1.1.1 事務:

事務:是邏輯上一組操作，要麼全都成功，要麼全都失敗.

事務特性:

ACID:

原子性:事務不可分割

一致性:事務執行的前後，數據完整性保持一致.

隔離性:一個事務執行的時候，不應該受到其他事務的打擾

持久性:一旦結束，數據就永久的保存到數據庫.

 

如果不考慮隔離性:

髒讀:一個事務讀到另一個事務未提交數據

不可重複讀:一個事務讀到另一個事務已經提交數據（update）導致一個事務多次查詢結果不一致

虛讀:一個事務讀到另一個事務已經提交數據（insert）導致一個事務多次查詢結果不一致

 

事務的隔離級別:

未提交讀:以上情況都有可能發生。

已提交讀:避免髒讀，但不可重複讀，虛讀是有可能發生。

可重複讀:避免髒讀，不可重複讀，但是虛讀有可能發生。

串行的:避免以上所有情況.

 

1.1.2 Spring中事務管理:

分層開發：事務處在Service層.

Spring提供事務管理API:

PlatformTransactionManager:平臺事務管理器.

commit(TransactionStatus status)

getTransaction(TransactionDefinition definition)

 

rollback(TransactionStatus status)

 

TransactionDefinition:事務定義

ISOLation_XXX:事務隔離級別.

PROPAGATION_XXX:事務的傳播行爲.(不是JDBC中有的，爲了解決實際開發問題.)

過期時間:

 

TransactionStatus:事務狀態

是否有保存點

是否一個新的事務

事務是否已經提交

 

關係:PlatformTransactionManager通過TransactionDefinition設置事務相關信息管理事務，管理事務過程中，產生一些事務狀態:狀態由TransactionStatus記錄.

 

API詳解:

PlatformTransactionManager:接口.

Spring爲不同的持久化框架提供了不同PlatformTransactionManager接口實現

 

org.springframework.jdbc.datasource.DataSourceTransactionManager:使用Spring JDBC或iBatis 進行持久化數據時使用

org.springframework.orm.hibernate3.HibernateTransactionManager: 使用Hibernate3.0版本進行持久化數據時使用

org.springframework.orm.jpa.JpaTransactionManager使用JPA進行持久化時使用

org.springframework.jdo.JdoTransactionManager當持久化機制是Jdo時使用

org.springframework.transaction.jta.JtaTransactionManager使用一個JTA實現來管理事務，在一個事務跨越多個資源時必須使用

 

TransactionDefinition:

* ISOLATION_DEFAULT:默認級別. Mysql  repeatable_readoracle read_commited

ISOLATION_READ_UNCOMMITTED

ISOLATION_READ_COMMITTED 

ISOLATION_REPEATABLE_READ 

ISOLATION_SERIALIZABLE 

 

* 事務的傳播行爲:(不是JDBC事務管理，用來解決實際開發的問題.)傳播行爲：解決業務層之間的調用的事務的關係.

PROPAGATION_REQUIRED:支持當前事務，如果不存在 就新建一個

* A,B如果A有事務，B使用A的事務，如果A沒有事務，B就開啓一個新的事務.(A,B是在一個事務中。)

PROPAGATION_SUPPORTS:支持當前事務，如果不存在，就不使用事務

* A,B如果A有事務，B使用A的事務，如果A沒有事務，B就不使用事務.

PROPAGATION_MANDATORY:支持當前事務，如果不存在，拋出異常

* A,B如果A有事務，B使用A的事務，如果A沒有事務，拋出異常.

PROPAGATION_REQUIRES_NEW如果有事務存在，掛起當前事務，創建一個新的事務

* A,B如果A有事務，B將A的事務掛起，重新創建一個新的事務.(A,B不在一個事務中.事務互不影響.)

PROPAGATION_NOT_SUPPORTED以非事務方式運行，如果有事務存在，掛起當前事務

* A,B非事務的方式運行，A有事務，就會掛起當前的事務.

PROPAGATION_NEVER 以非事務方式運行，如果有事務存在，拋出異常

PROPAGATION_NESTED如果當前事務存在，則嵌套事務執行

* 基於SavePoint技術.

* A,BA有事務，A執行之後，將A事務執行之後的內容保存到SavePoint.B事務有異常的話，用戶需要自己設置事務提交還是回滾.

 

* 常用:(重點)

PROPAGATION_REQUIRED

PROPAGATION_REQUIRES_NEW

PROPAGATION_NESTED

1.1.3 Spring的事務管理:

Spring的事務管理分成兩類:

* 編程式事務管理:

* 手動編寫代碼完成事務管理.

* 聲明式事務管理:

* 不需要手動編寫代碼,配置.

1.1.4 事務操作的環境搭建:

CREATE TABLE `account` (

  `id` int(11) NOT NULL AUTO_INCREMENT,

  `name` varchar(20) NOT NULL,

  `money` double DEFAULT NULL,

  PRIMARY KEY (`id`)

) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

INSERT INTO `account` VALUES ('1', 'aaa', '1000');

INSERT INTO `account` VALUES ('2', 'bbb', '1000');

INSERT INTO `account` VALUES ('3', 'ccc', '1000');

 

創建一個web項目:

* 導入相應jar包

* 引入配置文件:

* applicationContext.xml、log4j.properties、jdbc.properties

 

創建類:

* AccountService

* AccountDao

 

在Spring中註冊:

<!-- 業務層類 -->

<bean id="accountService" class="cn.itcast.spring3.demo1.AccountServiceImpl">

<!-- 在業務層注入Dao -->

<property name="accountDao" ref="accountDao"/>

</bean>

<!-- 持久層類 -->

<bean id="accountDao" class="cn.itcast.spring3.demo1.AccountDaoImpl">

<!-- 注入連接池的對象,通過連接池對象創建模板. -->

<property name="dataSource" ref="dataSource"/>

</bean>

 

編寫一個測試類:

1.1.5 Spring的事務管理:

手動編碼的方式完成事務管理:

需要事務管理器:真正管理事務對象.

* Spring提供了事務管理的模板(工具類.)

 

第一步:註冊事務管理器:

<!-- 配置事務管理器 -->

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

<!-- 需要注入連接池,通過連接池獲得連接 -->

<property name="dataSource" ref="dataSource"/>

</bean>

 

第二步:註冊事務模板類:

<!-- 事務管理的模板 -->

<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">

<property name="transactionManager" ref="transactionManager"/>

</bean>

 

第三步:在業務層注入模板類:(模板類管理事務)

<!-- 業務層類 -->

<bean id="accountService" class="cn.itcast.spring3.demo1.AccountServiceImpl">

<!-- 在業務層注入Dao -->

<property name="accountDao" ref="accountDao"/>

<!-- 在業務層注入事務的管理模板 -->

<property name="transactionTemplate" ref="transactionTemplate"/>

</bean>

 

第四步:在業務層代碼上使用模板:

public void transfer(final String from, final String to, final Double money) {

transactionTemplate.execute(new TransactionCallbackWithoutResult() {

@Override

protected void doInTransactionWithoutResult(TransactionStatus status) {

accountDao.out(from, money);

int d = 1 / 0;

accountDao.in(to, money);

}

});

}

 

手動編碼方式缺點:

* 代碼量增加,代碼有侵入性.

聲明式事務管理:(原始方式)

基於TransactionProxyFactoryBean.

導入:aop相應jar包.

 

第一步:註冊平臺事務管理器:

<!-- 事務管理器 -->

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

<!-- 注入連接池 -->

<property name="dataSource" ref="dataSource"/>

</bean>

 

第二步:創建業務層代理對象:

<!-- 配置生成代理對象 -->

<bean id="accountServiceProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">

<!-- 目標對象 -->

<property name="target" ref="accountService"/>

<!-- 注入事務管理器 -->

<property name="transactionManager" ref="transactionManager"/>

<!-- 事務的屬性設置 -->

<property name="transactionAttributes">

<props>

<prop key="transfer">PROPAGATION_REQUIRED</prop>

</props>

</property>

</bean>

 

第三步:編寫測試類:

***** 千萬注意:注入代理對象

@Autowired

@Qualifier("accountServiceProxy")

private AccountService accountService;

 

prop格式：PROPAGATION,ISOLATION,readOnly,-Exception,+Exception

* 順序:傳播行爲、隔離級別、事務是否只讀、發生哪些異常可以回滾事務（所有的異常都回滾）、發生了哪些異常不回滾.

 

***** 缺點:就是需要爲每一個管理事務的類生成代理.需要爲每個類都需要進行配置.

聲明式事務管理:(自動代理.基於切面 ******)

第一步:導入相應jar包.

* aspectj

 

第二步:引入相應約束:

* aop、tx約束.

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:context="http://www.springframework.org/schema/context"

xmlns:aop="http://www.springframework.org/schema/aop"

xmlns:tx="http://www.springframework.org/schema/tx"

xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context.xsd

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop.xsd

http://www.springframework.org/schema/tx

" >http://www.springframework.org/schema/tx/spring-tx.xsd">

 

第三步:註冊事務管理器;

<!-- 事務管理器 -->

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

<property name="dataSource" ref="dataSource"/>

</bean>

 

第四步:定義增強(事務管理)

<!-- 定義一個增強 -->

<tx:advice id="txAdvice" transaction-manager="transactionManager">

<!-- 增強(事務)的屬性的配置 -->

<tx:attributes>

<!--

isolation:DEFAULT:事務的隔離級別.

propagation:事務的傳播行爲.

read-only:false.不是隻讀

timeout:-1

no-rollback-for:發生哪些異常不回滾

rollback-for:發生哪些異常回滾事務

 -->

<tx:method name="transfer"/>

</tx:attributes>

</tx:advice>

 

第五步:定義aop的配置(切點和通知的組合)

<!-- aop配置定義切面和切點的信息 -->

<aop:config>

<!-- 定義切點:哪些類的哪些方法應用增強 -->

<aop:pointcut expression="execution(* cn.itcast.spring3.demo3.AccountService+.*(..))" id="mypointcut"/>

<!-- 定義切面: -->

<aop:advisor advice-ref="txAdvice" pointcut-ref="mypointcut"/>

</aop:config>

 

第六步:編寫測試類:

* 注入Service對象,不需要注入代理對象(生成這個類的時候,已經是代理對象.)

基於註解的事務管理:

第一步:事務管理器:

<!-- 事務管理器 -->

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

<property name="dataSource" ref="dataSource"/>

</bean>

 

第二步:註解事務:

<!-- 開啓註解的事務管理 -->

<tx:annotation-driven transaction-manager="transactionManager"/>

 

第三步:在Service上使用註解

@Transactional

* 註解中有屬性值:

* isolation

* propagation

* readOnly

...

1.2 SSH框架整合:

1.2.1 Struts2+Spring+Hibernate導包

Struts2導入jar包:

* struts2/apps/struts2-blank.war/WEB-INF/lib/*.jar

* 導入與spring整合的jar

* struts2/lib/struts2-spring-plugin-2.3.15.3.jar--- 整合Spring框架

* struts2/lib/struts2-json-plugin-2.3.15.3.jar--- 整合AJAX

* struts2/lib/struts2-convention-plugin-2.3.15.3.jar--- 使用Struts2註解開發.

 

* 配置

web.xml

<filter>

  <filter-name>struts2</filter-name>

  <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>

</filter>

<filter-mapping>

  <filter-name>struts2</filter-name>

  <url-pattern>/*</url-pattern>

</filter-mapping>

 

struts.xml

<struts>

 

    <constant name="struts.devMode" value="true" />

 

    <package name="default" namespace="/" extends="struts-default">

    

    </package>

 

</struts>

 

 

Spring導入jar包:

Spring3.2 開發最基本jar包

spring-beans-3.2.0.RELEASE.jar

spring-context-3.2.0.RELEASE.jar

spring-core-3.2.0.RELEASE.jar

spring-expression-3.2.0.RELEASE.jar

com.springsource.org.apache.commons.logging-1.1.1.jar

com.springsource.org.apache.log4j-1.2.15.jar

AOP開發

spring-aop-3.2.0.RELEASE.jar

spring-aspects-3.2.0.RELEASE.jar

com.springsource.org.aopalliance-1.0.0.jar

com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar

Spring Jdbc開發

spring-jdbc-3.2.0.RELEASE.jar

spring-tx-3.2.0.RELEASE.jar

Spring事務管理

spring-tx-3.2.0.RELEASE.jar

Spring整合其他ORM框架

spring-orm-3.2.0.RELEASE.jar

Spring在web中使用

spring-web-3.2.0.RELEASE.jar

Spring整合Junit測試

spring-test-3.2.0.RELEASE.jar

 

(Spring沒有引入c3p0和數據庫驅動)

 

* 配置:

applicationContext.xml

Log4j.properties

 

在web.xml中配置監聽器;

<!-- 配置Spring的監聽器 -->

<listener>

<!-- 監聽器默認加載的是WEB-INF/applicationContext.xml -->

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

 

<!-- 指定Spring框架的配置文件所在的位置 -->

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>classpath:applicationContext.xml</param-value>

</context-param>

 

Hibernate的jar包導入:

* 核心包:hibernate3.jar

* lib/required/*.jar

* lib/jpa/*.jar

* 引入hibernate整合日誌系統的jar包:

* 數據連接池:

* 數據庫驅動:

 

* 二級緩存:(可選的.)

* backport-util-concurrent.jar

* commons-logging.jar

* ehcache-1.5.0.jar

 

* Hibernate的配置:

* hibernate.cfg.xml

* 映射:

* 格式:類名.hbm.xml

1.2.2 Struts2和Spring的整合:

1.新建包結構:

* cn.itcast.action

* cn.itcast.service

* cn.itcast.dao

* cn.itcast.vo

 

2.創建實體類:

* Book

 

3.新建一個jsp頁面:

* addBook.jsp

        <s:form action="book_add" namespace="/" method="post" theme="simple">

圖書名稱:<s:textfield name="name"/><br/>

圖書價格:<s:textfield name="price"/><br/>

<s:submit value="添加圖書"/>

</s:form>

 

4.編寫Action:

public class BookAction extends ActionSupport implements ModelDriven<Book>{

// 模型驅動類

private Book book = new Book();

public Book getModel() {

return book;

}

 

// 處理請求的方法:

public String add(){

System.out.println("web層的添加執行了...");

return NONE;

}

}

 

5.配置struts.xml

<action name="book_*" class="cn.itcast.action.BookAction" method="{1}">

    

    </action>

 

1.2.3 Struts2和Spring的整合兩種方式:

Struts2自己管理Action:(方式一)

<action name="book_*" class="cn.itcast.action.BookAction" method="{1}">

* Struts2框架自動創建Action的類.

Action交給Spring管理:(方式二)

可以在<action>標籤上通過一個僞類名方式進行配置:

<action name="book_*" class="bookAction" method="{1}"></action>

 

在spring的配置文件中:

<!-- 配置Action -->

<bean id="bookAction" class="cn.itcast.action.BookAction"></bean>

(*****)注意:Action交給Spring管理一定要配置scope=”prototype”

 

推薦使用二:

* 在Spring中管理的類,可以對其進行AOP開發.統一的管理.

 

Web層獲得Service:

傳統方式:

* 獲得WebApplicationContext對象.

* 通過WebAppolicationContext中getBean(“”);

 

實際開發中:

* 引入了struts2-spring-plugin-2.3.15.3.jar

* 有一個配置文件 : struts-plugin.xml

開啓常量 :

<constant name="struts.objectFactory" value="spring" />

引發另一個常量的執行:(Spring的工廠類按照名稱自動注入)

struts.objectFactory.spring.autoWire = name

 

1.2.4 Spring整合Hibernate:

Spring整合Hibernate框架的時候有兩種方式:

零障礙整合:(一)

可以在Spring中引入Hibernate的配置文件.

1.通過LocalSessionFactoryBean在spring中直接引用hibernate配置文件

<!-- 零障礙整合 在spring配置文件中引入hibernate的配置文件 -->

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

<property name="configLocation" value="classpath:hibernate.cfg.xml"/>

</bean>

 

2.Spring提供了Hibernate的模板.只需要將HibernateTemplate模板注入給DAO.

* DAO繼承HibernateDaoSupport.

<!-- DAO的配置 -->

<bean id="bookDao" class="cn.itcast.dao.BookDao">

<property name="sessionFactory" ref="sessionFactory"/>

</bean>

 

改寫DAO:繼承HibernateDaoSupport類.

public class BookDao extends HibernateDaoSupport{

 

public void save(Book book) {

System.out.println("DAO層的保存圖書...");

this.getHibernateTemplate().save(book);

}

 

}

 

3.創建一個映射文件 :

<hibernate-mapping>

<class name="cn.itcast.vo.Book" table="book">

<id name="id">

<generator class="native"/>

</id>

<property name="name"/>

<property name="price"/>

</class>

</hibernate-mapping>

 

4.別忘記事務管理:

事務管理器:

<!-- 管理事務 -->

<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">

<property name="sessionFactory" ref="sessionFactory"/>

</bean>

 

5.註解管理事務:

<!-- 註解開啓事務 -->

<tx:annotation-driven transaction-manager="transactionManager"/>

 

6.在業務層類上添加一個註解:

@Transactional

沒有Hibernate配置文件的形式(二)

不需要Hibernate配置文件的方式,將Hibernate配置文件的信息直接配置到Spring中.

Hibernate配置文件中的信息 :

* 連接數據庫基本參數:

* Hibernate常用屬性:

* 連接池:

* 映射:

 

把Hibernate配置文件整合Spring中:

連接池:

<!-- 引入外部屬性文件. -->

<context:property-placeholder location="classpath:jdbc.properties"/>

<!-- 配置c3p0連接池 -->

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">

<property name="driverClass" value="${jdbc.driver}"/>

<property name="jdbcUrl" value="${jdbc.url}"/>

<property name="user" value="${jdbc.user}"/>

<property name="password" value="${jdbc.password}"/>

</bean>

Hibernate常用屬性:

<!-- 配置Hibernate的屬性 -->

<property name="hibernateProperties">

<props>

<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>

<prop key="hibernate.show_sql">true</prop>

<prop key="hibernate.format_sql">true</prop>

<prop key="hibernate.hbm2ddl.auto">update</prop>

<prop key="hibernate.connection.autocommit">false</prop>

</props>

</property>

 

映射

<!-- <property name="mappingResources">

<list>

<value>cn/itcast/vo/Book.hbm.xml</value>

</list>

</property> -->

<property name="mappingDirectoryLocations">

<list>

<value>classpath:cn/itcast/vo</value>

</list>

</property>

1.2.5 HibernateTemplate的API:

 Serializable save(Object entity) :保存數據

 void update(Object entity) :修改數據

 void delete(Object entity) :刪除數據

 <T> T get(Class<T> entityClass, Serializable id) :根據ID進行檢索.立即檢索

 <T> T load(Class<T> entityClass, Serializable id) :根據ID進行檢索.延遲檢索.

 List find(String queryString, Object... values) :支持HQL查詢.直接返回List集合.

 List findByCriteria(DetachedCriteria criteria)  :離線條件查詢.

 List findByNamedQuery(String queryName, Object... values):命名查詢的方式.

 

1.2.6 OpenSessionInView:

 

1.3 基於註解的方式整合SSH:

導入以上工程jar包:

* 導入struts2的註解開發:

* struts2-convention-plugin-2.3.15.3.jar

 

* web.xml:

<!-- 配置Spring的監聽器 -->

<listener>

<!-- 監聽器默認加載的是WEB-INF/applicationContext.xml -->

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

 

<!-- 指定Spring框架的配置文件所在的位置 -->

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>classpath:applicationContext.xml</param-value>

</context-param>

 

<!-- 配置Struts2的核心過濾器 -->

<filter>

<filter-name>struts2</filter-name>

<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>

</filter>

<filter-mapping>

<filter-name>struts2</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

 

* 創建包結構:

* 引入spring的配置文件、log4j、jdbc屬性文件.

 

* 創建頁面:

* 創建Action:

@Namespace("/")

@ParentPackage("struts-default")

public class BookAction extends ActionSupport implements ModelDriven<Book>{

private Book book = new Book();

public Book getModel() {

return book;

}

 

@Action(value="book_add")

public String add(){

System.out.println("web層添加圖書...");

return NONE;

}

}

 

* Action---Service----Dao

將各層類使用註解裝配Spring中:

@Controller

@Service

@@Repository

 

完成屬性注入:

@Autowired

@Qualifier("bookService")

 

* 實體類:

@Entity

@Table(name="book")

public class Book {

@Id

@GeneratedValue(strategy=GenerationType.IDENTITY)

private Integer id;

@Column(name="name")

private String name;

private Double price;

public Integer getId() {

return id;

}

public void setId(Integer id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public Double getPrice() {

return price;

}

public void setPrice(Double price) {

this.price = price;

}

@Override

public String toString() {

return "Book [id=" + id + ", name=" + name + ", price=" + price + "]";

}

}

* 事務管理:

 

* 模板注入:

今天內容總結:

Spring的事務管理:

* 編程式事務:(瞭解)

* 聲明式事務:

* TransactionProxyFactoryBean.

* AOP和事務配置:(*****)

* 基於註解事務管理:(*****)

 

SSH整合:

* SSH整合(帶有hibernate配置文件)

* 導包:

* 配置文件:

* Struts2+Spring

* 兩種方式:

* Action的類由Struts框架創建.

* Action的類由Spring框架創建.(scope=”prototype”)

* Spring+Hibernate:

* 在Spring框架中引入Hibernate的配置文件.

* 管理事務:

* DAO中注入sessionFactory.

 

* SSH整合(不帶Hibernate配置文件)

* 導包:

* 配置文件:

* Struts2+Spring

* 兩種方式:

* Action的類由Struts框架創建.

* Action的類由Spring框架創建.(scope=”prototype”)

* Spring+Hibernate

* 把Hibernate配置信息配置到Spring中

* 管理事務:

* DAO中注入sessionFactory.

 

* SSH註解.(**)

* Struts2:

* 在Action的類上

* @Namespace(“/”)

* @ParentPackage("struts-default")

 

* 在要執行的方法上:

* @Action

 

* 把Action/Service/Dao交給Spring.

* Action:

@Controller("bookAction")

@Scope("prototype")

* Service

@Service

* Dao

@Repository

 

* 配置Spring中自動掃描;

<context:component-scan base-package="cn.itcast.action,cn.itcast.service,cn.itcast.dao"/>

 

* 映射:

@Entity

@Table(name="book")

public class Book {

@Id

@GeneratedValue(strategy=GenerationType.IDENTITY)

private Integer id;

@Column(name="name")

private String name;

...

}

* 配置SessionFactory:

<!-- 配置Hibernate的其他屬性: -->

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">

<property name="dataSource" ref="dataSource"/>

<!-- 配置Hibernate的屬性 -->

<property name="hibernateProperties">

<props>

<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>

<prop key="hibernate.show_sql">true</prop>

<prop key="hibernate.format_sql">true</prop>

<prop key="hibernate.hbm2ddl.auto">update</prop>

<prop key="hibernate.connection.autocommit">false</prop>

</props>

</property>

<!-- 映射掃描 -->

<property name="packagesToScan">

<list>

<value>cn.itcast.vo</value>

</list>

</property>

</bean>

 

* 事務管理:

<!-- 事務管理器 -->

<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">

<property name="sessionFactory" ref="sessionFactory"/>

</bean>

<tx:annotation-driven transaction-manager="transactionManager"/>

 

* DAO中使用Hibernate模板:

* 手動注入HibernateTemplate :

<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">

<property name="sessionFactory" ref="sessionFactory"/>

</bean>

* 在Dao中

@Autowired

@Qualifier("hibernateTemplate")

private HibernateTemplate hibernateTemplate;