spring-mybatis

spring-mybatis整合

PropertyPlaceholderConfigurer

location

SqlSessionFactoryBean

作用:用来创建SqlSessionFacotry,并且扫描xml文件

dataSource：数据源
typeAliasesPackage：扫描某个包，并将下面的类配置别名
configLocation：加载mybatis主配置文件
mapperLocations：扫描某个包下所有mapper.xml

MapperScannerConfigurer

作用:用来扫描mapper接口

basePackage：扫描某个包下所有mapper接口
sqlSessionFactoryBeanName：注入sqlSessionFactory,注意是用value，不是ref的方式注入

spring-mybatis整合步骤

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

1、编写Mapper接口

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

2、编写Mapper.xml

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

事务

1、使用注解解决事务问题

1、添加约束文档

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

2、xml配置事务管理器

3、在任意希望进行事务增强的方法上面添加@Transactional注解

  @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));
    }

2、通过XML配置AOP解决所有的事务问题

事务补充知识点

1.事务回滚控制

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

事务回滚控制

例如:

    // 在需要增强的方法上面，添加该注解，就可以使用事务
    //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.事务隔离级别

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

7.png

3、事务传递

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

8.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();
        }
    }
}