mybatis脱离spring怎么用

MyBatis是一个开源的Java持久层框架，可以方便地与Spring集成使用，但也可以单独脱离Spring使用。下面是详细的步骤：

第一步：导入MyBatis的相关依赖
在项目的pom.xml文件中添加MyBatis相关依赖，在这之前需要先创建一个Maven项目。以下是常用的MyBatis依赖：

<dependencies>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.2</version>
    </dependency>
    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.23</version>
    </dependency>
</dependencies>

第二步：创建MyBatis的配置文件
在项目的资源文件夹下创建一个名为mybatis-config.xml的文件，该文件用于配置MyBatis的相关属性。以下是一个简单的配置示例：

<?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"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <!-- 在这里配置Mapper映射文件 -->
    </mappers>
</configuration>

第三步：创建Mapper接口和Mapper映射文件
在项目的Java源码文件夹下创建一个Mapper接口，例如UserMapper.java，并在该接口中定义SQL语句的方法。然后，创建一个与Mapper接口同名的Mapper映射文件，例如UserMapper.xml，并在该文件中编写具体的SQL语句。以下是一个简单的示例：

UserMapper.java

public interface UserMapper {
    User getUserById(int id);
}

UserMapper.xml

<?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">
<mapper namespace="com.example.mapper.UserMapper">
    <select id="getUserById" resultType="com.example.model.User">
        SELECT * FROM user WHERE id = #{id}
    </select>
</mapper>

第四步：编写Java代码使用MyBatis
在Java代码中使用MyBatis时，需要创建一个SqlSessionFactory对象，该对象负责创建和管理SqlSession。然后，通过SqlSessionFactory对象获取一个SqlSession对象，通过该对象执行具体的SQL语句。以下是一个简单的示例：

public class MyBatisExample {
    public static void main(String[] args) {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        try (SqlSession session = sqlSessionFactory.openSession()) {
            UserMapper userMapper = session.getMapper(UserMapper.class);
            User user = userMapper.getUserById(1);
            System.out.println(user);
        }
    }
}

以上是使用MyBatis的基本步骤，通过这些步骤可以在不依赖Spring的情况下使用MyBatis进行数据库操作。当然，如果你在项目中还使用了Spring框架，可以继续进行MyBatis与Spring的集成。

要将MyBatis脱离Spring使用，您需要进行以下步骤：

1. 添加依赖：在项目的pom.xml文件中添加MyBatis的依赖项，例如：

<dependency>
   <groupId>org.mybatis</groupId>
   <artifactId>mybatis</artifactId>
   <version>3.5.6</version>
</dependency>

同时，还需要添加MyBatis的数据库驱动依赖项，例如MySQL的驱动项：

<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
   <version>8.0.21</version>
</dependency>

2. 配置MyBatis：创建MyBatis的配置文件，例如mybatis-config.xml，配置文件中需要指定数据源和映射文件等信息。例如：

<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/mydb"/>
            <property name="username" value="root"/>
            <property name="password" value="password"/>
         </dataSource>
      </environment>
   </environments>
   <mappers>
      <mapper resource="com/example/mapper/ExampleMapper.xml"/>
   </mappers>
</configuration>

这里配置了一个development环境，并指定了数据库驱动、连接URL、用户名和密码，还指定了映射文件的位置。

3. 创建Mapper接口：创建一个接口，用于定义数据库操作的方法。例如：

public interface ExampleMapper {
   List<Example> getAllExamples();
   Example getExampleById(int id);
   void insertExample(Example example);
   void updateExample(Example example);
   void deleteExample(int id);
}

4. 创建映射文件：创建一个XML文件，用于定义数据库操作的SQL语句。例如创建ExampleMapper.xml文件，配置文件中定义了与Mapper接口中方法对应的SQL语句。例如：

