spring-mybatis

spring-mybatis整合

PropertyPlaceholderConfigurer

• 1.PropertyPlaceholderConfigurer是个bean工厂后置处理器的实现，也就是 BeanFactoryPostProcessor接口的一个实现。PropertyPlaceholderConfigurer可以将上下文（配置文 件）中的属性值放在另一个单独的标准java Properties文件中去。在XML文件中用${key}替换指定的properties文件中的值。这样的话，只需要对properties文件进 行修改，而不用对xml配置文件进行修改。

• 2.在Spring中，使用PropertyPlaceholderConfigurer可以在XML配置文件中加入外部属性文件，当然也可以指定外部文件的编码

SqlSessionFactoryBean

作用：用来创建SqlsessionFactory,并且扫描xml文件

• dataSource:数据源

• typeAliasesPackage:扫描某个包，并将下面的类配置别名

• configLocation:加载mybatis主配置文件

• mapperLocations:扫描某个包下所有mapper.xml

<!-- 配置mybatis和spring整合对象SqlSessionFactoryBean -->
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <!-- 配置数据源  -->
            <property name="dataSource" ref="dataSource"></property>
            <!-- 配置mybatis的映射文件 -->
            <property name="mapperLocations" value="classpath:com/wzw/mapper/*.xml"></property>
            <!-- 加载mybatis配置文件  -->
            <property name="configLocation" value="classpath:mybatis-config.xml"></property>
        </bean>

MapperScannerConfigurer

作用：用来扫描mapper接口

• basePackage:扫描某个包下所有mapper接口

• sqlSessionFactoryBeanName：注入sqlSessionFactory，注意是用value而不是用的ref方式注入

<!-- 配置映射文件扫描对象，使用动态代理产生代理对象 -->
        <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            <!-- 配置扫描的接口 -->
            <property name="basePackage" value="com.wzw.dao"></property>
            <!-- 配置sqlSessionFactoryBean -->
            <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
        </bean> 

spring-mybatis整合步骤

导包：1.mybatis.jar 2、mybatis-spring.jar

创建一个bean类，在dao层里使用接口，在mapper层里用xml文件写xml文件即用mybatis开发,service层里用spring 方式注入对象

1.编写Mapper接口

//这里的代理对象由mybatis创建，不能使用@Service
public interface UserDao {
    //使用@Param("username")取别名
    User selectUser(@Param("username")String username,@Param("password")String password);
}

2.编写Mapper.xml

<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  <mapper namespace="com.hemi.dao.UserDao">
    <select id="selectUser" resultType="User">
        select * from user where username=#{username} and password=#{password}
    </select>
  </mapper>

3.编写service

//不要忘了使用注解创建对象
@Service
public class UserService {
    //不要忘了使用注解注入对象
    @Autowired
    private UserDao userDao;
    public User selectUser(String username,String password){
        User user = userDao.selectUser(username, password);
        return user;
    }
}

4.编写spring-mybatis.xml

<!-- 配置数据 -->
    <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource">
        <!-- 帮你调用set方法 setDriverClass() -->
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/bank"></property>
        <property name="user" value="root"></property>
        <property name="password" value=""></property>
    </bean>         
<!-- 配置SqlSessionFactoryBean：用来创建SqlSessionFacotry,并且扫描xml文件-->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean" id="sqlSessionFacotry">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
        <!--配置别名，如果在下面的mybatis配置文件中有配置别名，那么这句可以不用-->
        <property name="typeAliasesPackage" value="com.hemi.bean"></property>
        <!--加载mybatis配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"></property>
        <!-- 扫描mapper.xml -->
        <property name="mapperLocations" value="classpath:com/hemi/mapper/*.xml"></property>
    </bean>
<!-- 配置MapperScannerConfigurer：用来扫描mapper接口 --> 
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 扫描mapper接口 -->
        <property name="basePackage" value="com.hemi.dao"/>
        <!--注入sqlSessionFacotry-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFacotry"></property>
    </bean>

事务

• 1.什么是事务:

数据库操作的基本单位，事务逻辑上的一组操作,组成这组操作的各个逻辑单元,要么一起成功,要么一起失败.

• 2.事务特性：ACID

  • 原子性：强调事务的不可分割

  • 一致性：事物的执行的前后数据的完整性保持一致（转账）

  • 隔离性：一个事务执行的过程中，不应该受到其他事务的干扰

  • 持久性：事务一旦结束，数据就持久到数据库

• 3.如果不考虑隔离性引发安全性问题

  • 脏读：一个事务读到了另一个事务未提交的数据

  • 不可重复读 :一个事务读到了另一个事务已经提交的update的数据导致多次查询结果不一致.

  • 虚读（幻读） :一个事务读到了另一个事务已经提交的insert的数据导致多次查询结果不一致.

