Spring整合MyBatis(快速上手)

Mybatis的详细教程链接

1.纯XML方式整合

1. 构建Maven工程，在Pom.xml中导入所需的坐标

        <!-- Spring核心-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>

        <!--mybatis核心-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.9</version>
        </dependency>
       <!-- mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.30</version>
        </dependency>
        <!--spring整合mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.0</version>
        </dependency>
        <!--druid数据源-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.16</version>
        </dependency>
        <!--spring管理jdbc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
        <!--简化POJO开发 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
            <scope>provided</scope>
        </dependency>
        <!--Junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!--spring整合Junit-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>

2. 在 resource 目录下，编写配置文件

applicationContext.xml(spring整合mybatis的核心配置文件)内容如下:

<?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">

    <!--加载jdbc.properties配置文件，并不使用系统属性  -->
    <context:property-placeholder location="jdbc.properties" system-properties-mode="NEVER" />

    <!--将druid数据源注入到spring容器中-->
    <bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
        <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>
    
    <!--将mybatis的核心对象sqlSessionFactory注入到spring容器中 -->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean" id="sqlSessionFactory">
        <property name="typeAliases" value="com.maoge.pojo"/>
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--将MapperScannerConfigurer(Mapper映射)注入到spring容器中-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer" id="mapper">
        <property name="basePackage" value="com.maoge.dao"/>
    </bean>
    
</beans>

jdbc.properties文件内容如下：

jdbc.driverClassName=com.mysql.cj.jdbc.Driver     # 数据库驱动名
jdbc.url=jdbc:mysql:///cloud-user                 # 数据库连接地址
jdbc.username=root                                # 数据库用户名
jdbc.password=root                                     # 数据库密码

注意：此处url使用了简写方式，完整写法：jdbc:mysql://localhost:3306/[数据库名]

3.在源代码目录main下的java中编写对应的POJO层、DAO层、Service层

注意：DAO接口位置要与applicationContext.xml中Mapper映射的basePackage保持一致

POJO

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private Integer id;
    private String username;
    private Integer age;
}

DAO

public interface UserDAO {
    //查询所有用户
    @Select("select * from user")
    public List<User> getUserAll();
    //通过id查询一个用户
    @Select("select * from user where id=#{id}")
    public User getUserById(int id);
}

Service

//UserDAO.java
public interface UserService {
    
    public List<User> getUserAll();
    
    public User getUser();
}

//UserDAOimpl.java
public class UserServiceimpl implements UserService {
    //自动注入
    @Autowired
    UserDAO userDAO;

    @Override
    public List<User> getUserAll() {
        return userDAO.getUserAll();
    }

    @Override
    public User getUser(int id) {
        return userDAO.getUserById(id);
    }
}

并将userService注入到spring容器中（加入userService的bean）：

<bean class="com.maoge.service.UserServiceimpl" id="userService"/>

单元测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath*:applicationContext.xml")
public class Test1 {

    @Test
    public void testUserService(){
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        UserService userService = applicationContext.getBean(UserService.class);
        //查询user表中所有用户并遍历
        List<User> userList = userService.getUserAll();
        for (User user : userList) {
            System.out.println(user);
        }
        System.out.println("================");
        //通过id查询用户
        User user = userService.getUser(1);
        System.out.println(user);
    }
}

结果：

2.纯注解方式整合

纯注解方式整合与XMl方式大致相同，主要区别在于：

• 配置文件写成了JavaConfig
• 使用了大量的注解形式注入spring容器

博主重点说明要修改的部分，没有说的与XML方式配置雷同

将 applicationContext.xml 修改成 java 的 config

SpringConfig.java

@Configuration  //代表spring的配置类
@ComponentScan({"com.maoge"})    //指定扫描注解的目录
@Import({JdbcConfig.class,MybatisConfig.class}) //导入其他的配置类
@PropertySource({"jdbc.properties"}) //加载jdbc配置文件
public class SpringConfig { }

MybatisConfig.java

public class MybatisConfig {

    //将SqlSessionFactoryBean注入到spring容器中,成为bean
    @Bean
    public SqlSessionFactoryBean factoryBean(DataSource dataSource){
        SqlSessionFactoryBean sqlSessionFactoryBean=new SqlSessionFactoryBean();
        //配置druid数据源
        sqlSessionFactoryBean.setDataSource(dataSource);
        return sqlSessionFactoryBean;
    }


    //代替mapper映射器
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer mscf=new MapperScannerConfigurer();
        //指定代理的路径
        mscf.setBasePackage("com.maoge.dao");
        return mscf;
    }

}

JdbcConfig.java

public class JdbcConfig {

    @Value("${jdbc.driverClassName}")
    public String driver;
    @Value("${jdbc.url}")
    public String url;
    @Value("${jdbc.username}")
    public String username;
    @Value("${jdbc.password}")
    public String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource druidDataSource=new DruidDataSource();
        druidDataSource.setDriverClassName(driver);
        druidDataSource.setUrl(url);
        druidDataSource.setUsername(username);
        druidDataSource.setPassword(password);
        return druidDataSource;
    }
}

将DAO层、Service层通过注解注入Spring容器中

• DAO层 使用 @Repository 注解注入
• Service使用 @Service 注解注入

如果用到了Controller层使用 @Contoller 注解

注意：注解是写在接口的实现类上的

示例：

@Repository
public interface UserDAO {
//方法体内容省略，与上面雷同
}

@Service
public class UserServiceimpl implements UserService {
//方法体内容省略，与上面雷同
}

使用单元测试运行：