Mybatis 框架学习5 - Mybatis中dao实现类的使用

最新推荐文章于 2020-11-02 19:40:19 发布
最新推荐文章于 2020-11-02 19:40:19 发布
阅读量393 收藏
点赞数
分类专栏： Java基础 Mybatis 框架 文章标签： Mybatis java 框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41302594/article/details/100037275
版权
框架 同时被 3 个专栏收录
36 篇文章 0 订阅
订阅专栏
Java基础
31 篇文章 0 订阅
订阅专栏
Mybatis
18 篇文章 0 订阅
订阅专栏

文章目录

Mybatis 中编写dao实现类的使用 - 了解

​ Mybatis 支持编写通过自己编写dao的实现类来实现对数据库的操作。由于在实际的开发中，使用这种方法会让程序员手动编写大量的代码，所以在实际开发中，我们一般使用自动生成代理的方式来进行数据库的操作，而不是这个方式。

1. 查询列表

  1. 创建一个 maven 项目，不使用骨架

  2. 接着，在pom.xml 文件中，写入以下依赖：

    <?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.itheima</groupId>
    <artifactId>mybatis_dao</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>

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

        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>

  3. 然后编写dao接口类：

    package com.itheima.dao;

import com.itheima.domain.User;

import java.util.List;

/**
 * 用户持久层
 */
public interface IUserDao {
    /**
     * 查询所有用户
     * @return List<User>
     */
    List<User> findAll();
}

  4. 接着，在 resources 文件夹下，创建主配置文件，并写入一下配置：

    <?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="mysql">
<!--        配置 mysql 的环境-->
        <environment id="mysql">
<!--            配置事物-->
            <transactionManager type="JDBC"></transactionManager>
<!--            配置连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/day23?serverTimezone=Asia/Shanghai"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
<!--    配置映射文件的位置-->
    <mappers>
        <mapper resource="com/itheima/dao/IUserDao.xml"></mapper>
    </mappers>
</configuration>

  5. 然后在 resources 文件夹下，创建一个和 dao 接口类包相同结构的文件夹，在文件夹下创建一个映射文件，并写入以下配置：

    <?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.itheima.dao.IUserDao">
<!--    映射的方法-->
<!--    查询所有操作-->
    <select id="findAll" resultType="com.itheima.domain.User">
        <!--select id as userId, username as userName, address as userAddress, sex as userSex, birthday as userBirthday from user; -->
        select * from user;
	</select>
</mapper>

  6. 为了在项目中可以使用 log4j，我们需要在 resources 文件夹下面创建一个 log4j.properies 文件，已提供 log4j 运行时的属性：

    # Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE            debug   info   warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE

# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE

# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=d:\axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

  7. 然后，在dao文件夹下创建一个impl文件夹，以存放 dao 接口的实现类，创建一个 java 文件，这个Java 文件就是 dao 的实现类，里面存放了如何查询列表的方法：

    package com.itheima.dao.impl;

import com.itheima.dao.IUserDao;
import com.itheima.domain.User;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;

import java.util.List;

public class UserDaoImpl implements IUserDao {

    SqlSessionFactory factory;

    public UserDaoImpl(SqlSessionFactory factory) {
        this.factory = factory;
    }

    public List<User> findAll() {
        // 1. 根据 SqlSessionFactory 获取 SqlSession 对象
        SqlSession session = factory.openSession();
        // 2. 调用 SqlSession 中的方法，来实现查询列表
        List<User> users =  session.selectList("com.itheima.dao.IUserDao.findAll");// 参数就是获取的配置信息
        // 3. 释放资源
        session.close();
        return users;
    }
}

    这里我们创建了一个 SqlSessionFactory 对象，并使用构造函数以获取传入的 SqlSessionFactory 对象。SqlSessionFactory 对象主要是用来生成 SqlSession 对象，我们再通过生成的 SqlSession 对象了，传入我们在映射文件中写入的 Sql 语句来实现对数据库的查询。

  8. 最后我们在测试类中调用该方法即可：

    package com.itheima.test;

import com.itheima.dao.IUserDao;
import com.itheima.dao.impl.UserDaoImpl;
import com.itheima.domain.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.After;
import org.junit.Before;
import org.junit.Test;

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

/**
 * 测试 Mybatis 的 CRUD 方法
 */