• 4.解决读问题：设置事务隔离级别（每种数据库的隔离级别不一样）

  • 未提交读 :脏读，不可重复读，虚读都有可能发生

  • 已提交读:避免脏读。但是不可重复读和虚读有可能发生(sqlserver,orcale)

  • 可重复读:避免脏读和不可重复读.但是虚读有可能发生.（mysql）

  • 串行化的 :避免以上所有读问题.

使用Aspectj注解方式解决事务的问题

1.添加约束的文档 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd

2.xml配置事务管理器

    <bean id="transactionManager" 
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>

<!-- 开启事务：通过aop的方式，对方法进行事务的增强 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

3.在任意希望进行事务增强的方法添加@Transaction注解

    @Transactional
    public int getMoney(int uid,float money,int typeid){    
        moneyDao.getMoney(uid, money);
        int a=1/0;//这里报错，会进行事务回滚
        return moneyDao.insertReocrd(new Record(uid, money, typeid));
    }

注意:@Transactional只能运用在public修饰的方法上

通过XML配置AOP方式解决事务问题

 <!-- 配置AOP -->
    <aop:config>
        <!-- 配置切入点：指定哪些方法要执行事务增强 -->
        <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.hemi.service.*.*(..))"/>
    </aop:config>

    <!-- 配置增强 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!-- 细粒度控制某个方法上事务的属性：例如事务是否传递，事务是否回滚等等 -->
        <!-- REQUIRED:有事务就用，没有就创建 SUPPORTS:有就用，没有就非事务执行 -->
        <tx:attributes>
            <!-- no-rollback-for:当出现了ArithmeticException异常时，也不回滚已提交的事务 -->
            <tx:method name="*Money" propagation="REQUIRED"  no-rollback-for="ArithmeticException"/>
            <tx:method name="delect*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="insert*" propagation="REQUIRED"/>      
            <tx:method name="select*" propagation="SUPPORTS"/>
        </tx:attributes>
    </tx:advice>

注意:第二种方式可以控制所有的方法是否使用事务

补充

事务回滚控制

控制遇到哪些异常才要回滚事务

1.png

例如：

    // 在需要增强的方法上面，添加该注解，就可以使用事务
    //noRollbackFor:如果出现了ArithmeticException，忽略
    @Transactional(noRollbackFor={ArithmeticException.class})
    public int getMoney(int uid, float money, int typeid) {
        moneyDao.getMoney(uid, money);
        int a = 1 / 0;//虽然这里抛出异常，但是上面的操作依然生效，事务不会回滚
        return moneyDao.insertReocrd(new Record(uid, money, typeid));
    }

事务隔离级别 不同数据库支持不同的隔离级别，一般不用修改

2.png

事务传递 两个方法相互嵌套，事务是否公用

3.png

例如：

事务：火车票售票点买票  非事务（正常执行）：打电话买票

public class A{
    事务传递：方法之间的事务传递，例如：方法A的是否可以传递给方法B所使用
    ma：方法A
    mb:方法B

    required:有事务就用，没事务，自己创建

    @Transactional
    ma(){
        mb();//使用了方法ma的事务，如果ma回滚，那么mb也回滚
        int a=1/0;      
    }

    supports:有事务就用，没事务,不用事务，正常执行
    @Transactional
    ma(){
        mb();//打电话
        int a=1/0;      
    }

    mandatory(强制使用事务)：有事务就用，没事务，就报错
    @Transactional
    ma(){
        mb();//如果没有，那么这句就抛出异常
        int a=1/0;      
    }

    required_new:有事务就暂停别人的事务，然后自己开启事务

    @Transactional
    ma(){
        con =connection.startTranscation();
        try{
            update()    
        }catch (Exception e) {
            con.rollback();
        }

        try{
            con1 =connection.startTranscation();
            mb();
        }catch (Exception e) {
            con1.rollback();
        }

        try{
            insert();
            int a=10/0;
        }catch (Exception e) {
            con.rollback();
        }   
    }

    not_supported:有事务就暂停别人的事务，不用事务，正常执行
    @Transactional
    ma(){
        update();
        mb();
        int a=10/0;
        insert();   
    }

    never:有事务抛异常，没事务就正常执行

    @Transactional
    ma(){
        update();
        mb();
        int a=10/0;
        insert();   
    }

    nested:事务嵌套：有事务，就嵌套在别人的事务中，没事务，自己创建事务
    @Transactional
    ma(){
        con =connection.startTranscation();
        try{
            update()    
        }catch (Exception e) {
            con.rollback();
        }

        //插队
        try{
            mb();
        }catch (Exception e) {
            con.rollback();
        }

        try{
            insert();
            int a=10/0;
        }catch (Exception e) {
            con.rollback();
        }
    }
}