最详细的MyBatis构建，极其细腻教学。建议入门操作

最新推荐文章于 2024-08-15 14:47:41 发布

菜汪在路上

最新推荐文章于 2024-08-15 14:47:41 发布

阅读量429

点赞数 1

分类专栏： mybatis 文章标签： mybatis java spring

本文链接：https://blog.csdn.net/qx020814/article/details/127358928

版权

mybatis 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

本人配置：

idea2022

jdk1.8

mysql56

mybatis3.5.7

首先解决我遇见的第一个大坑，利用maven构建项目。

maven的作用是帮助我们就行导入jar包，因为项目一旦过大后，很多jar包的名字都会重复，比如org、MAIN、APP等等。所以就使用maven就行辅助导包。

首先安装maven：

链接：https://pan.baidu.com/s/18egp0AypGot6TFgEKSPwAA
提取码：ydhl

下载好后我们进行安装：

我安装的地址是盘，因为在maven进行导包的时候，会去下载jar包，有的包比较哒，放在c盘就容易沾满c盘。不建议这么做、

创建一个个人本地jar包的仓库，我的仓库文件名就叫：mvn_repo自己知道在哪里就行。

然后点开idea，进行创建项目：

点成这样就好了，进入idea后我们还要配置maven的下载jar包的地址，现在这个地址是去国外下载，非常慢！！

我们先配置一下我们自己的maven路径，因为idea自带一个maven，我们还是用自己的比较好，知道自己的jar包都放在哪里的，万一以后换电脑，可以直接把东西复制走：

在这：

要勾选后面的框框噢

还有就是maven的jar包下载路径配置文件在这个文件夹下面：

叫这玩意：

settings.xml

仓库地址就是我们自己创建的哪个文件地址，maven会自动去settings.xml配置的地址下载需要的jar包。

接下载就是配置我们自己的下载地址:打开settings.xml文件：

注意，这里面只需要改两个地方就好，若是懒得搞，直接复制我的，改一下自己本地仓库地址就好了。

<?xml version="1.0" encoding="UTF-8"?>

<!--
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License.  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
-->

<!--
 | This is the configuration file for Maven. It can be specified at two levels:
 |
 |  1. User Level. This settings.xml file provides configuration for a single user,
 |                 and is normally provided in ${user.home}/.m2/settings.xml.
 |
 |                 NOTE: This location can be overridden with the CLI option:
 |
 |                 -s /path/to/user/settings.xml
 |
 |  2. Global Level. This settings.xml file provides configuration for all Maven
 |                 users on a machine (assuming they're all using the same Maven
 |                 installation). It's normally provided in
 |                 ${maven.conf}/settings.xml.
 |
 |                 NOTE: This location can be overridden with the CLI option:
 |
 |                 -gs /path/to/global/settings.xml
 |
 | The sections in this sample file are intended to give you a running start at
 | getting the most out of your Maven installation. Where appropriate, the default
 | values (values used when the setting is not specified) are provided.
 |
 |-->
