MyBatis学习2之入门案例CRUD（查询）

最新推荐文章于 2024-07-18 16:32:46 发布

五毛辣条

最新推荐文章于 2024-07-18 16:32:46 发布

阅读量131

点赞数

分类专栏： MyBatis 文章标签： sql 数据库 mybatis

本文链接：https://blog.csdn.net/qq_43332008/article/details/120381410

版权

MyBatis 专栏收录该内容

21 篇文章 0 订阅

订阅专栏

工程搭建

第一步：引入jar包

<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.pp</groupId>
    <artifactId>mybatis_day1</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <!--mybatis包-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.4</version>
        </dependency>
        <!--数据库驱动包-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.44</version>
        </dependency>
        <!--测试包-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
            </resource>
        </resources>
    </build>

</project>

第二步：在资源文件下创建一个SqlMapConfig.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>
    <!-- 和spring整合后 environments配置将废除-->
    <environments default="development">
        <environment id="development">
            <!-- 使用jdbc事务管理-->
            <transactionManager type="JDBC" />
            <!-- 数据库连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8" />
                <property name="username" value="root" />
                <property name="password" value="123" />
            </dataSource>
        </environment>
    </environments>
</configuration>

SqlMapConfig.xml是mybatis核心配置文件，上边文件的配置内容为数据源、事务管理。

第三步：mapper.xml文件

mapper.xml配置文件时sql映射文件，该文件中配置了操作数据库的sql语句.此文件需要在Sql中加载。在根目录下常见com.pp包创建mapper包，然后再改包中创建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="pp">
</mapper>

除了头约束文件，这里使用了标签，namespace处填写扫描的包，这里填写的是pp

第四步：再SqlMapConfig.xml配置文件中添加UserMapper.xml,使能够加载到UserMapper配置文件。

<?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>
    ...
    <mappers>
        <mapper resource="com/pp/mapper/UserMapper.xml"/>
    </mappers>
</configuration>

这里的中 resource里面填写的是UserMapper.xml配置文件的具体路径。

第五步：在com.pp包下面创建一个pojo包，作为实体类包。然后创建一个User类。

package com.pp.pojo;

import java.util.Date;

public class User {
  /*  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(32) NOT NULL COMMENT '用户名称',
            `birthday` date DEFAULT NULL COMMENT '生日',
            `sex` char(1) DEFAULT NULL COMMENT '性别',
            `address` varchar(256) DEFAULT NULL COMMENT '地址',*/
  private Integer id;
  private String username;
  private Date   birthday;
  private String sex;
  private String address;

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", birthday=" + birthday +
                ", sex='" + sex + '\'' +
                ", address='" + address + '\'' +
                '}';
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
 
    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

第六步：在com.pp包下创建一个dao包，作为持久层

在dao层创建UserDao接口类

package com.pp.dao;

import com.pp.pojo.User;

import java.util.List;

public interface UserDao {
    User findUserByid(Integer id);
}

在dao层创建UserDaoImpl实现类继承和实现UserDao接口类的抽象方法

package com.pp.dao;

import com.pp.pojo.User;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;

import java.util.List;

public class UserDaoImpl implements UserDao{
    /*
    *
    * 1.有会话工厂
    * 2.初始化sqlseesion
    * 3.
    * */
  //新建sqlSessionFactory会话工厂
    private SqlSessionFactory sqlSessionFactory;
    //构造方法，是创建UserDaoImpl类，谁就要使用构造方法，然后把会话工厂也拿到
    public UserDaoImpl( SqlSessionFactory sqlSessionFactory){
        this.sqlSessionFactory=sqlSessionFactory;
    }
    public User findUserByid(Integer id) {
        SqlSession sqlSession = sqlSessionFactory.openSession();
      
    }

上面的步骤中，我们继承和实现了UserDao接口类的抽象方法，然后创建一个新建sqlSessionFactory会话工厂并且初始化它。在findUserByid方法里面，我们通过会话工厂去开启会话。
第七步：在com.pp下创建的mapper包中新建一个UserMapper接口

package com.pp.mapper;

import com.pp.pojo.User;

import java.util.List;

public interface UserMapper {
    User findUserByid(Integer id);
 }

引文dao层中目前只有一个方法，也就是findUserByid(Integer id)通过id去获取用户名，所以我们在 UserMapper接口类中也写了这样一个方法（ User findUserByid(Integer id);）。

第七步：在UserMapper.xml文件中写sql语句

<?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="pp">
  
