mybatis如何整合spring

在整合MyBatis和Spring框架之前，首先要确保已经将MyBatis和Spring框架的相关依赖添加到项目中。

一、引入相关依赖
需要在项目的pom.xml（如果是maven项目）或者build.gradle（如果是gradle项目）中添加MyBatis和Spring的相关依赖。

1. Maven项目依赖配置示例：

<dependencies>
    <!-- MyBatis核心依赖 -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.7</version>
    </dependency>
    
    <!-- MyBatis与Spring整合依赖 -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.7</version>
    </dependency>

    <!-- Spring核心依赖 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.8</version>
    </dependency>
</dependencies>

2. Gradle项目依赖配置示例：

plugins {
    id 'java'
}

dependencies {
    // MyBatis核心依赖
    implementation 'org.mybatis:mybatis:3.5.7'
    
    // MyBatis与Spring整合依赖
    implementation 'org.mybatis:mybatis-spring:2.0.7'

    // Spring核心依赖
    implementation 'org.springframework:spring-context:5.3.8'
}

二、配置数据源和事务管理器
在Spring的配置文件（如applicationContext.xml）中配置数据源和事务管理器，以便MyBatis能够与数据库进行交互，并管理事务的提交或回滚。

1. 配置数据源：

<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/mybatis_demo" />
    <property name="username" value="root" />
    <property name="password" value="password" />
</bean>

2. 配置事务管理器：

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
</bean>