<settings xmlns="http://maven.apache.org/SETTINGS/1.2.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.2.0 https://maven.apache.org/xsd/settings-1.2.0.xsd">
  <!-- localRepository
   | The path to the local repository maven will use to store artifacts.
   |
   | Default: ${user.home}/.m2/repository
  <localRepository>/path/to/local/repo</localRepository>
  -->
  <localRepository>D:\maven\apache-maven-3.8.6\mvn_repo</localRepository>

  <!-- interactiveMode
   | This will determine whether maven prompts you when it needs input. If set to false,
   | maven will use a sensible default value, perhaps based on some other setting, for
   | the parameter in question.
   |
   | Default: true
  <interactiveMode>true</interactiveMode>
  -->

  <!-- offline
   | Determines whether maven should attempt to connect to the network when executing a build.
   | This will have an effect on artifact downloads, artifact deployment, and others.
   |
   | Default: false
  <offline>false</offline>
  -->

  <!-- pluginGroups
   | This is a list of additional group identifiers that will be searched when resolving plugins by their prefix, i.e.
   | when invoking a command line like "mvn prefix:goal". Maven will automatically add the group identifiers
   | "org.apache.maven.plugins" and "org.codehaus.mojo" if these are not already contained in the list.
   |-->
  <pluginGroups>
    <!-- pluginGroup
     | Specifies a further group identifier to use for plugin lookup.
    <pluginGroup>com.your.plugins</pluginGroup>
    -->
  </pluginGroups>

  <!-- proxies
   | This is a list of proxies which can be used on this machine to connect to the network.
   | Unless otherwise specified (by system property or command-line switch), the first proxy
   | specification in this list marked as active will be used.
   |-->
  <proxies>
    <!-- proxy
     | Specification for one proxy, to be used in connecting to the network.
     |
    <proxy>
      <id>optional</id>
      <active>true</active>
      <protocol>http</protocol>
      <username>proxyuser</username>
      <password>proxypass</password>
      <host>proxy.host.net</host>
      <port>80</port>
      <nonProxyHosts>local.net|some.host.com</nonProxyHosts>
    </proxy>
    -->
  </proxies>

  <!-- servers
   | This is a list of authentication profiles, keyed by the server-id used within the system.
   | Authentication profiles can be used whenever maven must make a connection to a remote server.
   |-->
  <servers>
    <!-- server
     | Specifies the authentication information to use when connecting to a particular server, identified by
     | a unique name within the system (referred to by the 'id' attribute below).
     |
     | NOTE: You should either specify username/password OR privateKey/passphrase, since these pairings are
     |       used together.
     |
    <server>
      <id>deploymentRepo</id>
      <username>repouser</username>
      <password>repopwd</password>
    </server>
    -->

    <!-- Another sample, using keys to authenticate.
    <server>
      <id>siteServer</id>
      <privateKey>/path/to/private/key</privateKey>
      <passphrase>optional; leave empty if not used.</passphrase>
    </server>
    -->
  </servers>

  <!-- mirrors
   | This is a list of mirrors to be used in downloading artifacts from remote repositories.
   |
   | It works like this: a POM may declare a repository to use in resolving certain artifacts.
   | However, this repository may have problems with heavy traffic at times, so people have mirrored
   | it to several places.
   |
   | That repository definition will have a unique id, so we can create a mirror reference for that
   | repository, to be used as an alternate download site. The mirror site will be the preferred
   | server for that repository.
   |-->
   <mirrors>
  <mirror> 
  
		<id>nexus-aliyun</id> 
		<mirrorOf>central</mirrorOf> 
		<name>Nexus aliyun</name> 
		<url>http://maven.aliyun.com/nexus/content/groups/public</url> 
