day03-spring与数据库操作的框架解析即dataSource的获取（JDBC）、使用spring中已经有的事务进行JDBC操作

数据库的操作：
   固定的代码（模板，datasource的获取）+动态的参数（变化的SQL语句、参数等等）
   模板模式的编程
代码的结构的解析：
 JdbcTemplate extends JdbcAccessor
    JdbcTemplate(){
   
    }
    JdbcTemplate(DataSource dataSource){
  this.dataSource = dataSource;
    }
    setDataSource(DataSource dataSource){
  this.dataSource = dataSource;
    }

 public abstract class JdbcDaoSupport extends DaoSupport {
  private JdbcTemplate jdbcTemplate;
  public final void setDataSource(DataSource dataSource) {
   if (this.jdbcTemplate == null || dataSource != this.jdbcTemplate.getDataSource()) {
    this.jdbcTemplate = createJdbcTemplate(dataSource);
    initTemplateConfig();
   }
  }
  protected JdbcTemplate createJdbcTemplate(DataSource dataSource) {
   return new JdbcTemplate(dataSource);
  }
  public final DataSource getDataSource() {
   return (this.jdbcTemplate != null ? this.jdbcTemplate.getDataSource() : null);
  }
  public final void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
   this.jdbcTemplate = jdbcTemplate;
   initTemplateConfig();
  }
  public final JdbcTemplate getJdbcTemplate() {
    return this.jdbcTemplate;
  }
 }
   说明：
       1、在JdbcDaoSupport中可以注入dataSource
       2、在JdbcDaoSupport中注入的dataSource通过createJdbcTemplate方法
   传入到JdbcTemplate
              3、可以通过JdbcDaoSupport得到JdbcTemplate的引用
 HibernateTemplate
 SqlMapClientTemplate
 JdoTemplate

spring结合jdbc的写法：共七种写法
   1、
        类的写法：
  PersonDao extends JdbcDaoSupport
 配置文件：
        1、在PersonDao中注入DataSource
        2、在PersonDao中注入JdbcTemplate
             在JdbcTemplate中注入dataSource
                       1、可以利用构造器的形式
                       2、可以利用setter的方式
   2、
        类的写法
         PersonDao{
     private JdbcTemplate   jdbcTemplate;
  }
        配置文件：
              在PersonDao中注入JdbcTemplate
                     在JdbcTemplate中注入dataSource
                              1、可以利用构造器的形式
                              2、可以利用setter的方式
   3、
 类的写法
         PersonDao extends JdbcTemplate{
  
  }
 配置文件：
         利用构造器或者setter方法注入dataSource

总结：
     无论什么样的形式，最终是把dataSource传入到了jdbcTemplate中,只要有了数据源，就可以进行一系列crud操作。

package com.itheima.dao;

public interface PersonDao {
	void savePerson();
}

package com.itheima.dao.impl;

import org.springframework.jdbc.core.support.JdbcDaoSupport;

import com.itheima.dao.PersonDao;

public class PersonDaoImpl extends JdbcDaoSupport implements PersonDao {

	@Override
	public void savePerson() {
		// TODO Auto-generated method stub
		this.getJdbcTemplate().execute("insert into person(name) values(‘ccc‘)");
	}

}

package com.itheima.service;

public interface PersonService {
	void savePerson();
}

package com.itheima.service.impl;

import com.itheima.dao.PersonDao;
import com.itheima.service.PersonService;

public class PersonServiceImpl implements PersonService {
	private PersonDao personDao;
	
	public void setPersonDao(PersonDao personDao) {
		this.personDao = personDao;
	}

	@Override
	public void savePerson() {
		/**
		 * 如果有事务，则以下操作将不会执行，都不会成功。因为有异常 。
		 * 要么都成功。
		 */
		this.personDao.savePerson();
		//int i = 1/0;
		this.personDao.savePerson();
	}

}

