首页 > 软件编程 > java > Mybatis框架的整合使用

Mybatis和其他主流框架的整合使用过程详解

2023-11-17 09:05:35 作者：琮墨

MyBatis最初是Apache的一个开源项目iBatis, 2010年6月这个项目由Apache Software Foundation迁移到了Google Code，这篇文章主要介绍了Mybatis和其他主流框架的整合使用,需要的朋友可以参考下

Mybatis简介

MyBatis历史

MyBatis最初是Apache的一个开源项目iBatis, 2010年6月这个项目由Apache Software Foundation迁移到了Google Code。随着开发团队转投Google Code旗下，iBatis3.x正式更名为MyBatis。代码于2013年11月迁移到Github
iBatis一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。iBatis提供的持久层框架包括SQL Maps和Data Access Objects（DAO）

MyBatis特性

MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架
MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集
MyBatis可以使用简单的XML或注解用于配置和原始映射，将接口和Java的POJO（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录
MyBatis 是一个半自动的ORM（Object Relation Mapping）框架

1、在Maven项目中使用Mybatis

　　先创建一个普通的Maven项目，然后在pom.xml文件中引入Mybatis的依赖，因为要连接数据库，所以还需要引入数据库连接的依赖

 <dependencies>
        <dependency>
              <groupId>org.mybatis</groupId>
              <artifactId>mybatis</artifactId>
              <version>3.5.10</version>
          </dependency>
          <dependency>
              <groupId>mysql</groupId>
              <artifactId>mysql-connector-java</artifactId>
             <version>8.0.33</version>
         </dependency>
     </dependencies>

　　要使用Mybatis需要配置Mybatis的核心配置，在resources资源文件夹下创建一个mybatis配置文件（名字随意），并写入配置，配置参考Mybatis官方文档mybatis – MyBatis 3 | 入门

在数据源<dataSource>的配置中,配置好driver,url,username,password

 <?xml version="1.0" encoding="UTF-8" ?>
  <!DOCTYPE configuration
         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
          "https://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.cj.jdbc.Driver"/>
                 <property name="url" value="jdbc:mysql://localhost:3307/mybatis"/>
                 <property name="username" value="root"/>
                 <property name="password" value="root"/>
             </dataSource>
         </environment>
     </environments>
     <!--<mappers>
         <mapper resource="org/mybatis/example/BlogMapper.xml"/>
     </mappers>-->
 </configuration>

　　习惯上命名为mybatis-config.xml，这个文件名仅仅只是建议，并非强制要求。将来整合Spring之后，这个配置文件可以省略，所以大家操作时可以直接复制、粘贴。核心配置文件主要用于配置连接数据库的环境以及MyBatis的全局配置信息核心配置文件存放的位置是src/main/resources目录下

　　现在需要一个数据库和表和一些数据用做连接测试

 CREATE DATABASE IF NOT EXISTS `mybatis` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
  CREATE TABLE USER(
       `id` INT UNSIGNED PRIMARY KEY AUTO_INCREMENT COMMENT 'ID',
       `name` VARCHAR(100) COMMENT '姓名',
      `age` TINYINT UNSIGNED COMMENT '年龄',
       `gender` TINYINT UNSIGNED COMMENT '性别, 1:男, 2:女',
       `phone` VARCHAR(11) COMMENT '手机号'
  ) COMMENT '用户表';
 INSERT INTO USER(id, NAME, age, gender, phone) VALUES (NULL,'白眉鹰王',55,'1','18800000000');
 INSERT INTO USER(id, NAME, age, gender, phone) VALUES (NULL,'金毛狮王',45,'1','18800000001');
 INSERT INTO USER(id, NAME, age, gender, phone) VALUES (NULL,'青翼蝠王',38,'1','18800000002');
 INSERT INTO USER(id, NAME, age, gender, phone) VALUES (NULL,'紫衫龙王',42,'2','18800000003');
 INSERT INTO USER(id, NAME, age, gender, phone) VALUES (NULL,'光明左使',37,'1','18800000004');
 INSERT INTO USER(id, NAME, age, gender, phone) VALUES (NULL,'光明右使',48,'1','18800000005');