三、配置MyBatis的SqlSessionFactoryBean
在Spring的配置文件中，需要配置MyBatis的SqlSessionFactoryBean，以便创建SqlSessionFactory对象，用于管理数据库的会话和执行SQL语句。

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <property name="mapperLocations">
        <array>
            <value>classpath:mapper/*.xml</value>
        </array>
    </property>
</bean>

其中，mapperLocations属性指定了MyBatis映射文件（Mapper XML）所在的路径。

四、配置MapperScannerConfigurer
为了让Spring能够自动扫描并注入Mapper接口的实现，需要配置MapperScannerConfigurer。

<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.example.mapper" />
</bean>

其中，basePackage属性指定了Mapper接口所在的包路径。

五、完成配置
以上配置完成后，MyBatis与Spring框架的整合就完成了。在编写业务代码时，可以通过注入Mapper接口的实例来使用MyBatis提供的数据库访问方法。

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public User getUserById(Integer id) {
        return userMapper.getUserById(id);
    }

    @Override
    public void addUser(User user) {
        userMapper.addUser(user);
    }

    // 其他业务方法...
}

六、总结
通过以上步骤，我们就完成了MyBatis和Spring框架的整合。整合后，可以在Spring框架的环境中，方便地使用MyBatis进行数据库访问，并享受Spring框架提供的事务管理等特性。

MyBatis是一个简化数据库访问的持久层框架，而Spring是一个开发企业级Java应用的综合框架。将MyBatis与Spring整合可以更方便地管理和使用数据库连接。

下面是整合MyBatis和Spring的步骤：

1. 引入依赖：在项目的pom.xml中添加MyBatis和Spring的相关依赖。

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.3</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

2. 配置数据源：在application.properties或application.yml中配置数据源相关信息。

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

3. 创建数据源Bean：在Spring配置文件中创建数据源Bean，将数据源相关信息注入到数据源Bean中。

@Configuration
public class DataSourceConfig {

    @Value("${spring.datasource.url}")
    private String url;
    
    @Value("${spring.datasource.username}")
    private String username;
    
    @Value("${spring.datasource.password}")
    private String password;
    
    @Value("${spring.datasource.driver-class-name}")
    private String driverClassName;

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

4. 创建SqlSessionFactoryBean：在Spring配置文件中创建SqlSessionFactoryBean，将数据源Bean注入到SqlSessionFactoryBean中，并配置MyBatis的配置文件。

@Configuration
@MapperScan("com.example.mapper")
public class MyBatisConfig {

    @Autowired
    private DataSource dataSource;

    @Bean
    public SqlSessionFactoryBean sqlSessionFactory() {
        SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(dataSource);
        // 配置MyBatis的配置文件
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        sessionFactory.setConfigLocation(resolver.getResource("classpath:mybatis-config.xml"));
        return sessionFactory;
    }
}

5. 创建Mapper接口：创建Mapper接口，使用@Mapper注解将Mapper接口注册到Spring中。

@Mapper
public interface UserMapper {

    User getUserById(int id);

    void createUser(User user);

    void updateUser(User user);

    void deleteUser(int id);
}

6. 使用Mapper接口：在业务逻辑中通过@Autowired注解将Mapper接口注入到需要使用的类中，并调用Mapper接口的方法。

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

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

    @Override
    public void createUser(User user) {
        userMapper.createUser(user);
    }

    @Override
    public void updateUser(User user) {
        userMapper.updateUser(user);
    }

    @Override
    public void deleteUser(int id) {
        userMapper.deleteUser(id);
    }
}

通过以上步骤，就完成了MyBatis与Spring的整合。在业务逻辑中可以直接使用注入的Mapper接口来访问数据库。整合后，就可以更方便地使用MyBatis进行数据库操作，并且可以利用Spring的事务管理等功能。

MyBatis是一个持久化框架，而Spring是一个轻量级的应用程序框架。整合MyBatis和Spring可以从两个方面来实现：依赖注入和事务管理。下面将详细介绍如何在Spring中整合MyBatis。

1. 添加依赖项
   首先，在Maven或Gradle中添加MyBatis和Spring的依赖项。对于Maven，您可以将以下依赖项添加到您的pom.xml文件中：

<!-- MyBatis -->
<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>${mybatis.version}</version>
</dependency>

<!-- MyBatis-Spring -->
<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis-spring</artifactId>
  <version>${mybatis-spring.version}</version>
</dependency>

对于Gradle，您可以将以下依赖项添加到build.gradle文件中：

// MyBatis
implementation 'org.mybatis:mybatis:$mybatisVersion'

// MyBatis-Spring
implementation 'org.mybatis:mybatis-spring:$mybatisSpringVersion'

2. 配置数据源
   在Spring中整合MyBatis之前，您需要配置一个数据源。根据您使用的数据库类型，您可以配置一个连接池，如Apache Commons DBCP或HikariCP。

以下是一个使用HikariCP的示例配置：

<!-- DataSource -->
<bean id="dataSource" class="com.zaxxer.hikari.HikariDataSource">
  <property name="driverClassName" value="com.mysql.jdbc.Driver" />
  <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/mydatabase" />
  <property name="username" value="root" />
  <property name="password" value="password" />
</bean>

3. 配置SqlSessionFactory
   在Spring中使用MyBatis，您需要配置SqlSessionFactory来创建SqlSession。 SqlSessionFactory是MyBatis中重要的对象，它是线程安全的，因此您可以在多个线程中共享。

以下是一个示例配置：

<!-- SqlSessionFactory -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  <property name="dataSource" ref="dataSource" />
  <property name="mapperLocations" value="classpath:mapper/*.xml" />
  <property name="configLocation" value="classpath:mybatis-config.xml" />
</bean>

请注意，您需要指定mapperLocations属性来指定包含MyBatis映射器文件的位置，并且您可能需要指定configLocation属性来指定MyBatis配置文件的位置。

4. 配置MapperScannerConfigurer
   MapperScannerConfigurer是一个Spring Bean后置处理器，它可以自动扫描和注册MyBatis映射器接口。

以下是一个示例配置：

<!-- MapperScannerConfigurer -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  <property name="basePackage" value="com.example.dao" />
</bean>

在上面的示例中，我们指定了要扫描的基本包，该包中的所有接口都将被自动注册为MyBatis映射器。

5. 配置事务管理
   Spring提供了多种事务管理方式，您可以根据需要选择适合您的应用程序的方式。最常用的两种方式是基于注解的声明式事务处理和编程式事务处理。

以下是使用基于注解的声明式事务处理的示例配置：

<!-- Transaction Manager -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource" />
</bean>

<!-- Enable Transactional Annotation -->
<tx:annotation-driven transaction-manager="transactionManager" />

上述配置创建了一个DataSourceTransactionManager的实例，并启用了基于注解的声明式事务处理。您可以在需要进行事务管理的方法上使用@Transactional注解。

如果您希望使用编程式事务处理，可以使用TransactionTemplate或PlatformTransactionManager来手动管理事务。

6. 编写Mapper接口和映射器文件
   最后，您需要编写Mapper接口和映射器文件。Mapper接口定义了要执行的SQL语句，而映射器文件包含了与数据库交互的SQL语句和映射规则。

在Mapper接口中，您可以使用注解或XML配置SQL语句。以下是一个使用注解的示例：

@Mapper
public interface UserMapper {
  @Select("SELECT * FROM users WHERE id = #{id}")
  User findById(Long id);
}

在映射器文件中，您可以定义更复杂的SQL语句和映射规则。以下是一个示例：

<mapper namespace="com.example.dao.UserMapper">
  <resultMap id="BaseResultMap" type="com.example.entity.User">
    <id property="id" column="id" />
    <result property="name" column="name" />
    <!-- ... -->
  </resultMap>
  
  <select id="findById" resultMap="BaseResultMap" parameterType="java.lang.Long">
    SELECT * FROM users WHERE id = #{id}
  </select>
</mapper>

通过以上步骤，您已成功地将MyBatis整合到Spring中。您现在可以使用@Autowired注解将Mapper接口注入到Spring Bean中，并在需要时使用它们进行数据库交互。