public class MybatisTest {

    private InputStream is;
    private IUserDao userDao;

    @Before
    public void init() throws IOException {
        // 1. 读取配置文件，生成文件字符流
        is = Resources.getResourceAsStream("SqlMapConfig.xml");
        // 2. 获取 SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
        // 3. 使用工厂创建  dao 对象
        userDao = new UserDaoImpl(factory);
    }

    @After
    public void destroy() throws IOException {
        if (is != null) {
            is.close();
        }
    }

    @Test
    public void testFindAll() {
        // 5. 执行查询方法
        List<User> users = userDao.findAll();
        for(User user : users) {
            System.out.println(user);
        }
    }
}

    在调用该方法时，我们首先需要读取主配置文件中，我们设置的数据库传入的属性值，以获取对数据库的连接，通过使用工厂，创建 dao 对象。最后执行查询。

  9. 以下是结果：

    User{idd=41, username='老王', address='北京', sex='男', birthday=Tue Feb 27 17:47:08 CST 2018}
User{idd=42, username='小二王', address='北京金燕龙', sex='女', birthday=Fri Mar 02 15:09:37 CST 2018}
User{idd=43, username='小二王', address='北京金燕龙', sex='女', birthday=Sun Mar 04 11:34:34 CST 2018}
User{idd=45, username='传智播客', address='北京金燕龙', sex='男', birthday=Sun Mar 04 12:04:06 CST 2018}
User{idd=46, username='老王', address='北京', sex='男', birthday=Wed Mar 07 17:37:26 CST 2018}
User{idd=48, username='小马宝莉', address='北京修正', sex='女', birthday=Thu Mar 08 11:44:00 CST 2018}
User{idd=51, username='mybatis update user1', address='China', sex='男', birthday=Thu Aug 22 20:45:19 CST 2019}
User{idd=54, username='mybatis save user and get id', address='China', sex='男', birthday=Thu Aug 22 18:18:44 CST 2019}

2. 保存操作

  1. 首先，在 dao 接口中创建一个保存方法：

    /**
     * 保存用户
     * @param user
     */
    void saveUser(User user);

  2. 接着，在 dao 的实现类中，我们实现保存方法：

    public void saveUser(User user) {
        // 1. 根据 SqlSessionFactory 对象获取 SqlSession 对象
        SqlSession session = factory.openSession();
        // 2. 使用 SqlSession 对象中的方法，来实现保存操作
        session.insert("com.itheima.dao.IUserDao.saveUser");
        // 3. 提交事务
        session.commit();
        // 4. 释放资源
        session.close();
        return ;
    }

    这里需要注意，执行之后，我们需要提交事务。

  3. 然后，编写测试类进行测试：

    @Test
    public void testSave() {
        User user = new User();
        user.setUsername("赵老头");
        user.setSex("男");
        user.setAddress("China");
        user.setBirthday(new Date());

        userDao.saveUser(user);
    }

  4. 然后，运行，会发现报错：

    org.apache.ibatis.exceptions.PersistenceException: 
### Error updating database.  Cause: java.sql.SQLIntegrityConstraintViolationException: Column 'username' cannot be null
### The error may exist in com/itheima/dao/IUserDao.xml
### The error may involve com.itheima.dao.IUserDao.saveUser-Inline
### The error occurred while setting parameters
### SQL: insert into user (username, address, sex, birthday) values (?, ?, ?, ?);
### Cause: java.sql.SQLIntegrityConstraintViolationException: Column 'username' cannot be null

    log 文件里显示，username 不能为空。我们分别设置了值。

    为什么会报错呢？我们来看实现类中的 session.insert()方法。通过查看源码，我们发现，insert有两个重构方法：

    session.insert(String statement);
session.insert(String statement, Object parameter);

    我们使用的是第一种，读取配置文件的 SQL 配置信息。但是我们在读取映射文件的 sql 配置信息之后，并没有将 user 对象传入，导致我们在存储的时候并没有 user 对象的存入。

    所以只需要使用第二个重构方法，再将 user 对象传入即可。

  5. 修改正确后的执行结果：

    数据库中已经有了结果：

    55 赵老头 2019-08-23 12:02:44 男 China

