spring整合mybatis普通版及spring整合mybatis纯注解版

娇糖玛奇朵~

已于 2023-04-06 11:48:51 修改

阅读量884

点赞数 3

文章标签： mybatis spring java

于 2023-04-06 08:52:23 首次发布

本文链接：https://blog.csdn.net/su3253067688/article/details/129981094

版权

一、spring整合mybatis普通版（理论）：

1 Spring的两大核心思想

1、IOC:控制反转，Spring容器可以完成对象的创建，属性的注入，对象管理等工作

2、Aop：面向切面，在不修改代码业务逻辑的情况下，实现原有的业务的增强

2 Spring可以对mybatis提供哪些支持？

1、Spring-Ioc可以为mybatis完成DataSource、SqlSessionFactory、SqlSession以及Dao对象的创建

2、Spring-Aop可以提供事物管理切面类完成对mybatis数据库中的事务管理。

3 将 MyBatis 与 Spring 进行整合，主要解决什么问题？

将 MyBatis 与 Spring 进行整合，主要解决的问题就是将 SqlSessionFactory 对象交由 Spring 来管理。所以，该整合，只需要将 SqlSessionFactory 的对象生成器 SqlSessionFactoryBean 注册在 Spring 容器中，再将其注入给 Dao 的实现类即可完成整合。

4 实现 Spring 与 MyBatis 的整合常用的方式：

扫描的 Mapper 动态代理 Spring 像插线板一样，mybatis 框架是插头，可以容易的组合到一起。插线板 spring 插上 mybatis，两个框架就是一个整体。使用mybatis，需要创建mybatis框架中的某些对象，使用这些对象，就可以使用mybatis提供的功能了。

5 对于mybatis执行sql语句，需要用到的对象有：

SqlSessionFactory对象，只有创建了SqlSessionFactory对象，才能调用openSession()方法得到SqlSession对象。
dao接口的代理对象，例如StudentDao接口，需要的代理对象为：SqlSeesion.getMapper(StudentDao.class)。
数据源DataSource对象，使用一个更强大、功能更多的连接池对象代替mybatis自己的PooledDataSource

二、spring整合mybatis普通版（实操）：

1 在实际的项目开发中，我们需要将MyBatis和Spring进行整合，通过Spring 的依赖注入以减少代码的耦合。

第一步：创建数据库表
在Navicat下执行如下sql命令创建表User.

drop table if exists t_user;
create table t_user (
uid int(11) primary key not null AUTO_INCREMENT,
username varchar(20),
birthday varchar(20),
sex varchar(5),
address varchar(50)
);

insert into t_user values (1, '张三', '2022-05-03', '男', '北京');
insert into t_user values (2, '李四', '2022-05-19', '男', '广州');
insert into t_user values (3, '小红', '2022-05-19', '女', '郑州');
insert into t_user values (4, '小美', '2022-05-20', '女', '郑州');
select * from t_user;

第二步：创建bean
创建一个model包并在其下创建一个User.java文件。

package com.su.bean;