<mapper namespace="com.example.mapper.ExampleMapper">
   <select id="getAllExamples" resultType="com.example.model.Example">
      SELECT * FROM examples
   </select>
   <select id="getExampleById" parameterType="int" resultType="com.example.model.Example">
      SELECT * FROM examples WHERE id = #{id}
   </select>
   <insert id="insertExample" parameterType="com.example.model.Example">
      INSERT INTO examples (name, description) VALUES (#{name}, #{description})
   </insert>
   <update id="updateExample" parameterType="com.example.model.Example">
      UPDATE examples SET name = #{name}, description = #{description} WHERE id = #{id}
   </update>
   <delete id="deleteExample" parameterType="int">
      DELETE FROM examples WHERE id = #{id}
   </delete>
</mapper>

这里定义了查询所有示例、根据ID查询示例、插入示例、更新示例和删除示例的SQL语句。

5. 使用MyBatis：在应用程序中使用MyBatis进行数据库操作。首先，需要构建一个SqlSessionFactory对象，使用配置文件来配置该对象。然后，使用SqlSessionFactory对象来创建SqlSession对象，最后使用SqlSession对象执行数据库操作。例如：

InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession();

ExampleMapper exampleMapper = sqlSession.getMapper(ExampleMapper.class);
List<Example> examples = exampleMapper.getAllExamples();

for (Example example : examples) {
   System.out.println(example.getName());
}

sqlSession.close();

这里使用了SqlSessionFactoryBuilder类来构建SqlSessionFactory对象，并使用SqlSessionFactory对象创建了一个SqlSession对象。然后，通过SqlSession对象的getMapper()方法获取了ExampleMapper的实例，并使用该实例执行了数据库操作。

这样，您就可以脱离Spring使用MyBatis进行数据库操作了。

MyBatis是一种Java持久化框架，它提供了一种简单而灵活的方式来访问关系数据库。尽管它通常与Spring框架集成使用，但你也可以脱离Spring单独使用MyBatis。

下面是脱离Spring使用MyBatis的步骤和操作流程：

1. 添加MyBatis依赖：首先，在你的项目中添加MyBatis的依赖。可以通过Maven或者Gradle来导入依赖项。例如，在pom.xml文件中添加以下代码：

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.7</version>
</dependency>

2. 创建MyBatis配置文件：在src/main/resources目录下创建一个名为mybatis-config.xml的文件，用于配置MyBatis的相关设置。在该文件中，你可以配置数据库连接信息、映射文件路径等。

以下是一个简单的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/mydatabase" />
                <property name="username" value="myusername" />
                <property name="password" value="mypassword" />
            </dataSource>
        </environment>
    </environments>
    
    <mappers>
        <!-- 配置映射文件路径 -->
        <mapper resource="com/example/mapper/UserMapper.xml" />
    </mappers>
</configuration>

3. 创建映射文件：在src/main/resources目录下创建一个或多个映射文件，用于定义数据库表与Java对象之间的映射关系。例如，创建一个名为UserMapper.xml的映射文件。

以下是一个简单的UserMapper.xml示例：

<?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">
    
<mapper namespace="com.example.mapper.UserMapper">
    <!-- 定义SQL语句和映射关系 -->
    <select id="getUserById" resultType="com.example.model.User">
        SELECT * FROM users WHERE id = #{id}
    </select>
</mapper>

4. 创建数据模型类：创建一个Java类，用于表示数据库表对应的实体对象。例如，创建一个名为User的类：

public class User {
    private int id;
    private String name;
    // getter and setter methods
    // ...
}

5. 创建Mapper接口：创建一个Java接口，用于定义与数据库交互的方法。例如，创建一个名为UserMapper的接口：

public interface UserMapper {
    User getUserById(int id);
}

6. 编写代码使用MyBatis：在你的代码中，通过以下步骤使用MyBatis：

a) 创建SqlSessionFactory对象：使用MyBatis的全局配置文件mybatis-config.xml创建SqlSessionFactory对象。

InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

b) 创建SqlSession对象：使用SqlSessionFactory对象创建SqlSession对象。

SqlSession sqlSession = sqlSessionFactory.openSession();

c) 获取Mapper对象：使用SqlSession对象获取Mapper对象。

UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

d) 调用Mapper方法：通过Mapper对象调用方法执行数据库操作。

User user = userMapper.getUserById(1);

e) 关闭SqlSession：使用完SqlSession对象后，记得关闭它。

sqlSession.close();

这样，你就可以在没有Spring的情况下使用MyBatis进行数据库操作了。以上是脱离Spring使用MyBatis的基本操作流程。你可以根据实际需求进行适当调整和扩展。