3. 更新用户

  1. 在 dao 接口中写入更新方法：

    /**
     * 更新用户
     * @param user
     */
    void updateUser(User user);

  2. 在 dao 实现类中实现更新方法，其实和之前的保存和查询列表方法类似：

    public void updateUser(User user) {
        // 1. 根据 SqlSessionFactory 对象获取 SqlSession 对象
        SqlSession session = factory.openSession();
        // 2. 使用 SqlSession 对象中的方法，来实现更新操作:
        session.update("com.itheima.dao.IUserDao.updateUser", user);
        // 3. 提交事务
        session.commit();
        // 4. 关闭连接
        session.close();
        return ;
    }

  3. 然后在映射配置文件中，进行一下配置：

    <!--    更新用户-->
    <update id="updateUser" parameterType="com.itheima.domain.User">
        update user set username=#{username}, address=#{address}, sex=#{sex}, birthday=#{birthday} where id=#{id};
    </update>

  4. 以下是结果：

    2019-08-23 13:06:14,478 0      [           main] DEBUG ache.ibatis.logging.LogFactory  - Logging initialized using 'class org.apache.ibatis.logging.log4j.Log4jImpl' adapter.
2019-08-23 13:06:14,507 29     [           main] DEBUG source.pooled.PooledDataSource  - PooledDataSource forcefully closed/removed all connections.
2019-08-23 13:06:14,507 29     [           main] DEBUG source.pooled.PooledDataSource  - PooledDataSource forcefully closed/removed all connections.
2019-08-23 13:06:14,507 29     [           main] DEBUG source.pooled.PooledDataSource  - PooledDataSource forcefully closed/removed all connections.
2019-08-23 13:06:14,507 29     [           main] DEBUG source.pooled.PooledDataSource  - PooledDataSource forcefully closed/removed all connections.
2019-08-23 13:06:14,575 97     [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Opening JDBC Connection
2019-08-23 13:06:15,388 910    [           main] DEBUG source.pooled.PooledDataSource  - Created connection 1313916817.
2019-08-23 13:06:15,388 910    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@4e50c791]
2019-08-23 13:06:15,392 914    [           main] DEBUG theima.dao.IUserDao.updateUser  - ==>  Preparing: update user set username=?, address=?, sex=?, birthday=? where id=?; 
2019-08-23 13:06:15,426 948    [           main] DEBUG theima.dao.IUserDao.updateUser  - ==> Parameters: 赵老太(String), China Hongkong(String), 女(String), 2019-08-23 13:06:14.567(Timestamp), 55(Integer)
2019-08-23 13:06:15,430 952    [           main] DEBUG theima.dao.IUserDao.updateUser  - <==    Updates: 1
2019-08-23 13:06:15,431 953    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Committing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@4e50c791]
2019-08-23 13:06:15,435 957    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@4e50c791]
2019-08-23 13:06:15,435 957    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@4e50c791]
2019-08-23 13:06:15,435 957    [           main] DEBUG source.pooled.PooledDataSource  - Returned connection 1313916817 to pool.

    我们发现日志中记录成功修改了数据。

  5. 数据库中的数据也得到了修改：

    55	赵老太	2019-08-23 13:06:15	女	China Hongkong

4. 删除操作

  1. 在 dao 接口中，写入删除方法：

    /**
     * 根据 id 删除用户
     * @param id
     */
    void deleteUser(Integer id);

  2. 在 dao 接口的实现类中，写入实现方法：

    public void deleteUser(Integer id) {
        // 1. 根据 SqlSessionFactory 对象获取 SqlSession 对象
        SqlSession session = factory.openSession();
        // 2. 使用 SqlSession 对象中的删除方法，来实现删除操作：
        session.delete("com.itheima.dao.IUserDao.deleteUser", id);
        // 3. 执行事务
        session.commit();
        // 4. 关闭连接
        session.close();
        return ;
    }

    依旧是调用 SqlSession 对象中的方法，这次是删除方法，传入配置文件中的 Sql 语句和需要删除的用户的 ID；

  3. 在映射文件中配置一下信息：

    <!--    删除用户-->
    <delete id="deleteUser" parameterType="java.lang.Integer">
        delete from user where id = #{id};
    </delete>

  4. 编写测试类，进行测试：

    @Test
    public void testDelet() {
        Integer id = 55;
        userDao.deleteUser(id);
    }

  5. 查看数据库，发现数据库中已经删除了 id 为 55 的那条数据。