　　构建整体项目结构controller、service、mapper三层架构，创建一个实体类对应数据库的表结构，创建MyBatis的映射文件xxxMapper.xml

映射文件的命名规则

表所对应的实体类的类名+Mapper.xml
例如：表t_user，映射的实体类为User，所对应的映射文件为UserMapper.xml
因此一个映射文件对应一个实体类，对应一张表的操作
MyBatis映射文件用于编写SQL，访问以及操作表中的数据
MyBatis映射文件存放的位置是src/main/resources/mappers目录下

在resources文件目录下创建mapper的时候需要和main文件目录下的mapper同包名，在创建directory的时候，目录结构不能使用点，而是用/代替

User实体类中的属性需要和表中的字段名相对应，这里也可以用Lombok注解

mapper接口的全类名和映射文件的命名空间（namespace）保持一致、mapper接口中方法的方法名和映射文件中编写SQL的标签的id属性保持一致

然后在mapper中写我们需要的语句，查询语句用<select>、增加语句用<insert>、删除语句用<delete>、修改语句用<update>标签，返回类型resultType要和实体类中的实体类名称对应

 <?xml version="1.0" encoding="UTF-8" ?>
  <!DOCTYPE mapper
          PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
          "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
  <mapper namespace="mapper.UserMapper">
      <select id="selectAll" resultType="pojo.User">
          SELECT id, name, age, gender, phone FROM user
     </select>
 </mapper>

　　写好了之后回到mybatis-config.xml中配置一下mapper映射

　　在UserMapper中将UserMapper.xml中配置好的方法声明一下，方法名要和上面的id对应上

　　在service层写好业务逻辑代码，在接口中声明方法，在实现类中实现方法

 public class UserServiceImpl implements UserService {
      @Override
      public List<User> selectAll() throws IOException {
          //读取MyBatis的核心配置文件
          InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
          //获取SqlSessionFactoryBuilder对象
          SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
          //通过核心配置文件所对应的字节输入流创建工厂类SqlSessionFactory，生产SqlSession对象
         SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
         //获取sqlSession，此时通过SqlSession对象所操作的sql都必须手动提交或回滚事务
         SqlSession sqlSession = sqlSessionFactory.openSession();
         //通过代理模式创建UserMapper接口的代理实现类对象
         UserMapper mapper = sqlSession.getMapper(UserMapper.class);
         //调用UserMapper接口中的方法，就可以根据UserMapper的全类名匹配元素文件，通过调用的方法名匹配映射文件中的SQL标签，并执行标签中的SQL语句
         List<User> users = mapper.selectAll();
         return users;
     }
 }

　　在controller层中写好处理结果代码

public class UserController {
     private UserService userService = new UserServiceImpl();
     public void selectAll() throws IOException {
         List<User> users = userService.selectAll();
         users.forEach(System.out::println);
     }
 }

　　创建一个Test类去测试mybatis数据库连接，因为没有引入单元测试依赖，所以这里用主函数去测试

　　发现结果成功输出打印　

　　如果SQL语句比较简单，可以使用mybatis中的注解，查询语句用@Select、增加语句用@Insert、删除语句用@Delete、修改语句用@Update注解

在里面写上sql语句，再运行发现，也可以查询成功。

　　当然，复杂一点的sql语句和动态SQL建议还是使用Mapper配置，只是简单的sql语句写在注解里面可以简化，复杂的sql只会增加代码的复杂度

总结

　　在Maven项目中，使用mybatis需要先导入mybatis依赖和连接数据库的依赖，然后创建mybatis配置文件，在配置文件中配置数据源细信息，随后创建MyBatis的映射文件Mapper，在mapper文件中写好对应的语句，然后在业务层进行SqlSession连接，调用mapper中的方法，再在controller层处理返回方法。