</mirror>
	 
    <mirror>
      <id>maven-default-http-blocker</id>
      <mirrorOf>external:http:*</mirrorOf>
      <name>Pseudo repository to mirror external repositories initially using HTTP.</name>
      <url>http://0.0.0.0/</url>
      <blocked>true</blocked>
    </mirror>
  </mirrors>

  <!-- profiles
   | This is a list of profiles which can be activated in a variety of ways, and which can modify
   | the build process. Profiles provided in the settings.xml are intended to provide local machine-
   | specific paths and repository locations which allow the build to work in the local environment.
   |
   | For example, if you have an integration testing plugin - like cactus - that needs to know where
   | your Tomcat instance is installed, you can provide a variable here such that the variable is
   | dereferenced during the build process to configure the cactus plugin.
   |
   | As noted above, profiles can be activated in a variety of ways. One way - the activeProfiles
   | section of this document (settings.xml) - will be discussed later. Another way essentially
   | relies on the detection of a system property, either matching a particular value for the property,
   | or merely testing its existence. Profiles can also be activated by JDK version prefix, where a
   | value of '1.4' might activate a profile when the build is executed on a JDK version of '1.4.2_07'.
   | Finally, the list of active profiles can be specified directly from the command line.
   |
   | NOTE: For profiles defined in the settings.xml, you are restricted to specifying only artifact
   |       repositories, plugin repositories, and free-form properties to be used as configuration
   |       variables for plugins in the POM.
   |
   |-->
  <profiles>
    <!-- profile
     | Specifies a set of introductions to the build process, to be activated using one or more of the
     | mechanisms described above. For inheritance purposes, and to activate profiles via <activatedProfiles/>
     | or the command line, profiles have to have an ID that is unique.
     |
     | An encouraged best practice for profile identification is to use a consistent naming convention
     | for profiles, such as 'env-dev', 'env-test', 'env-production', 'user-jdcasey', 'user-brett', etc.
     | This will make it more intuitive to understand what the set of introduced profiles is attempting
     | to accomplish, particularly when you only have a list of profile id's for debug.
     |
     | This profile example uses the JDK version to trigger activation, and provides a JDK-specific repo.
    <profile>
      <id>jdk-1.4</id>

      <activation>
        <jdk>1.4</jdk>
      </activation>

      <repositories>
        <repository>
          <id>jdk14</id>
          <name>Repository for JDK 1.4 builds</name>
          <url>http://www.myhost.com/maven/jdk14</url>
          <layout>default</layout>
          <snapshotPolicy>always</snapshotPolicy>
        </repository>
      </repositories>
    </profile>
    -->

    <!--
     | Here is another profile, activated by the system property 'target-env' with a value of 'dev',
     | which provides a specific path to the Tomcat instance. To use this, your plugin configuration
     | might hypothetically look like:
     |
     | ...
     | <plugin>
     |   <groupId>org.myco.myplugins</groupId>
     |   <artifactId>myplugin</artifactId>
     |
     |   <configuration>
     |     <tomcatLocation>${tomcatPath}</tomcatLocation>
     |   </configuration>
     | </plugin>
     | ...
     |
     | NOTE: If you just wanted to inject this configuration whenever someone set 'target-env' to
     |       anything, you could just leave off the <value/> inside the activation-property.
     |
    <profile>
      <id>env-dev</id>

      <activation>
        <property>
          <name>target-env</name>
          <value>dev</value>
        </property>
      </activation>

      <properties>
        <tomcatPath>/path/to/tomcat/instance</tomcatPath>
      </properties>
    </profile>
    -->
	<profile> 
		<id>jdk-1.8</id> 
		<activation> 
			<activeByDefault>true</activeByDefault> 
			<jdk>1.8</jdk> 
		</activation> 
		<properties> 
			<maven.compiler.source>1.8</maven.compiler.source> 
			<maven.compiler.target>1.8</maven.compiler.target> 
			<maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion> 
		</properties> 
</profile>
  </profiles>

  <!-- activeProfiles
   | List of profiles that are active for all builds.
   |
  <activeProfiles>
    <activeProfile>alwaysActiveProfile</activeProfile>
    <activeProfile>anotherAlwaysActiveProfile</activeProfile>
  </activeProfiles>
  -->
</settings>

第一个地方就是把下载地址改为阿里云的镜像仓库，因为它在国内，所以下载东西快很多。

第二个就是更改下载到本地仓库的地址。

然后配置maven的环境变量：

(39条消息) 配置maven环境变量_Godfiry的博客-CSDN博客_maven环境变量配置

这里我就不多阐述，直接访问就好了。

现在开始我们的idea配置，点开创建项目一起创建的pom.xml

然后现在很重要：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>mybatis</groupId>
    <artifactId>myBatis_dom1</artifactId>
    <packaging>war</packaging>
    <version>1.0</version>
    <name>myBatis_dom1 Maven Webapp</name>
    <url>http://maven.apache.org</url>
    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.4</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>RELEASE</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <finalName>myBatis_dom1</finalName>
    </build>
</project>

我们来细讲一下这个配置文件，很重要！一定不要手打，直接复制过去就好了，改一下版本号就行。

1：

这个是mybatis的配置，意思是让maven知道我要下载哪个jar包、已经版本号