5. 查询一个

  1. 首先，在 dao 接口中，写下查询一个方法：

    /**
     * 根据用户的 id 查找用户
     * @param id
     * @return
     */
    User findById(Integer id);

  2. 然后，在实现类中进行实现：

    public User findById(Integer id) {
        // 1. 根据 SqlSessionFactory 对象获取 SqlSession 对象
        SqlSession session = factory.openSession();
        // 2. 使用 SqlSession 对象中的查询方法来实现查询一个：
        User user = session.selectOne("com.itheima.dao.IUserDao.findById", id);
    	session.close();s
        return user;
    }

    由于实现类中是有 selectOne 这个方法，直接调用即可。

  3. 映射文件中的配置信息：

    <!--    查询一个-->
    <select id="findById" parameterType="int" resultType="com.itheima.domain.User">
        select * from user where id = #{id};
    </select>

  4. 在测试类中使用：

     @Test
    public void testFindById() {
        Integer id = 56;
        User user = userDao.findById(id);
        System.out.println(user);
    }

  5. 结果：

    2019-08-23 13:45:35,342 0      [           main] DEBUG ache.ibatis.logging.LogFactory  - Logging initialized using 'class org.apache.ibatis.logging.log4j.Log4jImpl' adapter.
2019-08-23 13:45:35,367 25     [           main] DEBUG source.pooled.PooledDataSource  - PooledDataSource forcefully closed/removed all connections.
2019-08-23 13:45:35,367 25     [           main] DEBUG source.pooled.PooledDataSource  - PooledDataSource forcefully closed/removed all connections.
2019-08-23 13:45:35,367 25     [           main] DEBUG source.pooled.PooledDataSource  - PooledDataSource forcefully closed/removed all connections.
2019-08-23 13:45:35,368 26     [           main] DEBUG source.pooled.PooledDataSource  - PooledDataSource forcefully closed/removed all connections.
2019-08-23 13:45:35,436 94     [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Opening JDBC Connection
2019-08-23 13:45:36,286 944    [           main] DEBUG source.pooled.PooledDataSource  - Created connection 868815265.
2019-08-23 13:45:36,286 944    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@33c911a1]
2019-08-23 13:45:36,290 948    [           main] DEBUG .itheima.dao.IUserDao.findById  - ==>  Preparing: select * from user where id = ?; 
2019-08-23 13:45:36,320 978    [           main] DEBUG .itheima.dao.IUserDao.findById  - ==> Parameters: 56(Integer)
2019-08-23 13:45:36,345 1003   [           main] DEBUG .itheima.dao.IUserDao.findById  - <==      Total: 1
User{idd=56, username='赵老头', address='China', sex='男', birthday=Fri Aug 23 12:58:19 CST 2019}

6. 模糊查询

  1. 在 dao 接口中写入模糊查询的方法：

    /**
     * 根据名称，模糊查询用户信息
     * @param username
     * @return
     */
    List<User> findByName(String username);

  2. 在实现类中实现该方法：

    public List<User> findByName(String username) {
        // 1. 根据 SqlSessionFactory 对象获取 SqlSession 对象
        SqlSession session = factory.openSession();
        // 2. 使用 SqlSession 对象中的查询方法来实现查询一个：
        List<User> users = session.selectList("com.itheima.dao.IUserDao.findByName", username);
    	session.close();
        return users;
    }

  3. 在映射文件中进行一下配置：

    <!--    根据名称模糊查询的语法-->
<!--    <select id="findByName" parameterType="String" resultType="com.itheima.domain.User">-->
<!--        select * from user where username like #{value};-->
<!--    </select>-->

    <select id="findByName" parameterType="String" resultType="com.itheima.domain.User">
        select * from user where username like #{username};
    </select>

  4. 在测试类进行一下测试：

    @Test
    public void findByName() {
        String username = "%王%";
        List<User> users = userDao.findByName(username);
        for(User user : users) {
            System.out.println(user);
        }
    }

  5. 结果：

    2019-08-23 13:55:59,058 0      [           main] DEBUG ache.ibatis.logging.LogFactory  - Logging initialized using 'class org.apache.ibatis.logging.log4j.Log4jImpl' adapter.
