Spring07-整合Mybatis

最新推荐文章于 2022-11-03 15:26:05 发布
最新推荐文章于 2022-11-03 15:26:05 发布
阅读量136 收藏
点赞数
分类专栏： Mybatis 文章标签： spring java maven
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_39395819/article/details/122675452
版权
回顾MyBatis

1.在 Maven 中导入 MyBatis 需要的依赖

<dependencies>
    <!--Mysql驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.22</version>
    </dependency>
    <!--MyBatis-->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.7</version>
    </dependency>
    <!--junit-->
    <!--Junit单元测试-->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>5.7.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

​ 这些是 MyBatis 需要的依赖，还没有涉及到 Spring。

2.创建配置文件 mybatis-config.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>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=true&amp;serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="0723"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

这里就不用 db.properties 文件获取属性了，后面这个工作要交给 Spring 了。

3.创建 MyBatis 工具类

public class MyBatisUtil {
    // 提升作用域
    private static SqlSessionFactory sqlSessionFactory;
    static {
        try {
            // 使用MyBatis第一步：获取SqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 从SqlSessionFactory中获取SqlSession
    public static SqlSession getSqlSession(){
        // sqlSession 其实类似于 connection
        SqlSession sqlSession = sqlSessionFactory.openSession();
        return sqlSession;
    }
}

基本的统一配置就完成了，下面就是对应数据库编写实体类和对应的 Mapper 了。

4.编写实体类 User，属性对应数据库中的字段

@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class User {
    private int id;
    private String name;
    private String pwd;
}

5.写完实体类，就要写对应的 Dao 层接口，即 UserMapper,放在 dao(或mapper) 包下

package com.qiyuan.dao;
...
public interface UserMapper {
    // 查询全部用户
    List<User> getUserList();
}

6.有了接口，就要有其对应的实现，即 UserMapper.xml，这里和 UserMapper接口放在同一包下（要记得让 Maven 能导出嗷）

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--命名空间namespace要绑定一个对应的Dao/Mapper接口，相当于实现它-->
<mapper namespace="com.qiyuan.dao.UserMapper">
    <!--select查询语句，使用别名记得配置 typeAlias -->
    <select id="getUserList" resultType="User">
        select * from user
    </select>
</mapper>

这里用到了别名，要在 mybatis-config.xml 中配置

    <typeAliases>
        <package name="com.baifu.pojo"/>
    </typeAliases>

7.然后在 mybatis-config.xml 中注册映射 mapper

    <mappers>
        <!--要求接口和其对应的 XML 名字相同，且在同一个包下-->
       <mapper class="com.baifu.mapper.UserMapper"/>
    </mappers>

直接用 class 方式注册绑定，比较简洁，不过要求接口和其对应的 XML 名字相同，且在同一个包下。

8.执行测试方法

public class MyTest {
    @Test
    public void getUserListTest(){
        // 不写注释了，看不懂入土吧！
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList = mapper.getUserList();
        for (User user : userList) {
            System.out.println(user);
        }
        sqlSession.close();
    }
}

运行发信报错：

org.apache.ibatis.binding.BindingException: Invalid bound statement (not found): com.baifu.mapper.UserMapper.getUserList

在“target-classes-com-baifu-mapper”下没有找到UserMapper.xml，**配置 Maven 以让 java 文件夹中的 xml 文件能成功导出！**在 pom.xml 中添加

<build>
    <resources>
        <!--让java目录下的properties和xml文件也能被导出-->
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
    </resources>
</build>

最基础的 MyBatis 应用就完成了，接下来引入 Spring。

MyBatis-Spring

通过 Spring 使用 MyBatis 有两种方式：使用 SqlSessionTemplate 和使用 SqlSessionDaoSupport。

1.导入依赖

要将 MyBatis 和 Spirng 结合起来，除了导入上面 MyBatis 的依赖，当然还要有 Spring 的依赖

<dependencies>
    <!--上面 MyBtais 的包-->
    ...
    <!-- Spring 框架 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.9</version>
    </dependency>
    <!-- AOP -->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.7</version>
    </dependency>
    <!-- Spring 管理 JDBC -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.3.9</version>
    </dependency>
    <!-- mybatis-spring -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.6</version>
    </dependency>
</dependencies>

注意这里相比之前的 Spring 项目，多了 spring-jdbc 和 mybatis-spring 的包，前者用于 Spring 管理数据库，后者作用就是是将 MyBatis 和 Spring 结合起来。

什么是 MyBatis-Spring？

MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。它将允许 MyBatis 参与到 Spring 的事务管理之中，创建映射器 mapper 和 SqlSession 并注入到 bean 中，以及将 Mybatis 的异常转换为 Spring 的 DataAccessException。 最终，可以做到应用代码不依赖于 MyBatis，Spring 或 MyBatis-Spring。

2.使用SqlSessionTemplate

SqlSessionTemplate 是 MyBatis-Spring 的核心。作为 SqlSession 的一个实现，这意味着可以使用它无缝代替你代码中已经在使用的 SqlSession。 SqlSessionTemplate 是线程安全的，可以被多个 DAO 或映射器所共享使用。

通过 Spring 去使用 MyBatis 的步骤为

  1. 创建 spring-dao.xml 配置文件（任意名，其实就是Spring的applicationContext.xml文件），管理数据库的配置，也相当于 MyBatisUtil 工具类

    配置数据源 dataSource

    <?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--data source-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://111.230.212.103:3306/mybatis?userSSL=true&amp;
                userUnicode=true&amp;characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="hsp"/>
    </bean>
  

</beans>

    在 Spring 中配置了数据源，mybatis-config 中的就可以删掉了

    <!-- mybatis-config.xml -->
<environments default="...">
	<!--用不到了，删了吧！-->
</environments>

  2. 在上边创建的spring-dao.xml 配置文件中创建 sqlSessionFactory 的 bean，同时设置数据源 dataSource 属性为上面配置的数据源，设置 configLocation 属性以绑定 MyBatis 配置文件

    <!-- sqlSessionFactory -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <!--绑定 MyBatis 配置文件！-->
    <property name="configLocation" value="classpath:mybatis-config.xml"/>
</bean>

    这里相当于 MyBatisUtil 工具类中的获取 SqlSessionFactory 实例！

    public class MyBatisUtil {
    private static SqlSessionFactory sqlSessionFactory;
    static {
        try {
            // 使用MyBatis第一步：获取SqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    ...
}

  3. 在 sqlSessionFactory 的 bean 中也可以配置其属性，和在 mybatis-config 中配置是一样的！如注册 Mapper

    <!-- sqlSessionFactory -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
	...
    <!--如，在这里注册 Mapper -->
    <property name="mapperLocations" value="classpath:com/baifu/mapper/*.xml"/>
</bean>


     这里就用到之前 MyBatis 中不能用的通配符了，因为**通配符是由 Spring 提供**的！

 在 bean 中配置了，mybatis-config 中配置的 mapper 也可以删掉了。

    <!-- mybatis-config.xml -->
<mappers>
    <!--不用了！-->
</mappers>

    ​ 这样一来，mybatis-config.xml 中几乎已经没有内容了（还剩一个别名 typeAlias ），虽然别名也能在 bean 中配置，不过最好将别名 typeAlias 和设置 settings 放在 mybatis-config.xml 中，方便查看和修改

    <!--仅存的 mybatis-conifg 内容-->
<?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>
    <typeAliases>
        <package name="com.baifu.pojo"/>
    </typeAliases>

</configuration>

  4. 有了配置好的 sqlSessionFactory 后，就可以用它获取 sqlSession了。

    ​ 创建 sqlSession 的 bean，注入 sqlSessionFactory 依赖

    <!-- SqlSessionTemplate 就是 SqlSession！-->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
    <!--只能用构造器注入，因为它没有 set 方法！-->
    <!-- 把工厂给它，就能从中 get 到 SqlSession 了-->
    <constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>

    SqlSessionTemplate 类只能通过构造器注入 sqlSessionFactory 依赖，这就是一个 SqlSession 了。

  5. 重点来了！由于面向对象的思想，要把对象交给 Spring 管理，而之前使用 MyBatis 时，Mapper.xml 充当了接口的实现类，这个实现类无法让 Spring 管理，所以要写一个真正的接口实现类，封装 Mapper.xml，交给 Spring 管理！

    创建 UserMapperImpl 类，实现了 UserMapper 接口，即有对数据库操作的方法

    public class UserMapperImpl implements UserMapper{
    // 原来的操作，使用 SqlSession 实现，现在使用 SqlSessionTemplate
    // 不过还是叫做 sqlSession 亲切！
    private SqlSessionTemplate sqlSession;

    // 添加 set 方法，以注入属性
    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }

    // 在这里进行封装！
    public List<User> getUserList() {
        // IoC 的思想！不用去 new 一个 sqlSession 了，注入后就能用！
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList = mapper.getUserList();
        return userList;
    }
}

    其中，有一个属性 sqlSession（变成了 SqlSessionTemplate 也是一样用法）及其对应的 set 方法，通过 Spring 依赖注入后就能使用，相当于之前的

    SqlSession sqlSession = MyBatisUtil.getSqlSession();
// 关闭应该是由 Spring 管理的吧...

    在这个“真”实现类（ UserMapperImpl 类）中调用了“假”实现类（ UserMapper.xml ）的方法，相当于多了一层封装，也变成了一个真实存在的类，方便 Spring 管理！

  6. 把真实现类交给 Spring 管理，同时进行依赖注入

        <bean id="userMapper" class="com.baifu.mapper.UserMapperImpl">
        <!--注入 sqlSession！-->
        <property name="sqlSession" ref="sqlSession"/>
    </bean>

    这时，获取 userMapper 对象后执行其中的方法，就会到 UserMapper.xml 执行对应的语句，和之前区别不大，只是多了一层封装以方便管理！

  7. 方法测试

    public class MyTest {
    @Test
    public void MyBatisSpringTest(){
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
        List<User> userList = userMapper.getUserList();
        for (User user : userList) {
            System.out.println(user);
        }
    }
}
// 执行结果
/*
User(id=1, name=www, pwd=99999)
User(id=2, name=baifu, pwd=6666)
User(id=3, name=李四, pwd=123890)
*/

优化：可以注意到，大部分配置都在 spring-dao.xml 文件中，这个文件做了几件事

  1. 配置数据源，即连接数据库的一些配置（ mybatis-config.xml 中的 environment 部分）
  2. 创建 sqlSessionFactory 的 bean，进行依赖注入（ mybatis-config.xml 中的 mapper 部分，MyBatisUtil 的创建 sqlSessionFactory 部分）
  3. 创建 sqlSession 的 bean，将 sqlSessionFactory 注入进去（ MyBatisUtil 中的 sqlSessionFactory.openSession ）
  4. 创建真实现类 UserMapperImpl 的 bean，为其注入 sqlSession

其中，第1、2、3步都是配置和工具类干的事情，属于改动比较少的部分；而第4步属于会经常会进行的步骤，如增加 StudentMapperImpl、TeacherMapperImpl 等的 bean。

所以将第4步这种配置抽出来，留下1、2、3步，使得 spring-dao.xml 变成了一个比较纯洁的配置文件

<?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 用 Spring 的数据源 替换 MyBatis 的数据源 -->
    <!--data source-->
    <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/mybatis?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=true&amp;serverTimezone=UTC"/>
        <property name="username" value="root"/>
        <property name="password" value="hsp"/>
    </bean>

    <!-- sqlSessionFactory -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!--绑定 MyBatis 配置文件！-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <!--如，在这里注册 Mapper -->
        <property name="mapperLocations" value="classpath:com/baifu/mapper/UserMapper.xml"/>
    </bean>

    <!-- SqlSessionTemplate 就是 SqlSession！-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--只能用构造器注入，因为它没有 set 方法！-->
        <!-- 把工厂给它，就能从中 get 到 SqlSession 了-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>
</beans>

至于第4步这种操作，创建了一个要具体用到的对象，还是放到 applicationContext.xml 中进行管理吧！

创建 applicationContext.xml，通过 import 标签引入 spring-dao.xml，把真正要用到的对象，即 userMapper 交给它管理

<?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--通过 import 标签引入 spring-dao.xml -->
    <import resource="spring-dao.xml"/>

    <bean id="userMapper" class="com.baifu.mapper.UserMapperImpl">
        <!--注入 sqlSession！-->
        <property name="sqlSession" ref="sqlSession"/>
    </bean> 
    
</beans>

测试时记着更改配置文件由于spring-dao.xml—>applicationContext.xml：

 ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

这样几个配置文件的作用都很明确了，mybatis-config 负责 MyBatis 的一些配置（别名、设置），spring-dao 管理了 MyBatis 连接数据库、创建 SqlSession和注册 mapper 的配置，applicationContext 整合了 Spring 的配置（现在是 spring-dao，后面还会有 spring-mvc 等等）和管理要用到对象。

3.使用SqlSessionDaoSupport

使用 SqlSessionDaoSupport 与使用 SqlSessionTemplate 大同小异，只不过更简化了一点。

上面说到，UserMapperImpl 类中有一个 SqlSessionTemplate 类型的 sqlSession 属性，实现的方法中封装了使用 SqlSession 对数据库的操作，调用它的方法就相当于在使用 SqlSession。

这种方式在使用前需要注入 sqlSession 属性，而 SqlSession 又由 SqlSessionFactory 创建。也就是说，使用这种方式需要 SqlSessionFactory 和 SqlSession 的 bean。

使用 SqlSessionDaoSupport 省略了创建 SqlSession 的 bean 的步骤。

创建 UserMapperImpl2 实现类，继承 SqlSessionDaoSupport 类，实现 UserMapper 接口

public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper{
    public List<User> getUserList() {
        return null;
    }
}

重点来了！**SqlSessionDaoSupport 类中有 getSqlSession 方法，可以直接获得一个 sqlSession！**用这个 sqlSession 去执行数据库操作就行了！

public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper{
    public List<User> getUserList() {
        SqlSession sqlSession = getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList = mapper.getUserList();
        return userList;
    }
}

能用是能用，但必须思考为什么能用。**为什么 SqlSessionDaoSupport 类可以通过 getSqlSession 方法返回一个 SqlSession？**我们知道，SqlSession 是由 SqlSessionFactory 创建的，所以，点进去看看

public abstract class SqlSessionDaoSupport extends DaoSupport {
	private SqlSessionTemplate sqlSessionTemplate;
    
    public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {
        // 从工厂获取 sqlSessionTemplate
    }
}

原来如此！SqlSessionDaoSupport 类中就需要注入一个 sqlSessionFactory，以获取其中的 sqlSessionTemplate 对象，返回的就是这个对象！

所以在注册 UserMapperImpl2 的实现类的时候，要注入 sqlSessionFactory 依赖

<bean id="userMapper2" class="com.baifu.mapper.UserMapperImpl2">
        <!--注入 sqlSession！-->
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>

它会通过注入的 sqlSessionFactory，获取 sqlSessionTemplate，也就是之前的方式获取到的 SqlSession 了（回见 2.2 / 4. ）。

执行测试方法，获取的是 userMapper2 对象，执行结果相同！

public class MyTest {
	@Test
    public void MyBatisSpringTest2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = context.getBean("userMapper2", UserMapper.class);
        List<User> userList = userMapper.getUserList();
        for (User user : userList) {
            System.out.println(user);
        }
    }
}

这样就完成了，相比直接使用 SqlSessionTemplate 的方式，SqlSessionDaoSupport 将其封装了起来，从 SqlSessionDaoSupport 中就可以获取到 SqlSession，不用配置 sqlSession 的 bean 和注入了(由继承的SqlSessionDaoSupport这个类完成了，剩一步)。

总结

使用 MyBatis-Spring 有两种方式

  • 使用SqlSessionTemplate：就是直接使用 SqlSession，需要将 SqlSession 注入到实现类中进行使用。

  • 使用SqlSessionDaoSupport：实现类继承 SqlSessionDaoSupport 类，把工厂交给它（通过注入），就能从它获取 SqlSession。

使用 MyBatis-Spring 需要创建与 Mapper.xml 对应的实现类，在实现类中调用 Mapper.xml 实现数据库操作。实例化 Mapper.xml 为一个实现类的目的是让 Spring 能管理它。

参考： https://blog.youkuaiyun.com/qq_43560701/article/details/119960903

Spring + MyBatis
xu123shun的博客
11-13 858
介绍MyBatis如何与Spring 整合开发
【Spring】Spring集成MyBatis
爱写bug的王六六
11-10 1472
集成思路 Spring能集成很多的框架，是Spring一个优势功能。 通过集成功能，让开发人员使用其他框架更方便。 集成使用的是Spring IoC 核心技术。 要使用框架，例如mybatis，怎么使用mybatis ？ Spring集成MyBatis的目的????将Mybatis框架中用到的对象交给Spring来管理，主要是SqlSessionFactory和dao代理，把这两个交给容器Spring。在Spring主配置文件中声明对象 使用mybatis，需要创建mybatis框架中的某些对象， 使用这
Spring整合MyBatis
qq_43560701的博客
08-27 345
Spring整合MyBatis 了解完 Spring 的基本使用后，就可以将 Spring 和 MyBatis 结合起来使用一下了。这里创建 Spring-10-MyBatis 项目练习一下用 Spring 整合 MyBatis。 1. 回顾MyBatis 距离学习 MyBatis 已经有一段时间了，都快忘了怎么用了。 先尝试单独搭建一个 MyBatis 项目，有以下几步 在 Maven 中导入 MyBatis 需要的依赖 <dependencies> <!--Mysql驱动-
【MyBatis学习14】MyBatis和Spring整合
武哥聊编程
06-16 1万+
前面十几篇博文总结了mybatis在开发中的相关技术，但在实际中都是和spring整合开发的，所以这里总结一下mybatis和spring的整合方法，并在整合后进行测试。 1. 整合的环境 这都是老掉牙的问题了，不管是开发还是整合，首先环境肯定得有，环境嘛，除了java环境和开发环境外，那就是jar包咯，关于mybatis和spring整合的jar包，我已经上传到下载频道了==&gt;传送门 将这
Spring学习（5）——Spring集成Mybatis
weixin_43721056的博客
05-02 520
经过之前的学习，已经将mybatis和spring的基本用法掌握了，下面开始进行的是将这两个框架进行整合。用的技术是Spring中的IoC。 为什么使用IoC呢？ 能把mybatis和spring集成在一起，像一个框架， 是因为ioc能创建对象。可以把mybatis框架中的对象交给spring统一创建， 开发人员从spring中获取对象。开发人员就不用同时面对两个或多个框架了， 就面对一个spring。 将 MyBatis 与 Spring 进行整合，主要解决的问题就是将 SqlSessionFactory
Spring中整合MyBatis
qq_25447799的博客
10-25 132
文章目录在Spring中整合MyBatis1、整合MyBatis2、 回顾Mybatis3、mybatis-spring-方式一 在Spring中整合MyBatis 1、整合MyBatis 1、导入相关jar包 <dependencies> <!--junit--> <dependency> <groupId>junit</groupId> <artifactId&gt
spring-mybatis整合jar包，spring-mybatis整合jar包
03-17
3. **mybatis-3.2.7.jar**：Mybatis是轻量级的ORM框架，它简化了SQL操作，允许开发者直接编写SQL语句并将其映射到Java对象上。在这个整合包中，Mybatis作为数据访问层的工具，与Spring的IoC容器配合，实现了DAO...
spring-spring-mvc-mybatis整合例子
03-05
- 配置MyBatis：在`mybatis-config.xml`中设置数据源、事务管理器等，并定义Mapper XML文件的位置。 - 编写Mapper接口和XML文件：定义数据库操作的方法，XML文件中编写对应的SQL语句。 - 创建Service层：在...
Spring-SpringMVC-Mybatis整合所有jar包
09-09
这个压缩包“ssm-lib”包含了所有整合所需的库文件，包括Spring的相关jar包（如spring-context、spring-webmvc等）、Mybatis的jar包以及其对Spring的适配器（mybatis-spring）、还有可能包括数据库驱动和其他辅助库...
spring-mybatis:spring 整合 mybatis
05-19
三、Spring整合MyBatis的关键步骤 1. 使用`@MapperScan`注解扫描Mapper接口：在Spring配置类上添加此注解，以便Spring自动发现并管理Mapper接口。 ```java @Configuration @MapperScan("com.example.mapper") ...
spring注解开发使用教程--整合Mybatis和Junit(二).zip
04-18
2. Mybatis与Spring的整合，涉及到`mybatis-config.xml`配置、`@MapperScan`、`@Mapper`注解以及事务管理。 3. JUnit在Spring环境下的使用，包括`@RunWith(SpringRunner.class)`、`@SpringBootTest`、`@Sql`、`@Test...
Spring和Mybatis的整合
beautifulsen的博客
11-03 5880
spring和mybatis的整合，回顾之前的笔记
Spring集成MyBatis
caijigskg的博客
04-08 6473
将mybatis与spring进行整合，主要解决的问题就是讲SqlSessionFactory对象交由spring来管理，所以，该整合，只需要将SqlSessionFactory的对象生成器SqlSessionFactoryBean注册在spring容器中，再将其注入给Dao的实现类即可完成整合。 实现spring与mybatis的整合常用的方式：扫描的Mapper动态代理 spring就像插线板一样，mybatis框架是插头，可以很容易的组合到一起。mybatis插头插入spring插线板就是一个整体
Spring——Spring整合MyBatis
热门推荐
贝尔摩德苦艾酒
03-13 2万+
Spring——Spring整合MyBatis
Spring整合Mybatis
ShiZaolin的博客
12-06 165
步骤： 1.导入jar包 创建好项目后，在web下面创建lib文件夹，用于存放jar包。 1.mybatis的jar包： 2.数据库驱动jar包 3.数据库连接池DBCPjar包 4.Spring的jar包 5.Mybatis和Spring整合包 2.添加好jar包后右击lib，选择添加为库（Create Library） 3.在src下创建配置mybatis的核心配置文件SqlMap...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值