public class User {
    private Integer uid;
    private String username;
    private String birthday;
    private String sex;
    private String address;

第三步：创建DAO接口
创建一个包dao，并在其下创建一个UserDao.java文件作为DAO接口。

package com.su.dao;

import com.su.bean.User;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Repository;

import java.util.List;
@Repository
public interface UserDao {
    @Select("select * from t_user")
    List<User> selectAll();
}

第四步：创建UserService接口
创建一个包service，并在其下创建一个UserService.java文件作为service接口。

package com.su.service;

import com.su.bean.User;

import java.util.List;

public interface UserService {
    List<User> findAll();
}

第五步：实现UserService接口
在service包下创建一个UserServiceImpl.xml文件作为上一步创建的UserService接口的实现

package com.su.service.impl;

import com.su.bean.User;
import com.su.dao.UserDao;
import com.su.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
@Service
public class UserSeviceImpl implements UserService {
    @Autowired
    UserDao userDao;
    @Override
    public List<User> findAll() {
    return userDao.selectAll();
    }
}

第六步：创建MyBatis的配置文件
在src下创建一个mybatis.xml文件，由于我们的数据源部分是要交给Spring管理，所以此处的配置文件只包含xml映射文件的位置信息。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>


</configuration>

第七步：在Spring中配置数据源
在src下创建一个spring.xml文件作为Spring的配置文件，这里我们使用Spring自带的Jdbc数据源，可以根据实际需要替换为其他数据源。

<?xml version="1.0" encoding="UTF-8"?>
<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"
       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">
<!-- 扫描器扫描component及同名注解-->
    <context:component-scan base-package="com.su"/>
    <!--1.定义连接数据库的数据源DriverManagerDataSource：实际开发使用第三方连接池管理数据
源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mysql"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>
    <!--2.在IOC容器中定义SqlSessionFactoryBean，配置数据源-->
    <bean id="factoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
    </bean>
<!--3.配置mapper扫描器 ，确定需要创建的代理对象-->
     <bean id="scannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
         <property name="basePackage" value="com.su.dao"/>
     </bean>
</beans>

关于Spring配置的说明：
Spring没有内置的提供对MyBatis的支持，配置sqlSessionFactory和userMapper所需要的class是来自于mybatis-spring-1.1.1.jar。

第八步：测试
在src下创建一个servlet包，并在其下创建一个test.java文件

package com.su.servlet;

import com.su.bean.User;
import com.su.service.UserService;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.List;

public class Test01 {
    UserService userService;
    @Test
    public void findAllTest(){
        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");
        userService=context.getBean(UserService.class);
        List<User> userList =userService.findAll();
        for (User user : userList) {
            System.out.println(user);
        }
    }
}

第八步：测试实现效果

一、spring整合mybatis纯注解版（理论）

1 IOC注解：

(主要作用就是在spring容器中声明一个Bean，同xml中的Bean节点作用相同，用在类上)：

　　@Repository(标识DAO层)

　　@Service(标识Service层)

　　@Conmpent(用在其他组件上)

　　隐式注入：

　　@Autowired:根据类型注入

　　@Qualifier：更具名字注入，但是需要和Autowired连用

　　@Resource:jdk提供，默认根据名字注入，如果没找到名字则根据类型注入

Aop注解（）

　　@Aspect（作用在类上，标识这是一个切面）

　　@Before(作用在方法上，前置增强)

　　@AfterReturing(作用在方法上，后置增强)

　　@AfterThrowing(作用在方法上，异常抛出增强)

　　@After(作用在方法上，最终增强)

其他注解

　　@Configuration：标识作用，表示这个类是一个核心配置类

　　@MapperScan：扫描Mapper接口，为dao层生成动态代理

　　@ComponentScan：扫描有注解的类所在的包

　　@EnableTransactionManagement：开启事务的注解

　　@EnableAspectJAutoProxy：开启aop的注解

　　@Transactional表示开启事务，作用在类上为该类所有方法都开启一个事务，也可以作用在方法上，表示当前方法开启一个事务

2 spring新注解

原始注解的局限：
上面的原始注解不能完全替代xml，如非自定义对象dataSource：

新注解：

@Bean用法：

想把某个第三方对象管理到spring容器中，就定义一个类，类里定义一个返回该对象的方法，在方法上加@Bean，如果后面要注入这个资源，就七起个名称@Bean("XXX")，如果只是交给spring管理，就不需要起名。

二、spring整合mybatis纯注解版（实操）

准备：

创建如图所示项目目录：

第一步：创建数据库表
在Navicat下执行如下sql命令创建表User.

drop table if exists t_user;
create table t_user (
uid int(11) primary key not null AUTO_INCREMENT,
username varchar(20),
birthday varchar(20),
sex varchar(5),
address varchar(50)
);

insert into t_user values (1, '张三', '2022-05-03', '男', '北京');
insert into t_user values (2, '李四', '2022-05-19', '男', '广州');
insert into t_user values (3, '小红', '2022-05-19', '女', '郑州');
insert into t_user values (4, '小美', '2022-05-20', '女', '郑州');
select * from t_user;

第二步：创建bean
创建一个model包并在其下创建一个User.java文件。

public class User {
    private Integer uid;
    private String username;
    private String birthday;
    private String sex;
    private String address;

调用get set方法和tostring方法

第三步：创建DAO接口
创建一个包dao，并在其下创建一个UserDao.java文件作为DAO接口。

package com.su.dao;

import com.su.bean.User;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public interface UserDao {
    @Select("select * from t_user")
    List<User> selectAll();
}

第四步：创建UserService接口
创建一个包service，并在其下创建一个UserService.java文件作为service接口。

package com.su.service;

import com.su.bean.User;
import org.springframework.stereotype.Component;

import java.util.List;

public interface UserService {
    List<User> findAll();
}

第五步：实现UserService接口
在service包下创建一个UserServiceImpl.xml文件作为上一步创建的UserService接口的实现

package com.su.service.impl;

import com.su.bean.User;
import com.su.dao.UserDao;
import com.su.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserSeviceImpl implements UserService {
    @Autowired
    UserDao userDao;
    @Override
    public List<User> findAll() {
    return userDao.selectAll();
    }
}

第六步：创建SpringConfig类（配置类）
创建一个包config 在包里创建SpringConfig类

package com.su.config;

import com.mchange.v2.c3p0.DriverManagerDataSource;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;


import javax.sql.DataSource;
//@Configuration:告诉系统该类为配置类
@Configuration
//@ComponentScan("com.su")：扫描器扫描
@ComponentScan("com.su")
public class SpringConfig {
    //定义一个方法 创建对应的对象 然后给对象的属性赋值 最后使用@Bean交给IOC管理该对象
    @Bean
    public DataSource getDataSource(){
        DriverManagerDataSource dataSource=new DriverManagerDataSource();
        dataSource.setDriverClass("com.mysql.cj.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/mysql");
        dataSource.setUser("root");
        dataSource.setPassword("root");
        return dataSource;
    }
    @Bean
    public SqlSessionFactoryBean getSqlSessionFactoryBean(DataSource dataSource) {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource);

        return factoryBean;
    }
    @Bean
    public MapperScannerConfigurer getMapperScannerConfigurer(){
        MapperScannerConfigurer scannerConfigurer =new MapperScannerConfigurer();
        scannerConfigurer.setBasePackage("com.su.dao");

        return scannerConfigurer;

        }
    }

第七步：测试
在src下创建一个servlet包，并在其下创建一个test.java文件

package com.su.servlet;

import com.su.bean.User;
import com.su.config.SpringConfig;
import com.su.service.UserService;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.List;

public class Test01 {
    UserService userService;
    @Test
    public void findAllTest(){
        AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext(SpringConfig.class);
        userService=context.getBean(UserService.class);
        List<User> userList =userService.findAll();
        for (User user : userList) {
            System.out.println(user);
        }
    }
}