2019-08-23 13:55:59,085 27     [           main] DEBUG source.pooled.PooledDataSource  - PooledDataSource forcefully closed/removed all connections.
2019-08-23 13:55:59,085 27     [           main] DEBUG source.pooled.PooledDataSource  - PooledDataSource forcefully closed/removed all connections.
2019-08-23 13:55:59,085 27     [           main] DEBUG source.pooled.PooledDataSource  - PooledDataSource forcefully closed/removed all connections.
2019-08-23 13:55:59,085 27     [           main] DEBUG source.pooled.PooledDataSource  - PooledDataSource forcefully closed/removed all connections.
2019-08-23 13:55:59,146 88     [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Opening JDBC Connection
2019-08-23 13:55:59,945 887    [           main] DEBUG source.pooled.PooledDataSource  - Created connection 1525409936.
2019-08-23 13:55:59,945 887    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5aebe890]
2019-08-23 13:55:59,949 891    [           main] DEBUG theima.dao.IUserDao.findByName  - ==>  Preparing: select * from user where username like ?; 
2019-08-23 13:55:59,980 922    [           main] DEBUG theima.dao.IUserDao.findByName  - ==> Parameters: %王%(String)
2019-08-23 13:56:00,003 945    [           main] DEBUG theima.dao.IUserDao.findByName  - <==      Total: 4
User{idd=41, username='老王', address='北京', sex='男', birthday=Tue Feb 27 17:47:08 CST 2018}
User{idd=42, username='小二王', address='北京金燕龙', sex='女', birthday=Fri Mar 02 15:09:37 CST 2018}
User{idd=43, username='小二王', address='北京金燕龙', sex='女', birthday=Sun Mar 04 11:34:34 CST 2018}
User{idd=46, username='老王', address='北京', sex='男', birthday=Wed Mar 07 17:37:26 CST 2018}

7. 查询数据总条数

  1. 在 dao 接口中定义以下方法：

    /**
     * 查询总用户数
     * @return
     */
    int findTotal();

  2. 在实现类中实现该方法：

    public int findTotal() {
        // 1. 根据 SqlSessionFactory 对象获取 SqlSession 对象
        SqlSession session = factory.openSession();
        // 2. 使用 SqlSession 对象中的查询方法来实现查询一个：
        Integer total = session.selectOne("com.itheima.dao.IUserDao.findTotal");
        session.close();
        return total;
    }

  3. 映射文件的配置如下：

    <!--    获取用户的总记录条数-->
    <select id="findTotal" resultType="int">
        select count(id) from user;
    </select>

  4. 测试方法如下：

    @Test
    public void findAll() {
        int total = userDao.findTotal();
        System.out.println(total);
    }

  5. 结果:

    2019-08-23 14:14:07,212 0      [           main] DEBUG ache.ibatis.logging.LogFactory  - Logging initialized using 'class org.apache.ibatis.logging.log4j.Log4jImpl' adapter.