2、用Spring框架整合Mybatis

　　同样的先创建一个Maven项目，然后在pom.xml文件中引入Spring的依赖，Mybatis的依赖，数据库连接依赖，druid连接池依赖，spring-mybatis依赖，spring-jdbc依赖。

  <dependencies>
          <dependency>
              <groupId>org.mybatis</groupId>
              <artifactId>mybatis</artifactId>
              <version>3.5.10</version>
          </dependency>
          <dependency>
              <groupId>mysql</groupId>
              <artifactId>mysql-connector-java</artifactId>
             <version>8.0.33</version>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-context</artifactId>
             <version>5.3.30</version>
         </dependency>
         <dependency>
             <groupId>com.alibaba</groupId>
             <artifactId>druid</artifactId>
             <version>1.2.20</version>
         </dependency>
         <dependency>
             <groupId>org.mybatis</groupId>
             <artifactId>mybatis-spring</artifactId>
             <version>1.3.2</version>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-jdbc</artifactId>
             <version>5.3.2</version>
         </dependency>
     </dependencies>

　　构建整体项目结构

2.1、基于XML整合Mybatis

导入Mybatis整合Spring的相关坐标
编写Mapper和Mapper.xml
配置SqlSessionFactoryBean和MapperScannerConfigurer
编写测试代码

　　和上面步骤相同，编写Mapper和Mapper.xml，一定要放在相同路径下

　　在UserMapper.xml中写我们需要的语句，并在UserMapper接口中写对应id的方法声明；

  <?xml version="1.0" encoding="UTF-8" ?>
  <!DOCTYPE mapper
          PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
         "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
  <mapper namespace="mapper.UserMapper">
      <select id="selectAll" resultType="pojo.User">
          SELECT id, name, age, gender, phone FROM user
     </select>
 </mapper>

public interface UserMapper {
    List<User> selectAll();
}

　　同样的，简单的SQL语句也可以用@Select注解编写，不需要UserMapper.xml配置　　

　　在Spring配置文件中配置SqlSessionFactoryBean

  <?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 http://www.springframework.org/schema/beans/spring-beans.xsd">
     <!--配置SqlSessionFactoryBean，作用将SqlSessionFactory存储到spring容器-->
      <bean class="org.mybatis.spring.SqlSessionFactoryBean">
          <property name="dataSource" ref="dataSource"></property>
      </bean>
     <!--配置数据源信息-->
     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
         <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
         <property name="url" value="jdbc:mysql://localhost:3307/mybatis"></property>
         <property name="username" value="root"></property>
         <property name="password" value="root"></property>
     </bean>
 </beans>

　　对应的是之前配置文件中的

  <dataSource type="POOLED">
                 <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                 <property name="url" value="jdbc:mysql://localhost:3307/mybatis"/>
                 <property name="username" value="root"/>
                 <property name="password" value="root"/>
 </dataSource>

　　在Spring配置文件中配置MapperScannerConfigurer

 <!--MapperScannerConfigurer,作用扫描指定的包，产生Mapper对象存储到Spring容器-->
     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
         <property name="basePackage" value="mapper"></property>
     </bean>

　　对应的是

 <mappers>
         <package name="com.tedu.mapper"/>
 </mappers>

　　在Spring配置文件中配置好之后，在使用的时候就不用手动创建了，直接注入即可。

　　在UserServiceImpl属性中添加UserMapper，并为其添加setter方法用于注入。

  public class UserServiceImpl implements UserService {
      private UserMapper userMapper;
      public void setUserMapper(UserMapper userMapper) {
          this.userMapper = userMapper;
      }
      @Override
      public List<User> selectAll() {
         return userMapper.selectAll();
     }
 }

　　同样，在UserController属性中添加UserService，并为其添加setter方法用于注入。在selectAll方法中处理返回的结果。

  public class UserController {
      private UserService userService;
      public void setUserService(UserService userService) {
          this.userService = userService;
      }
      public void selectAll(){
          List<User> users = userService.selectAll();
         users.forEach(System.out::println);
     }
 }