2：

这个是方便我们进行测试代码的，稍后就行讲解和下载junit4.0的插件。

3：

这个是mysql，意识同1.

然后我们点击这个按钮，让maven去下载ar包：

然后下面就有几个进度条，当然，下载比较快，要是你没注意，它就已经下好了。点开这里就能看见，已经下载好的jar包：

然后我们下载上面说的junit测试代码的插件，因为在打代码的时候，我们不可能每次都去搞一个main方法吧？？？太难看了，这里就有一个比较好的jar包插件：

下载这个插件，然后重启idea：

现在我们就写一个查询代码，用一下mybatis：

自己弄一个数据库，加几条数据，然后看我操作：

1：创建实体类pojo

2：写查询接口

3：写查询配置文件UserMapper.xml

4：写配置文件：mybatis-config.xml

因为mybatis是直接用xml使用，不再需要实现接口。

1：

2：

这里查询可以不写接口里的方法，mybatis会自动弄一个，我就写了一个空接口，因为mybatis必须压迫一个接口。

3：

使用idea连接mysql数据库，打开表，然后编写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">

<!-- namespace ：对应的mapper接口 -->
<mapper namespace="com.quxiao.pojo.User">
    <!--
        id : 对应接口的方法名称.
    -->
    <select id="selectAll" resultType="com.quxiao.pojo.User">
        select * from bus.user
    </select>
</mapper>

4：

<?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>
    <!--
        配置链接数据库的环境
        default : 选择那个环境有效
     -->
    <environments default="development">
        <environment id="development">

            <!-- 事务管理器 -->
            <transactionManager type="JDBC">
                <property name="" value=""/>
            </transactionManager>

            <!-- 数据源 即连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/bus"/>
                <property name="username" value="root"/>
                <property name="password" value="qx@123456"/>
            </dataSource>
        </environment>
    </environments>

    <!-- 引入 MyBatis 的映射文件 : 存放SQL语句 和 POJO的映射方式 -->
    <mappers>
        <mapper resource="mappers/UserMapper.xml"></mapper>
    </mappers>
</configuration>

注意引入文件时，不要弄错位置，你自己创建的位置肯定不和我的一样，仔细查看一下。

接下来我们写一个测试类玩玩：

我们不需要知道它到底什么意思，我们一定要先把查询输出来后，再去看每个代码的意识，：

这里一定要注意，我们使用@Test的时候，需要导入包，这里我放入我的代码：

package Test;

import com.quxiao.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.BeforeClass;
import org.junit.Test;

import java.io.IOException;
import java.io.Reader;
import java.util.List;

import static org.junit.Assert.*;

public class MybatisSelectAll {
    private static SqlSessionFactory sqlSessionFactory;

    @BeforeClass
    public static void init() {
        try {
            Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
            reader.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    @Test
    public void testSelectAll() {
        SqlSession session = sqlSessionFactory.openSession();
        try {
            List<User> userList = session.selectList("selectAll");
            userList.stream()
                    .forEach(x -> System.out.println(x));
        } finally {
            session.close();
        }
    }

}

具体代码到底什么意识，就交给大家去琢磨，因为我也没搞懂。我也是半小时前才写出测试代码，踩了不少坑才写出来。

goodbye~~

菜汪在路上

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
最详细的MyBatis构建，极其细腻教学。建议入门操作

maven的作用是帮助我们就行导入jar包，因为项目一旦过大后，很多jar包的名字都会重复，比如org、MAIN、APP等等。然后我们下载上面说的junit测试代码的插件，因为在打代码的时候，我们不可能每次都去搞一个main方法吧？我安装的地址是盘，因为在maven进行导包的时候，会去下载jar包，有的包比较哒，放在c盘就容易沾满c盘。点成这样就好了，进入idea后我们还要配置maven的下载jar包的地址，现在这个地址是去国外下载，非常慢！一定不要手打，直接复制过去就好了，改一下版本号就行。
复制链接

扫一扫

专栏目录