2019-08-23 14:14:07,242 30     [           main] DEBUG source.pooled.PooledDataSource  - PooledDataSource forcefully closed/removed all connections.
2019-08-23 14:14:07,242 30     [           main] DEBUG source.pooled.PooledDataSource  - PooledDataSource forcefully closed/removed all connections.
2019-08-23 14:14:07,242 30     [           main] DEBUG source.pooled.PooledDataSource  - PooledDataSource forcefully closed/removed all connections.
2019-08-23 14:14:07,242 30     [           main] DEBUG source.pooled.PooledDataSource  - PooledDataSource forcefully closed/removed all connections.
2019-08-23 14:14:07,304 92     [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Opening JDBC Connection
2019-08-23 14:14:08,208 996    [           main] DEBUG source.pooled.PooledDataSource  - Created connection 1525409936.
2019-08-23 14:14:08,208 996    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5aebe890]
2019-08-23 14:14:08,212 1000   [           main] DEBUG itheima.dao.IUserDao.findTotal  - ==>  Preparing: select count(id) from user; 
2019-08-23 14:14:08,239 1027   [           main] DEBUG itheima.dao.IUserDao.findTotal  - ==> Parameters: 
2019-08-23 14:14:08,267 1055   [           main] DEBUG itheima.dao.IUserDao.findTotal  - <==      Total: 1
2019-08-23 14:14:08,270 1058   [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5aebe890]
2019-08-23 14:14:08,270 1058   [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@5aebe890]
2019-08-23 14:14:08,270 1058   [           main] DEBUG source.pooled.PooledDataSource  - Returned connection 1525409936 to pool.
10
qq_41302594
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Mybatis中编写dao层实现类
qq_44341488的博客
07-18 1337
User的实现类 public class IUserDaoImpl implements IUserDao { private SqlSessionFactory factory; public IUserDaoImpl() { } public IUserDaoImpl(SqlSessionFactory factory) { this.fa...
Mybatis学习----原生Mybatis如何实现
成为自己的太阳的博客
05-31 692
Mybatis入门学习 1. 框架介绍 2. mybatis介绍 3. mybatis快速入门【重点】 4. 映射文件概述 5. mybatis原生的增删改查【了解】 6. 抽取工具类【spring可以代替】 7. 核心配置文件 8. 核心api概述 9. mybatis实现dao层 传统dao（接口+实现类） 接口dao（接口）【重点】 10. 基于接口增删改查 一 框架简介 为什么学习框架？ 简化代码，提高效率 二 Mybatis简介 2.1 ORM概述 ORM（obje
Mybatis编写dao的实现类
七七的博客
06-25 403
前期准备 创建数据库和表： CREATE DATABASE eesy_mybatis USE eest_mybatis DROP TABLE IF EXISTS `user`; CREATE TABLE `user` ( `id` INT(11) NOT NULL AUTO_INCREMENT, `username` VARCHAR(32) NOT NULL COMMENT '用户名称', `birthday` DATETIME DEFAULT NULL COMMENT '生日', `
JAVA日记之mybatis-2代理开发/动态sql/sql抽取/核心配置标签 ----喝最烈的酒.
thenumb的博客
07-01 161
1.Mybatis的Dao层实现 1.1 传统开发方式 1.1.1编写UserDao接口 public interface UserDao { List<User> findAll() throws IOException; } 1.1.2.编写UserDaoImpl实现 public class UserDaoImpl implements UserDao { pu...
【SSM框架入门】mybatis编写dao实现类
桥本环奈
09-13 655
mybatis编写dao实现类的过程较繁琐，在实际开发中没有意义。此文章仅作为mybatis知识的扩展，并以此了解mybatis通过代理dao定位sql语句的过程，即通过mapper配置文件中namespace和id属性定位sql语句 工程结构目录 在【SSM框架入门】mybatis环境搭建的基础上，新建一个IUserDao的实现类UserDaoImpl package com.ssm.dao.impl; import com.ssm.dao.IUserDao; import com.ssm.doma
Mybatis中使用dao实现类的执行过程分析
...
04-04 506
在Mybatis实现CRUD（基于dao实现类）的基础上，我们设置断点并进行观察。 运行调试时，我们可以看出这里session是DefaultSqlSession对象： 我们进入DefaultSqlSession类进一步分析： 可以看出我们最终调用的selectList函数是第三个，我们继续打断点： 通过调试我们可以看出这里Executor的实现类是CachingExecutor，接着进...
java8源码-simple-ibatis:手写mybatis框架---思路变成实践
06-04
手写mybatis框架---思路变成实践 项目简介： simple-batis是自己编写的一个简单ORM框架。在学习mybatis源码时，有感而发。耗时3周左右，基本满足了一些常用的Sql操作本项目所涉及的代码都是个人所写，没有一句copy，...
Mybatis 框架学习10 - Mybatis中的事务原理和自动提交设置
qq_41302594的博客
08-30 1200
文章目录Mybatis中的事务原理和自动提交设置1. Mybatis 中的事务1.1 什么是事务：1.2 事务的四大特性1.3 不考虑隔离性可能会产生的三个问题1.4 Mybatis 中的事务原理1.5 Mybatis 事务的自动提交 Mybatis中的事务原理和自动提交设置 1. Mybatis 中的事务 1.1 什么是事务： 事务是数据库操作的最小工作单元，是作为单个逻辑工作单元执行的一系列...
Spring+SpringMVC+Mybatis框架整合例子(SSM) 下载
07-21
Spring、SpringMVC和Mybatis是Java开发中最常用的三大开源框架，它们的整合使用，通常被称为SSM框架。这个框架组合提供了完整的后端服务解决方案，包括依赖注入（DI）、面向切面编程（AOP）、模型-视图-控制器（MVC...
Mybatis-kuang--master.zip
11-29
通过Mybatis的Mapper SPI机制，可以在运行时动态生成实现类。 4. **SqlSession**：这是Mybatis的会话对象，负责执行SQL并获取结果。执行增删改查操作后，需要调用commit()或rollback()进行提交或回滚。 5. **...
springboot，mybatis，springboot-mybatis环境，手动写dao实现类，非自动扫描
04-03
springboot，mybatis，springboot-mybatis环境，手动写dao实现类，非自动扫描 springboot环境，mybatis springboot mybatis 自动生成dao实现类的： https://download.csdn.net/download/nowsdt/11085245
Mybatis编写dao接口实现类
weixin_43157935的博客
03-11 693
使用 Mybatis 开发 Dao，通常有两个方法，即原始 Dao开发方式和 Mapper 接口代理开发方式。而现在主流 的开发方式是接口代理开发方式，这种方式总体上更加简便。现在给大家介绍一下基于传统编写 Dao 实现类的开发方式。 dao接口： package ypy.dao; import ypy.domain.User; import java.util.List; public...
Mybatis（二）— DAO实现类图解
Mr_OO的博客
10-08 464
（下列图解都偏大，需要放大仔细查看） 传统DAO层开发图解 析编写dao实现类Mybatis的执行过程 分析代理dao的执行过程 Statement 和 PreparedStatement 区别： 自定义mybatis开发流程图 ...
Mybatis框架回顾（dao实现类和注解分别实现简单案例）
但行好事 无问西东
12-07 406
Mybatis框架回顾 在上篇博客中讲解了搭建Mybatis环境的几点注意事项，因为遵守3、4、5点，所以直接使用dao接口的代理对象来对数据库执行操作，我们直接通过xml配置文件配置即可，不需要再创建dao接口的实现类，其实使用实现类也可以完成，接下来就演示通过dao接口的实现类来完成对数据库的操作 既然使用实现类来完成对数据库的操作，那么就不需要使用代理对象来执行相应的方法了， 这是现在的目...
Mybatis中使用Dao实现类实现增删改查【实际开发中使用代理dao】
JSON_ZJS的博客
10-15 378
在Mybatis开发中，使用到的是代理Dao的方式实现增删改查，这样就不需要在写Dao的实现类 但是Mybatis也支持写Dao实现类！即DaoImpl 直接上DaoImpl，之前的代码可以参考前面几篇文章。 DaoImpl类 package com.itheima.dao.impl; import com.itheima.dao.IUserDao; import com.itheima.dom...
（3）Mybatis————分析dao实现类的执行过程，代理dao的执行过程，常用的标签以及查询语句
qq_2533491534的博客
06-30 615
1， Mybatis的dao实现类的执行过程 1.1，保存操作并获取主键 id 1.2，更新操作 Mybatis的dao实现类的执行过程
mybatis(四)_原始dao开发方法（dao接口和dao实现类）
limts的博客
12-09 273
前言：SqlSession使用范围： SqlSessionFactoryBuilder：工具类 SqlSessionFactory：单例模式 SqlSession： 线程不安全：在SqlSesion实现类中除了有操作数据库的方法，还有数据域属性 最佳应用场合：方法，定义成局部变量 一、原始dao开发方法（dao接口和dao实现类） dao接口： dao实现类： 测试代码： 问题总结： 1....
Mybatis（9）Dao实现类和无实现类的执行过程
xiaobumi123的博客
11-02 148
findAll方法执行为例 1.执行findAll方法，DefaultSqlSession类 2. CachingExecutor类 3.BaseExecutor类 4.SimpleExecutor类 5.RoutingStatementHandle类 6.PreparedStatementHandle类 7.关于PreparedStatement对象方法的介绍 使用execute方法的好处？ 通过判断结果集是否为true后，再通过preparedStatem.
mybatis原始dao开发改进（dao接口和dao实现类）
jimgreatly的博客
04-25 335
思路程序员需要写dao接口和dao实现类。 需要向dao实现类中注入SqlSessionFactory，在方法体内通过SqlSessionFactory创建SqlSession。dao接口编写import java.util.List; /** * * <p>Title: UserDao</p> * <p>Description: dao接口，用户管理</p> */ public int
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值