　　在Spring配置文件中配置上述UserService和UserController用于注入

 <bean id="userServiceImpl" class="service.impl.UserServiceImpl">
         <property name="userMapper" ref="userMapper"></property>
     </bean>
     <bean id="userContorller" class="controller.UserController">
         <property name="userService" ref="userServiceImpl"></property>
     </bean>

　　最后创建一个测试类进行数据库连接测试

 public class TestSelectAll {
     public static void main(String[] args) {
         ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
         UserController userController = context.getBean(UserController.class);
         userController.selectAll();
     }
     }

　　可以在控制台看到打印的结果

总结

　　基于XML方式整合Mybatis首先需要创建Spring的配置文件，在XML配置文件中去配置bean，将bean对象交由Spring容器管理，其余的mapper和普通方法一样。需要配置数据源DataSource，配置SqlSessionFactoryBean、配置MapperScannerConfigurer，再配置UserMapper、UserService和UserController。在测试类中用ClassPathXmlApplicationContext和getBean获取到UserContorller对象再调用其方法即可。这种方式不用编写mybatis-config.xml配置文件，在Spring配置文件中全部配置了，虽然简化了部分操作，但是还是较为繁琐，下面讲一种用注解方式整合mybatis。

2.2、基于注解整合Mybatis

　　导入和上述基于XML整合mybatis方法相同的依赖

　　再构建同样的项目结构

　　还需要在resources资源目录下面添加一个配置文件用于存放数据源配置信息

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.username=root
jdbc.password=root
jdbc.url=jdbc:mysql://localhost:3307/mybatis

　　除了像上面方法构建的项目结构之外，还需要一个配置类进行配置

 @Configuration
  @ComponentScan("cn.test")
 @PropertySource("classpath:jdbc.properties")
  @MapperScan("cn.test.mapper")
  public class MybatisConfig {
      @Bean
      public DataSource dataSource(
              @Value("${jdbc.driver}") String driver,
             @Value("${jdbc.username}") String username,
             @Value("${jdbc.password}") String passwrod,
             @Value("${jdbc.url}") String url
     ){
         DruidDataSource dataSource = new DruidDataSource();
         dataSource.setDriverClassName(driver);
         dataSource.setUsername(username);
         dataSource.setPassword(passwrod);
         dataSource.setUrl(url);
         return dataSource;
     }
     @Bean
     public SqlSessionFactoryBean sqlSessionFactoryBean(@Autowired DataSource dataSource){
         SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
         sqlSessionFactoryBean.setDataSource(dataSource);
         return sqlSessionFactoryBean;
     }
 }

　　@Configuration注解是声明该类是一个配置类

　　@ComponentScan注解是包扫描，扫描该包和该包的子孙包中的类带有@Component注解的类，交由Spring容器管理

　　@PropertySource注解是设置资源文件目录，classpath后是properties文件的路径，加载后可以用${}占位符获取properties文件中的属性

　　@MapperScan注解是设置Mapper文件扫描，相当于mybatis配置文件中<mapper>标签

　　配置文件中用@Bean注解配置非自定义Bean的配置，在dataSource方法中传入连接数据库四要素并且用@Value注解去注入值，其中用${}占位符获取properties文件中的属性，最后方法返回dataSource，同样的用sqlSessionFactoryBean方法sqlSessionFactoryBean，在参数中用@AutoWried注入dataSource参数，其中@AuroWired注解可省略，最后方法返回sqlSessionFactoryBean。

　　这样，在Config配置文件中就完成了SqlSessionFactoryBean和MapperScannerConfigurer的配置

　　接下来就是编写UserMapper和UserMapper.xml文件，这里就不在用XML配置文件进行演示，如需要，上面的其他方法都有演示，这里就用注解的方式编写SQL语句。

