学习spring的第三天

第四章 ： 把mybatisu框架和spring集成在一起，像一个框架一样使用

使用的技术是：ioc
为什么ioc能把mybatis和spring集成在一起，像一个框架：
因为ioc能创建对象，可以吧mybatis框架中的对象交给spring统一创建，开发人员从spring中获取对象，
开发人员就不用同时面对两个过多个框架了，就面对一个spring

mybatis使用步骤，对象
1.定义dao接口，StudentDao
2.定义mapper文件，StudentDao.xml
3.定义mybatis的主配置文件 mybatis.xml
4.创建dao的代理对象， StudentDao dao = sqlSession.getMapper(StudentDao.class);

List<Student> students = dao.selectStudents();

要使用dao对象，需要使用getMapper()方法
怎么能使用getMapper()方法，需要哪些条件
1.获取sqlSession对象，需要使用sqlSessionFactory的openSession()方法。
2.创建SqlSessionFactory对象。通过读取mybatis的主配置文件，能创建SqlSessionFactory对象

需要SqlSessionFactory对象，使用Factory能获取SqlSession,有了SqlSession就能有dao，目的就是获取dao对象
Factory创建需要读取主配置文件

使用独立的连接池类替换mybatis默认自带的，把连接池类也交给spring创建

主配置文件：
1.数据库信息
2.mapper文件的位置

通过以上的说明，我们需要让spring创建以下对象
1.独立的连接池类的对象，使用阿里的druid连接池
2.SqlSessionFactory对象，使用的SqlSessionFactoryBean在内部创建的SqlSessionFactory
3.创建出dao对象,使用的MapperScannConfigure，在这个类的内部，调用getMapper(),创建接口的Dao对象

需要学习就是上面三个对象的创建语法，使用xml的bean标签。

spring的事务处理
1.什么是事务
讲mysql的时候，提出了事务。事务是指一组sql语句的集合，集合中有多条sql语句
可能是insert，update，select，delete，我们希望这些多个sql语句都能成功，或者
都失败，这些sql语句的执行是一致的，作为一个整体执行（原子性）。

2.在什么时候想起使用事务
当我们的操作，设计到多个表，或者是多个sql语句的insert，update，delete。需要保证
这些语句都是成功的才能完成我们的功能，或者都是失败的，保证操作是符合要求的

在java代码中写程序，控制事务，此时事务应该放在哪里呢？
service类的业务方法上，因为业务方法会调用多个dao方法，执行多个sql语句

3.通常使用JDBC访问数据库，还有mybatis访问数据库怎么处理事务
jdbc访问数据库，处理事务，Connection conn； conn.commit(); conn.rollback();
mybatis访问数据库，处理事务，SqlSession.commit(); SqlSession.rollback();
hibernate访问数据库，处理事务，Session.commit(),Session.rollback();

4.问题3中事务的处理方式，有什么不足
1）不同的数据库访问技术，处理事务的对象，方法不同
需要了解不同数据库访问技术使用事务的原理
2）掌握多种数据库中数据的处理逻辑。什么时候提交事务，什么时候回滚事务
3）处理事务的多种方法

总结：就是多种数据库的访问技术，有不同的事务处理的机制，对象，方法

5.怎么解决不足
spring提供一种处理事务的统一模型，能使用统一步骤，方式完成多种不同数据库访问技术的事务处理

使用spring的事务处理机制，可以完成mybatis访问数据库的事务处理
使用spring的事务处理机制，可以完成hibernate访问数据库的事务处理
使用spring的事务处理机制，可以完成jdbc访问数据库的事务处理

6.处理事务，需要怎么做，做什么
spring 处理事务的模型，使用的步骤是固定的。把事务使用的信息提供给spring就可以了