spring的配置文件applicationContext.xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:aop="http://www.springframework.org/schema/aop"
	   xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/aop 
           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/tx 
           http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
	<bean
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="locations">
			<value>classpath:jdbc.properties</value>
		</property>
	</bean>
    
  	<bean id="dataSource" destroy-method="close"
		class="org.apache.commons.dbcp.BasicDataSource">
		<property name="driverClassName" value="${jdbc.driverClassName}" />
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
	</bean>
	<!-- 
		把dao,service层的类放入到spring容器中
	 -->
	<bean id="personDao" class="com.itheima08.spring.jdbc.transaction.xml.dao.impl.PersonDaoImpl">
		<property name="dataSource">
			<ref bean="dataSource"/>
		</property>
	</bean>
	<bean id="personService" class="com.itheima08.spring.jdbc.transaction.xml.service.impl.PersonServiceImpl">
		<property name="personDao">
			<ref bean="personDao"/>
		</property>
	</bean>
	
	<!-- 
		事务管理器
	 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource">
			<ref bean="dataSource"/>
		</property>
	</bean>
	<!-- 
		规定事务的策略问题和事务管理器的问题
	 -->
	<tx:advice id="tx" transaction-manager="transactionManager">
		<tx:attributes>
			<!-- 
				name指定目标方法的范围
				  save*  就是以save开头的方法
				  propagation  传播属性
				      	用来解决嵌套事务的问题
				  isolation    隔离机制
				  read-only
				      true    只读事务
				      false   读写事务
			 -->
			<tx:method name="save*" 
				propagation="REQUIRED" 
				isolation="DEFAULT" 
				read-only="false"/>
		</tx:attributes>
	</tx:advice>
	
	<aop:config>
		<aop:pointcut 
			expression="execution(* com.itheima08.spring.jdbc.transaction.xml.service.impl.PersonServiceImpl.*(..))" 
			id="perform"/>
		<aop:advisor advice-ref="tx" pointcut-ref="perform"/>
	</aop:config>
</beans>

spring事务的架构：

1、顶级接口
	public interface PlatformTransactionManager {
	        //得到事务
		TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;
		//提交事务
		void commit(TransactionStatus status) throws TransactionException;
		//事务的回滚
		void rollback(TransactionStatus status) throws TransactionException;
	}

	TransactionStatus
		boolean isNewTransaction();
2、抽象类
	public abstract class AbstractPlatformTransactionManager implements PlatformTransactionManager{
		//获取事务
		public final TransactionStatus 
			getTransaction(TransactionDefinition definition) 
				throws TransactionException {
			//抽象方法
			Object transaction = doGetTransaction();
		}
		//将来谁继承该抽象类，谁实现该方法
		protected abstract Object doGetTransaction() throws TransactionException;

		public final void commit(TransactionStatus status) throws TransactionException {
		
		}

		public final void rollback(TransactionStatus status) throws TransactionException {
		
		}
	}
3、实现类
	DataSourceTransactionManager
	HibernateTransactionManager
	JdoTransactionManager
	...






案例分析：
    public class PersonDao{
	private PlatformTransactionManager platformTransactionManager;
	public void setPlatformTransactionManager(PlatformTransactionManager platformTransactionManager){
		this.platformTransactionManager = PlatformTransactionManager;
	}
    }

spring的声明式事务处理

这时spring容器是一个切面。

注意：要使用spring的事务管理来管理程序中的事务，就要遵守spring的规范（有一个接口、一个抽象类、三个实现类（JDBC、hibernate、））。
在使用spring的事务管理时，不需要写切面类，spring已经实现了，不需要关心。程序员只要写crud操作就行和声明事务。

事务管理器：你使用的是哪种技术，JDBC、hibernate，不管你是使用哪种技术，spring帮你实现完全的面向接口编程

day03-spring与数据库操作的框架解析即dataSource的获取（JDBC）、使用spring中已经有的事务进行JDBC操作,古老的榕树,5-wow.com