　　随后，编写三层架构的代码，在UserController中，用@AuroWired注解自动注入UserService，并且在类上加上@Controller注解，表示该类是Contriller层类并交由Spring容器管理

  @Controller
  public class UserController {
      @Autowired
      private UserService userService;
      public void findAll() {
          List<User> all = userService.findAll();
          all.forEach(System.out::println);
      }
 }

　　在UserServiceImpl中用，@AuroWired注解自动注入UserMapper，并且在类上加上@Service注解，表示该类是Service层类并交由Spring容器管理

  @Service
  public class UserServiceImpl implements UserService {
     @Autowired
      private UserMapper userMapper;
      @Override
      public List<User> findAll() {
          return userMapper.findAll();
      }
 }

　　在UserMapper中，编写SQL方法，用@Select注解编写SQL语句，因为在配置文件中加了@MapperScan("cn.test.mapper")注解，所以在此类上不需要加任何Component注解

 public interface UserMapper {
     @Select("SELECT id, name, age, gender, phone FROM user")
     List<User> findAll();
 }

　　最后，编写测试方法进行数据库连接测试

 public class TestAnnoMyBatis {
     public static void main(String[] args) {
         ApplicationContext context = new AnnotationConfigApplicationContext(MybatisConfig.class);
         UserController userController = context.getBean(UserController.class);
         userController.findAll();
     }
 }

　　在测试方法中用AnnotationConfigApplicationContext方法加载MybatisConfig配置文件，同样在控制台中可以看到成功输出结果

总结

　　基于注解整合Mybatis方法中，我们不需要配置任何XML文件，其他操作基本相同，只需要新增一个配置文件，在配置文件中用一些注解和方法去完成配置。同时，在管理Bean时，也是用注解去自动装配，交由Spring容器去管理。大大简化了配置。

3、SpringBoot整合Mybatis

　　用SpringBoot框架整合Mybatis相对就较为简单了

　　首先创建于一个SpringBoot项目

　　在勾选依赖的时候，需要勾选MyBatisFarmework依赖和MySql依赖进行数据的连接和Mybatis的使用

　　创建完成之后在application.properties配置文件中配置数据源

spring.datasource.url=jdbc:mysql://localhost:3307/mybatis?serverTimezone=Asia/Shanghai&characterEncoding=utf8
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

　　然后在UserMapper中开始写SQL语句

 @Mapper
 public interface UserMapper {
     @Select("SELECT id, name, age, gender, phone FROM user")
     List<User> userList();
 }

　　一定要在UserMapper类上加上@Mapper注解，@Mapper注解是识别他为mybatis的mapper接口，会自动的把加@Mapper 注解的接口生成动态代理类。

　　同样的，在UserService中用@AutoWired对UserMapper进行注入，并在该类上加上@Service注解

 @Service
 public class UserServiceImpl implements UserService {
     @Autowired
     private UserMapper userMapper;
     public List<User> userList(){
         return userMapper.userList();
     }
 }

　　在UserController中用@AutoWired对UserService进行注入并处理返回的结果，并在该类上加上@Controiller注解

  @Controller
  public class UserController {
      @Autowired
      private UserService userService;
      public void userList(){
          List<User> users = userService.userList();
          users.forEach(System.out::println);
      }
 }

　　最后在SpringBoot的测试类中写一个测试方法进行数据库连接的测试

 @SpringBootTest
 class SpringBootMybatisApplicationTests {
     @Autowired
     private UserController userController;
     @Test
     public void test(){
         userController.userList();
     }
 }

　　可以看到控制台成功输出结果

总结

　　使用SpringBoot框架整合Mybatis更为简单，只需要在application.properties配置文件中配置数据源四要素就行，随后就可以直接在Mapper中写SQL语句，最后可以在SpringBootTest类中直接进行测试。

到此这篇关于Mybatis和其他主流框架的整合使用的文章就介绍到这了,更多相关Mybatis框架的整合使用内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！