     <select id="findUserByid" resultType="com.pp.pojo.User">
         select *  from user where id=#{_prams}
     </select>

</mapper>

上面的UserMapper.xml配置文件中，使用标签，id填写的是UserMapper抽象类中的方法名，resultType填写结果返回的参数类型，此处填写返回参数类型的具体路径，所以com.pp.pojo.User值得就是com.pp.pojo包下的User类。标签之间使用sql语句，这个类是通过id去查询用户，所以这里的id是一个参数，因此需要占位符，又加上我们传入的入口参数是一个Integer，所以我们使用#{_prams}。花括号里面可以随便写，通常写_prams。

第八步：继续编写UserDaoImpl未完成的部分

...
...
public class UserDaoImpl implements UserDao{
	...
    public User findUserByid(Integer id) {
        ...
        User user = (User)sqlSession.selectOne("pp.findUserByid", id);
        return user;
    }

这里对写过的内容使用省略号表示，在该部分，我们利用会话工厂去调用了selectOne()方法，其中里面第一个参数填写的就是我们刚才在第七步配置的UserMapper.xml中中的namespace为pp，然后后面的findUserByid是标签中的id，组合起来就是pp.findUserByid,由于这里需要参数，所以带的是一个参数。

第九步：在test文件下的java包里面，创建一个UserTest类作为测试类

import com.pp.dao.UserDaoImpl;
import com.pp.mapper.UserMapper;
import com.pp.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.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
import java.util.List;

public class UserTest {
    private SqlSessionFactory factory;
    @Test
    @Before
    public void Setup() throws IOException {
        String res="SqlMapConfig.xml";
        InputStream inputStream = Resources.getResourceAsStream(res);
        factory=new SqlSessionFactoryBuilder().build(inputStream);
    }
    @Test
    public void fun(){
     /*
      实例化sqlsession factory
     */
        SqlSession sqlSession = factory.openSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.findUserByid(1);
        System.out.println(user);
    }
}

这里利用 @Before@Test一起使用代表无论运行那个测试类，这个类都需要最先执行，该类的内容就是，读取SqlMapConfig.xml内容，让会话工厂去读取里面的输入流。
最后里面的run()方法中，实例化了sqlsession factory。接下来进行开启会话，在去利用会话调用getMapper()参数就是UserMapper的映射类即UserMapper.class。然后调用mapper的方法findUserByid(1)即可。

第十步：测试结果

在这里插入图片描述

扩展：

上面的测试类是通过创建会话工厂，初始化工厂，然后去将SqlMapConfig.xml配置文件交给工厂去管理，工厂去调用配置文件的id去获取到数据库的数据。

下面的方法是通过Dao层的实现类UserDaoImpl去初始化会话工厂，使用UserDaoImpl去调用类的方法。

...
...
...

public class UserTest {
    private SqlSessionFactory factory;
   
    @Test
    @Before
    public void Setup() throws IOException {
        String res="SqlMapConfig.xml";
        InputStream inputStream = Resources.getResourceAsStream(res);
        factory=new SqlSessionFactoryBuilder().build(inputStream);
    }
   ...
   @Test
    public void fun1(){
        UserDaoImpl userDao = new UserDaoImpl(factory);
        User user = userDao.findUserByid(1);
        System.out.println(user);
    }
}

UserDaoImpl实现类的内容为

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;

import java.util.List;

public class UserDaoImpl implements UserDao{
    /*
    * 1.有会话工厂
    * 2.初始化sqlseesion
    * 3.
    * */
    //新建sqlSessionFactory会话工厂
    private SqlSessionFactory sqlSessionFactory;
    //构造方法，是创建UserDaoImpl类，谁就要使用构造方法，然后把会话工厂也拿到
    public UserDaoImpl( SqlSessionFactory sqlSessionFactory){
        this.sqlSessionFactory=sqlSessionFactory;
    }
    public User findUserByid(Integer id) {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        User user = (User)sqlSession.selectOne("pp.findUserByid", id);
        return user;
    }
}

测试结果：

总结：

我们在正文中使用的测试方法：

public class UserTest {
    private SqlSessionFactory factory;
    @Test
    @Before
    public void Setup() throws IOException {
        String res="SqlMapConfig.xml";
        InputStream inputStream = Resources.getResourceAsStream(res);
        factory=new SqlSessionFactoryBuilder().build(inputStream);
    }
    @Test
    public void fun(){
     /*
      实例化sqlsession factory
     */
        SqlSession sqlSession = factory.openSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.findUserByid(16);
        System.out.println(user);
    }
}

定义会话工厂但是没有实例化，然后利用@Before去获取SqlMapConfig.xml中的内容，最后实例化了sqlsession factory去获取抽象类的UserMapper，再去调用抽象类的findUserByid()方法。然而这里SqlMapConfig.xml内容中， namespace需要指明UserMapper的具体路径，所以需要填写com.pp.mapper.UserMapper才能够正确执行。

我们在扩展中使用的测试方法

public class UserTest {
    private SqlSessionFactory factory;
    @Test
    @Before
    public void Setup() throws IOException {
        String res="SqlMapConfig.xml";
        InputStream inputStream = Resources.getResourceAsStream(res);
        factory=new SqlSessionFactoryBuilder().build(inputStream);
    }
     @Test
    public void fun1(){
        UserDaoImpl userDao = new UserDaoImpl(factory);
        User user = userDao.findUserByid(1);
        System.out.println(user);
    }

这里涉及到主要的类UserDaoImpl

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;

import java.util.List;

public class UserDaoImpl implements UserDao{
    /*
    *
    * 1.有会话工厂
    * 2.初始化sqlseesion
    * 3.
    * */

    //新建sqlSessionFactory会话工厂
    private SqlSessionFactory sqlSessionFactory;
    //构造方法，是创建UserDaoImpl类，谁就要使用构造方法，然后把会话工厂也拿到
    public UserDaoImpl( SqlSessionFactory sqlSessionFactory){
        this.sqlSessionFactory=sqlSessionFactory;
    }
    public User findUserByid(Integer id) {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        User user = (User)sqlSession.selectOne("pp.findUserByid", id);
        return user;
    }
 }

综合测试类run1()方法和UserDaoImpl实现类我们可以看到，测试类中定义会话工厂但是没有实例化，然后利用@Before去获取SqlMapConfig.xml中的内容，但是在run1()创建了UserDaoImpl并且调用该类的构造方法去带入了 sqlSessionFactory参数进行实例化，然后再去调用UserDaoImpl类中的findUserByid()方法，该方法内先开启了会话sqlSession，在去使用sqlSession的selectOne()方法，改方法内的第一个参数填写SqlMapConfig.xml中namespace中的pp，第二个参数是要查询的id。最后在测试类返回一个usr对象，打印即可。
源码地址：https://gitee.com/yangforever/project-learning.git

五毛辣条

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
MyBatis学习2之入门案例CRUD（查询）

工程搭建第一步：引入jar包<?xml version="1.0" encoding="UTF-8"?><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.ap
复制链接

扫一扫