1）spring内部提交，回滚事务，使用的事务管理器对象，代替我们完成commit，rollback
   事务管理器是一个接口和他的众多实现类。
   接口：PlatformTransactionManager,定义了事务重要方法  commit,rollback
   实现类：spring把每一种数据库访问技术对应的事务处理类都创建好了
		   mybatis访问数据库-----spring创建好的是DateSourceTransactionManager
		   hibernate访问数据库----spring创建的是HibernateTransactionManager
		   
   怎么使用：我们需要告诉Spring,我们用的是哪种数据库的访问技术，怎么告诉spring呢？
   声明数据库访问技术对应的事务管理器实现类，在spring的配置文件中使用<bean>声明就看可以了
   例如，我们要使用mybatis访问数据库，就应该在xml配置文件中
   <bean id="xxx" class = "...DateSourceTransactionManager">
   
2）我们的业务需要什么样的事务，需要说明事务的类型
	说明方法需要的事务
	1）事务的隔离级别：有4个值。
		DEFAULT:采用DB默认的事务隔离级别。Mysql的默认为 REPEATABLE_READ: Oracle默认为READ_COMMITTED.
		READ_UNCOMMITTED:读未提交。未解决任何并发问题
		READ_COMMITTED:读已提交。解决脏读，存在不可重复读与幻读。
		REPEATABLE_READ:可重复读。解决脏读、不可重复读，存在幻读
		SERIALIZABLE:串行化。不存在并发问题
		
	2）事务的超过时间：表示一个方法最长的执行时间，如果方法执行时间超过了时间，事务回滚。
		单位是秒，整数值，默认是-1
		
	3）事务的传播行为 ：控制业务方法是不是有事务的，是什么样的事务的。
		7个传播行为，表示业务方法调用时，事务在方法之间是如何使用的。
		
		PROPAGATION_REQUIRED
		PROPAGATION_REQUIRES_NEW
		PROPAGATION_SUPPORTS
		以上三个需要掌握
		
		PROPAGATION_MANDATORY
		PROPAGATION_NESTED
		PROPAGATION_NEVER
		PROPAGATION_NOT_SUPPORTED
		
3）事务提交事务，回滚事务的时机
	1）当业务方法执行成功，没有异常抛出时，当方法执行完毕，spring在方法执行后提交事务。事务管理器commit
	
	2）当业务方法抛出运行时异常，spring执行回滚，调用事务管理器的rollback
	   运行时异常的定义：RuntimeException 和他的子类都是运行时异常，例如NullPointException, NumberFormatException
	   
	3）当你的业务方法抛出非运行时异常，主要还受查异常时，提交事务
		受查异常：在写代码时，必须处理的异常。例如IOExceotion，SQLException

总结spring的事务：
1.管理事务的是 事务管理器和它的实现类
2.spring的事务是一个统一模型
1）指定要使用的事务管理器实现类，使用
2）指定哪些类，哪些方法需要加入事务的功能
3）指定方法需要的隔离级别，传播行为，超时

	开发人员需要告诉spring，项目中类信息，方法的名称，方法的事务传播行为

