Spring整合MyBatis

最新推荐文章于 2023-01-05 11:43:23 发布
最新推荐文章于 2023-01-05 11:43:23 发布
阅读量280 收藏
点赞数 1
分类专栏： Spring 文章标签： spring mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43560701/article/details/119960903
版权

Spring整合MyBatis

了解完 Spring 的基本使用后，就可以将 Spring 和 MyBatis 结合起来使用一下了。这里创建 Spring-10-MyBatis 项目练习一下用 Spring 整合 MyBatis。

1. 回顾MyBatis

距离学习 MyBatis 已经有一段时间了，都快忘了怎么用了。

先尝试单独搭建一个 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 工具类，直接从之前的 MyBatis 笔记中偷过来😋

    public class MyBatisUtil {
    // 提升作用域
    private static SqlSessionFactory sqlSessionFactory;
    static {
        try {
            // 使用MyBatis第一步：获取SqlSessionFactory对象
            String resource = "org/mybatis/example/mybatis-config.xml";
            // 要导org.apache.ibatis.io.Resources的包！ Maven犯病严重
            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 了。

    写到测试方法的时候错回来了：这是什么几把东西啊？

    String resource = "org/mybatis/example/mybatis-config.xml";

    捏麻麻的，抄！抄出问题来了。配置文件放在 resources 文件夹中，直接 ↓ 就行了！

    String resource = "mybatis-config.xml";

  4. 编写实体类 User，属性对应数据库中的字段，以免多生事端

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

    顺便把 Lombok 也用上了，这玩意是真滴好用😋

  5. 写完实体类，就要写对应的 Dao 层接口，即 UserMapper

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

    注意放在 dao 包下哦，差点就和 User 类放一起了。

  6. 有了接口，就要有其对应的实现，即 UserMapper.xml，这里和 User 类放在同一包下（要记得让 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.qiyuan.entity"/>
    </typeAliases>

    直接包扫描，反正现在也不用 log4j 日志😕

  7. 然后不要忘记，在 mybatis-config.xml 中注册映射 mapper，特意写成一个步骤！

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

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

  8. 又来了！**配置 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>

    resources 目录下的本来就能导出，加了反而报错。

  9. 到现在才是真搞完了，执行测试方法

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

    这样就成功了。写到了遇到了两个 Bug：一是 MyBatis 工具类中的资源文件路径写错了，见3；二就是 Maven 的配置导出问题了，见8。

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

2. MyBatis-Spring

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

2.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.2 使用SqlSessionTemplate

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

通过 Spring 去使用 MyBatis 的步骤为

  1. 创建 spring-dao.xml 配置文件（也可以是其他名字啦），管理数据库的配置，也相当于 MyBatisUtil 工具类

    配置数据源 dataSource

    <!-- 用 Spring 的数据源 替换 MyBatis 的数据源 -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <!--就是 mybatis-config 中 数据源 dataSource 的属性！-->
    <property name="driverClassName" 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"/>
</bean>

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

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

  2. 创建 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/qiyuan/dao/*.xml"/>
</bean>

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

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

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

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

    <!--仅存的 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.qiyuan.entity"/>
    </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.qiyuan.dao.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=祈鸢, pwd=123456)
    User(id=2, name=qiyuanc2, pwd=0723)
    User(id=3, name=風栖祈鸢, pwd=07230723)
    User(id=5, name=祈鸢bbb, pwd=123123)
*/

    执行成功！相比之前，更加简洁明了了。获取 context 容器，获取容器的的对象，调用对象的方法，一气呵成！

优化：可以注意到，大部分配置都在 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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 用 Spring 的数据源 替换 MyBatis 的数据源 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <!--就是 mybatis-config 中 数据源 dataSource 的属性！-->
        <property name="driverClassName" 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"/>
    </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/qiyuan/dao/*.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.qiyuan.dao.UserMapperImpl">
        <!--注入 sqlSession！-->
        <property name="sqlSession" ref="sqlSession"/>
    </bean>
    
</beans>

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

记得加载配置文件的时候加载 applicationContext.xml 哦！

2.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.qiyuan.dao.UserMapperImpl2">
    <!--注入 sqlSessionFactory！-->
    <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 和注入了。

3. 总结

使用 MyBatis-Spring 有两种方式

  • 使用SqlSessionTemplate：就是直接使用 SqlSession，需要将 SqlSession 注入到实现类中进行使用。
  • 使用SqlSessionDaoSupport：实现类继承 SqlSessionDaoSupport 类，把工厂交给它（通过注入），就能从它获取 SqlSession。

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

内容好多，越写越乱！希望后面看得懂😵…

Omoikaese
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Spring + MyBatis
xu123shun的博客
11-13 747
介绍MyBatis如何与Spring 整合开发
史上最详细mybatis与spring整合教程
tianshouzhi的专栏
04-12 5688
点击上方"田守枝的技术博客"，关注我mybatis本身使用比较灵活，和spring整合也有多种方式。本文一网打尽mybatis与spring整合所有方式，让你彻底掌握my...
Java：Spring + MyBatis框架整合
chenyouchang的博客
01-05 1078
Spring整合MyBatis框架
mybatis和spring整合开发(完整版)
csfun1的博客
10-30 542
一、mybatis和spring整合原始dao层开发 1、mybatis框架执行简述： 1、配置mybatis配置文件（sqlMapConfig名称不固定）。 2、通过配置文件，创建sqlSessionFactory,加载mybatis运行环境。 3、由第二步的工厂产生sqlSession会话 4、调用sqlsession操作jdbc 5、释放资源sqlSession。 2、mybatis和spr...
spring整合Mybatis
10-24
spring整合Mybatis纯净项目，基础搭建，下载就用，包含整套源码，jar包
Spring整合Mybatis与SpringBoot整合Mybatis原理分析
04-16
一个完整而简单SSM项目，包含SQL脚本、代码与学习笔记。内容Spring如何整合SpringMVC与Mybatis以及整合原理的源码分析。
Spring整合Mybatis
09-15
Spring整合Mybatis
spring整合mybatis的jar_spring+mybatis_
10-03
使用spring+mybatis自动生成实体类工具包，部分错误解决方案等
spring 整合 mybatis 中数据源的几种配置方式(总结篇)
08-27
因为spring 整合mybatis的过程中， 有好几种整合方式，尤其是数据源那块，经常看到不一样的配置方式，总感觉有点乱，所以今天有空总结下，感兴趣的朋友跟随脚本之家小编一起学习吧
MyBatis和Spring整合jar：mybatis-3.2.7.jar等
03-09
MyBatis和Spring整合jar: mybatis-3.2.7.jar mybatis-spring-1.2.2.jar
【Spring】Spring集成MyBatis
爱写bug的王六六
11-10 1305
集成思路 Spring能集成很多的框架，是Spring一个优势功能。 通过集成功能，让开发人员使用其他框架更方便。 集成使用的是Spring IoC 核心技术。 要使用框架，例如mybatis，怎么使用mybatis ？ Spring集成MyBatis的目的????将Mybatis框架中用到的对象交给Spring来管理，主要是SqlSessionFactory和dao代理，把这两个交给容器Spring。在Spring主配置文件中声明对象 使用mybatis，需要创建mybatis框架中的某些对象， 使用这
spring整合mybatis详解
Java学习博客
09-30 3022
spring整合mybatis的步骤详解
sqlSession.getMapper(UserMapper.class)的使用方式
Mars Suburbs People
09-10 2266
说明： 1，本文采用的Mybatis框架版本为： mybatis-3.0.4.jar 2， 以持久化一个简单的User bean为例 User实体类的代码如下： package bean; public class User { private String name; private Integer age; ...
spring和mybatis整合，spring获取sqlsession对象
six_666666的博客
09-12 1万+
这里不做过多解释，主要是把spring和mybatis整合起来，自己在网上找了很久发现获取sqlsession对象的方法比较少 首先还是jar文件一个不能少这个可以自己准备也可以去我上传的资源中找到 mysql表 下面直接上配置 1、配置User类（工具类） package domain; import org.apache.ibatis.session.SqlSessio
Spring学习（5）——Spring集成Mybatis
weixin_43721056的博客
05-02 404
经过之前的学习，已经将mybatis和spring的基本用法掌握了，下面开始进行的是将这两个框架进行整合。用的技术是Spring中的IoC。 为什么使用IoC呢？ 能把mybatis和spring集成在一起，像一个框架， 是因为ioc能创建对象。可以把mybatis框架中的对象交给spring统一创建， 开发人员从spring中获取对象。开发人员就不用同时面对两个或多个框架了， 就面对一个spring。 将 MyBatis 与 Spring 进行整合，主要解决的问题就是将 SqlSessionFactory
Spring+Mybatis整合（详细）
qq_45387521的博客
03-22 363
Spring+Mybatis整合（详细） 第一步：jar包（16个可用maven） 使用IDEA的在WEB-INF下建立一个lib文件把jar包复制进去标记为库 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oGbcBFan-1616423000351)(C:\Users\lbw\AppData\Roaming\Typora\typora-user-images\image-20210321201715607.png)] 第二步：将数据库的类和表进行映射 创建实例类生成get
Spring+MyBatis+MyBatis-Plus整合及步骤详解
Fiona20的博客
03-16 7025
准备工作 了解Maven 设计数据库表 了解MyBatis 了解Spring 了解SpringMVC 知道哪里去找依赖吗？ https://mvnrepository.com/artifact/org.springframework 一、Spring+MyBatis整合 导入依赖 <dependencies> <dependency> <groupId>junit</groupId>
SqlSessionTemplate详解——Mybatis+Spring Boot
热门推荐
yqf66的博客
09-01 1万+
<dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>1.3.1</version> </dependency>
spring整合mybatis
最新发布
09-04
Spring 整合 MyBatis 可以通过以下步骤完成： 1. 引入相关依赖：在项目的 pom.xml 文件中添加 Spring 和 MyBatis 的依赖，例如： ``` <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.3.3</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.6</version> </dependency> ``` 2. 配置数据源：在 Spring 的配置文件中配置数据源，例如： ``` <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="com.mysql.jdbc.Driver" /> <property name="url" value="jdbc:mysql://localhost:3306/test" /> <property name="username" value="root" /> <property name="password" value="password" /> </bean> ``` 3. 配置 MyBatis：在 Spring 的配置文件中配置 MyBatis，例如： ``` <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="dataSource" /> <property name="typeAliasesPackage" value="com.example.model" /> <property name="mapperLocations" value="classpath:mapper/*.xml" /> </bean> <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"> <property name="basePackage" value="com.example.mapper" /> </bean> ``` 4. 编写 Mapper：创建 Mapper 接口并编写 SQL 语句，例如： ``` public interface UserMapper { @Select("SELECT * FROM user WHERE id = #{id}") User findById(Long id); } ``` 5. 注入 Mapper：在 Service 层中注入 Mapper 并调用相应方法，例如： ``` @Autowired private UserMapper userMapper; public User findById(Long id) { return userMapper.findById(id); } ``` 完成以上步骤后，Spring 和 MyBatis 就成功整合了。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值