spring框架中提供的事务处理方案
1.适合中小型项目使用，注解方案
spring框架自己用aop实现给业务方法增加事务的功能，使用@Transactional注解增加事务
@Transactional注解是spring框架自己的注解，放在public方法的上面，表示当前方法具有事务。
可以给注解的属性赋值，表示具体的隔离级别，传播行为，异常信息等等

	@使用@Transsactional的步骤：
		1）需要声明事务管理器对象
		<bean id = "xxx" class = "DataSourceTransactionManager">
		2）开启事务注解驱动，告诉sping框架，要使用注解的方式管理实务
			spring使用aop机制，创建@Transactional所在的类代理对象，给方法加入事务的功能
			spring给业务方法加入事务：
				在业务方法执行之前，先开启事务，在业务方法之后提交或回滚事务，使用aop的环绕通知
				
				@Around("要增加的事务功能的业务方法名称")
				Object myAround(){
					开启事务，spring自动启动
					try{
						buy(1001,10);
						spring的事务管理.commit();
					}catch(Exception e){
						spring的事务管理.rollback();
					}
				}
		3）在方法的上面加入@Trancational
		
		//rollbackFor:表示发生指定的异常一定回滚
			处理逻辑是：
				1.spring框架会首先检查方法抛出的异常是不是rollbackFor的属性值中
				  如果异常在rollbacFor列表中，不管是什么类型的异常，一定回滚
				2.如果抛出的异常不在rollbackFor列表中，spring会判断异常是不是RuntimeException
				  如果是一定回滚
		
		@Transactional(
        propagation = Propagation.REQUIRED,
        isolation = Isolation.DEFAULT,
        readOnly = false,
        rollbackFor = {
                NullPointerException.class , NotEnoughException.class
        }
		
2.适合大型项目，有很多的类，方法，需要大量的配置事务，使用aspectj框架功能，在spring配置文件中
  声明类，方法需要的事务。这种方式业务方法和事务配置完全分离。
  
  实现步骤：都是在xml配置文件中实现
  1）要使用的是aspectj框架，需要加入依赖
  <dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-aspects</artifactId>
	<version>5.2.5.RELEASE</version>
  </dependency>
  
  2)声明事务管理器对象
  <bean id = "xxx" class = "DataSourceTransactionManager">
  
  3）声明方法需要的事务类型（配置方法的事务属性【隔离级别，传播行为，超时】）
  
  4）配置aop：指定哪些类要创建代理。
  
  <!--声明式事务处理：和源代码完全分离的-->
<!--1.声明事务管理对象-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="myDataSource"/> <!--数据源-->
</bean>

<!--2.声明业务方法的事务属性（隔离级别，传播行为，超时时间）
    id：自定义名称，表示<tx:advice> 和 </tx:advice>之间的配置内容的
    transaction-manager: 事务管理器对象的id
-->
<tx:advice id="myAdvice" transaction-manager="transactionManager">
    <!--tx:attributes: 配置事务属性-->
    <tx:attributes>
        <!--tx:method ：给具体的方法配置事务属性，method可以有多个，分别给不同的方法设置事务属性
            name：方法名称，1）完整的方法名称，不带有包和类
                          2）方法可以使用通配符，* 表示任意字符
            propagation：传播行为，枚举值
            isolation：隔离级别
            rollback-for：指定的异常类名，全限定类名。发生异常一定回滚
        -->
        <tx:method name="buy" propagation="REQUIRED" isolation="DEFAULT"
                   rollback-for="com.bjpowernode.excep.NotEnoughException,java.lang.NullPointerException"/>
    </tx:attributes>
</tx:advice>

<!--配置aop-->
<aop:config>
    <!--配置切入点表达式：指定哪些包中类，要使用事务
        id：切入点表达式的名称，唯一值
        expression: 切入点表达式，指定哪些类要使用事务，aspectj会创建代理对象
    -->
    <aop:pointcut id="servciePt" expression="execution(* *..service..*.*(..))"/>

    <!--配置增强器：关联advice和pointcut
        advice-ref: 通知，上面tx：advice那里的配置
        pointcut-ref：切入点表法式的id
    -->
    <aop:advisor advice-ref="myAdvice" pointcut-ref="servciePt"/>
</aop:config>

==========================================================================================================
web项目中怎么使用容器对象
1.javase项目有main方法的，执行代码是执行main方法
在main里面创建的容器对象
ApplicationContext cxt = new ClassPathXmlApplicationContext(“applicationContext.xml”);

2.web项目是在tomcat服务器上运行的。tomcat一启动，项目一直运行的

需求：
web项目中容器对象只需要创建一次，吧容器对象放入到全局作用于ServletContext中。

怎么实现：
使用监听器 当全局作用域对象被创建时 创建容器 存入ServletContext

监听器作用：
1）创建容器对象，执行ApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");
2）把容器对象放入到ServletContext, ServletContext.setAttribute(key,ctx)

监听器可以自己创建，也可以使用框架中提供好的ContextLoaderListener