Mybatis的学习

最新推荐文章于 2022-07-27 18:04:03 发布
最新推荐文章于 2022-07-27 18:04:03 发布
阅读量203 收藏
点赞数
分类专栏： 仅供学习 文章标签： mybatis mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44175845/article/details/115176976
版权

Mybatis的学习

1.简介

1.1、什么是Mybatis

  • MyBatis 是一款优秀的持久层框架。
  • 它支持自定义 SQL、存储过程以及高级映射。
  • MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。
  • MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

1.2、如何获取Mybatis？

  • maven

    <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.5</version>
</dependency>

  • Github : https://github.com/mybatis/mybatis-3/releases

  • 中文文档: https://mybatis.org/mybatis-3/zh/index.html

1.3、什么是持久层?

数据持久化

  • 持久化是将程序数据在持久状态和瞬时状态间转换的机制。通俗的讲，就是瞬时数据（比如内存中的数据，是不能永久保存的）持久化为持久数据（比如持久化至数据库中，能够长久保存）。
  • 内存：断电即失

为什么需要持久化？

  • 有一些对象，不能让他丢掉
  • 内存太贵

1.4、持久层

Dao层，Service层，Controller层

  • 完成持久化工作的代码块
  • 层界限十分明显

1.5、为什么需要Mybatis？

  • 帮程序员将数据存入数据库
  • 方便、简化、框架、自动化
  • 传统的JDBC代码复杂
  • 特点：来自百科
    • 简单易学：本身就很小且简单。没有任何第三方依赖，最简单安装只要两个jar文件+配置几个sql映射文件易于学习，易于使用，通过文档和源代码，可以比较完全的掌握它的设计思路和实现。
    • 灵活：mybatis不会对应用程序或者数据库的现有设计强加任何影响。 sql写在xml里，便于统一管理和优化。通过sql语句可以满足操作数据库的所有需求。
    • 解除sql与程序代码的耦合：通过提供DAO层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试。sql和代码的分离，提高了可维护性。
    • 提供映射标签，支持对象与数据库的orm字段关系映射
    • 提供对象关系映射标签，支持对象关系组建维护
    • 提供xml标签，支持编写动态sql。

2、第一个Mybatis程序

2.1、搭建环境

搭建数据库

//navicat风格
create DATABASE mybatis;

use mybatis;
create table user (
id int(20) not null PRIMARY KEY,
name VARCHAR(30) DEFAULT NULL,
psw VARCHAR(30) DEFAULT NULL
)ENGINE=INNODB DEFAULT CHARSET=utf8;

insert into user(id,name,psw) VALUES
(1,'fmxu','123456'),
(2,'xiaobai','123456'),
(3,'xfm','123')

创建一个项目，导入maven依赖

<?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>fmxu</groupId>
    <artifactId>Mybatis-study</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>mybatis-01</module>
    </modules>

    <!--导入依赖-->
    <dependencies>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

2.2、创建一个模块

创建一个名为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/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf-8&amp;serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册-->
    <mappers>
        <mapper resource="dao/UserMapper.xml"/>
    </mappers>
</configuration>

编写mybatis工具类

package utils;

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 java.io.IOException;
import java.io.InputStream;

/**
 * @author Dell
 * @projectName Mybatis-study
 * @description: mybatis工具类
 * @date 2021/3/22/18:18
 */
//sqlSessionFactory---->sqlSession
public class MybatisUtils {

    private static SqlSessionFactory sqlSessionFactory;
    static{
        try{
            //使用mybatis第一步：获取sqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例。
    // SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
}

2.3、编写代码

  • 实体类

    package pojo;

/**
 * @author Dell
 * @projectName Mybatis-study
 * @description:
 * @date 2021/3/22/18:33
 */
public class User {
    private int id;
    private String name;
    private String psw;

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPsw() {
        return psw;
    }

    public void setPsw(String psw) {
        this.psw = psw;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", psw='" + psw + '\'' +
                '}';
    }
}

  • Dao接口

    package dao;

import pojo.User;

import java.util.List;

/**
 * @author Dell
 * @projectName Mybatis-study
 * @description: userDao接口
 * @date 2021/3/22/18:34
 */
public interface UserDao {
    List<User> getUserList();
}

  • 接口实现类由原来的UserDaoImpl转换为一个Mapper配置文件

    <?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==绑定一个对应的Dao/Mapper接口-->
<mapper namespace="dao.UserDao">
    <select id="getUserList" resultType="pojo.User">
    select * from mybatis.user;
  </select>
</mapper>

  • 它在命名空间 “dao.UserDao” 中定义了一个名为 “getUserList” 的映射语句，这样你就可以用全限定名 “dao.UserDao.getUserList” 来调用映射语句了.

    List<User> blogList = (User) session.selectOne("dao.UserDao.getUserList");

  • 你可能会注意到，这种方式和用全限定名调用 Java 对象的方法类似。这样，该命名就可以直接映射到在命名空间中同名的映射器类，并将已映射的 select 语句匹配到对应名称、参数和返回类型的方法。

    UserDao userDao = sqlSession.getMapper(UserDao.class);
List<User> userList=userDao.getUserList();

2.4、测试

出错 ：java.lang.ExceptionInInitializerError 原因为资源别过滤掉了

解决方案 在pom.xml文件下添加一下代码

<!--在build中配置resources，来防止我们资源导出失败的问题-->
<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.xml</include>
                <include>**/*.properties</include>
            </includes>
            <filtering>true</filtering>
        </resource>
    </resources>
</build>

测试方法

import dao.UserDao;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import pojo.User;
import utils.MybatisUtils;

import javax.swing.*;
import java.util.List;

/**
 * @author Dell
 * @projectName Mybatis-study
 * @description:
 * @date 2021/3/22/18:47
 */
public class UserTest {
    @Test
    public void test(){
        //获取SqlSession对象
        SqlSession sqlSession= MybatisUtils.getSqlSession();
        //执行SQL
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        List<User> userList=userDao.getUserList();
        for (User user:userList){
            System.out.println(user);
        }
        sqlSession.close();
    }
}

2.5、作用域（Scope）和生命周期

  • SqlSessionFactoryBuilder

    这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就不再需要它了。 因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）。 你可以重用 SqlSessionFactoryBuilder 来创建多个 SqlSessionFactory 实例，但最好还是不要一直保留着它，以保证所有的 XML 解析资源可以被释放给更重要的事情。

  • SqlSessionFactory

    SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。 使用 SqlSessionFactory 的最佳实践是在应用运行期间不要重复创建多次，多次重建 SqlSessionFactory 被视为一种代码“坏习惯”。因此 SqlSessionFactory 的最佳作用域是应用作用域。 有很多方法可以做到，最简单的就是使用单例模式或者静态单例模式。

  • SqlSession

    每个线程都应该有它自己的 SqlSession 实例。SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。 绝对不能将 SqlSession 实例的引用放在一个类的静态域，甚至一个类的实例变量也不行。 也绝不能将 SqlSession 实例的引用放在任何类型的托管作用域中，比如 Servlet 框架中的 HttpSession。 如果你现在正在使用一种 Web 框架，考虑将 SqlSession 放在一个和 HTTP 请求相似的作用域中。 换句话说，每次收到 HTTP 请求，就可以打开一个 SqlSession，返回一个响应后，就关闭它。 这个关闭操作很重要，为了确保每次都能执行关闭操作，你应该把这个关闭操作放到 finally 块中。

3、CRUD

1、select

  1. 编写接口

    //查询所有用户
List<User> getUserList();

//根据id查询用户
User getUserById(int id);

  2. 编写对应mapper中的sql语句

    <select id="getUserList" resultType="pojo.User">
    select * from mybatis.user
</select>

<select id="getUserById" parameterType="int" resultType="pojo.User">
    select * from mybatis.user where id = #{id}
</select>

  3. 测试

    @Test
public void test(){
    //获取SqlSession对象
    SqlSession sqlSession= MybatisUtils.getSqlSession();
    //执行SQL
    UserDao userDao = sqlSession.getMapper(UserDao.class);
    List<User> userList=userDao.getUserList();
    for (User user:userList){
        System.out.println(user);
    }
    sqlSession.close();
}

@Test
public void getUserById(){
    //获取SqlSession对象
    SqlSession sqlSession= MybatisUtils.getSqlSession();
    //执行SQL
    UserDao userDao = sqlSession.getMapper(UserDao.class);
    User user = userDao.getUserById(1);
    System.out.println(user);
    sqlSession.close();
}

2、insert

  1. 编写接口

    //插入用户
void addUser(User user);

  2. 编写对应mapper中的sql语句

    <!--对象中属性可以直接取出来-->
<select id="addUser" parameterType="pojo.User">
    insert into mybatis.user (id,name,psw) values(#{id},#{name},#{psw})
</select>

  3. 测试

    @Test
public void addUser(){
    //获取SqlSession对象
    SqlSession sqlSession= MybatisUtils.getSqlSession();
    //执行SQL
    UserDao userDao = sqlSession.getMapper(UserDao.class);
    userDao.addUser(new User(4,"小黄","123"));
    sqlSession.commit();
    sqlSession.close();
}

3、update

  1. 编写接口

    //修改用户
void updateUser(User user);

  2. 编写对应mapper中的sql语句

    <select id="updateUser" parameterType="pojo.User">
    update mybatis.user set name=#{name},psw=#{psw} where id=#{id}
</select>

  3. 测试

    @Test
public void updateUser(){
    //获取SqlSession对象
    SqlSession sqlSession= MybatisUtils.getSqlSession();
    //执行SQL
    UserDao userDao = sqlSession.getMapper(UserDao.class);
    userDao.updateUser(new User(4,"小李","1234"));
    sqlSession.commit();
    sqlSession.close();
}

4、delete

  1. 编写接口

    //根据id删除用户
void deleteUser(int id);

  2. 编写对应mapper中的sql语句

    <select id="deleteUser" parameterType="int">
    delete from mybatis.user where id=#{id}
</select>

  3. 测试

    @Test
public void deleteUser(){
//获取SqlSession对象
SqlSession sqlSession= MybatisUtils.getSqlSession();
//执行SQL
UserDao userDao = sqlSession.getMapper(UserDao.class);
userDao.deleteUser(4);
sqlSession.commit();
sqlSession.close();
}

    增删改需要提交事务

4、配置解析

1、核心配置文件

  • mybatis-config.xml

  • MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。

    configuration（配置）
properties（属性）
settings（设置）
typeAliases（类型别名）
typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）
environments（环境配置）
environment（环境变量）
transactionManager（事务管理器）
dataSource（数据源）
databaseIdProvider（数据库厂商标识）
mappers（映射器）

2、环境配置（environments）

​ MyBatis 可以配置成适应多种环境，不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。

3、属性（properties）

这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性(比如创建db.properties文件)优先使用，也可以在 properties 元素的子元素中设置。

外部文件：

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf-8&amp;serverTimezone=UTC
username=root
password=123456

properties元素的子元素：

<properties resource="org/mybatis/example/config.properties">
    <property name="username" value="dev_user"/>
    <property name="password" value="F2Fa3!33TYyg"/>
</properties>

设置好的属性可以在整个配置文件中用来替换需要动态配置的属性值。比如:

<dataSource type="POOLED">
  <property name="driver" value="${driver}"/>
  <property name="url" value="${url}"/>
  <property name="username" value="${username}"/>
  <property name="password" value="${password}"/>
</dataSource>

4、类型别名（typeAliases）

类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置，意在降低冗余的全限定类名书写。例如：

<typeAliases>
  <typeAlias alias="Author" type="domain.blog.Author"/>
  <typeAlias alias="Blog" type="domain.blog.Blog"/>
  <typeAlias alias="Comment" type="domain.blog.Comment"/>
  <typeAlias alias="Post" type="domain.blog.Post"/>
  <typeAlias alias="Section" type="domain.blog.Section"/>
  <typeAlias alias="Tag" type="domain.blog.Tag"/>
</typeAliases>

也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean，比如：

会使用 Bean 的首字母小写的非限定类名来作为它的别名(意思是会自动将指定包下的所有类用其首字母小写的类名作为别名)

<typeAliases>
  <package name="domain.blog"/>
</typeAliases>

5、设置

这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。 下表描述了设置中各项设置的含义、默认值等。

设置名描述有效值默认值
cacheEnabled全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。true | falsetrue
lazyLoadingEnabled延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。true | falsefalse
aggressiveLazyLoading开启时，任一方法的调用都会加载该对象的所有延迟加载属性。 否则，每个延迟加载属性会按需加载（参考 lazyLoadTriggerMethods)。true | falsefalse （在 3.4.1 及之前的版本中默认为 true）
multipleResultSetsEnabled是否允许单个语句返回多结果集（需要数据库驱动支持）。true | falsetrue
useColumnLabel使用列标签代替列名。实际表现依赖于数据库驱动，具体可参考数据库驱动的相关文档，或通过对比测试来观察。true | falsetrue
useGeneratedKeys允许 JDBC 支持自动生成主键，需要数据库驱动支持。如果设置为 true，将强制使用自动生成主键。尽管一些数据库驱动不支持此特性，但仍可正常工作（如 Derby）。true | falseFalse
autoMappingBehavior指定 MyBatis 应如何自动映射列到字段或属性。 NONE 表示关闭自动映射；PARTIAL 只会自动映射没有定义嵌套结果映射的字段。 FULL 会自动映射任何复杂的结果集（无论是否嵌套）。NONE, PARTIAL, FULLPARTIAL
autoMappingUnknownColumnBehavior指定发现自动映射目标未知列（或未知属性类型）的行为。NONE: 不做任何反应WARNING: 输出警告日志（'org.apache.ibatis.session.AutoMappingUnknownColumnBehavior' 的日志等级必须设置为 WARN）FAILING: 映射失败 (抛出 SqlSessionException)NONE, WARNING, FAILINGNONE
defaultExecutorType配置默认的执行器。SIMPLE 就是普通的执行器；REUSE 执行器会重用预处理语句（PreparedStatement）； BATCH 执行器不仅重用语句还会执行批量更新。SIMPLE REUSE BATCHSIMPLE
defaultStatementTimeout设置超时时间，它决定数据库驱动等待数据库响应的秒数。任意正整数未设置 (null)
defaultFetchSize为驱动的结果集获取数量（fetchSize）设置一个建议值。此参数只可以在查询设置中被覆盖。任意正整数未设置 (null)
defaultResultSetType指定语句默认的滚动策略。（新增于 3.5.2）FORWARD_ONLY | SCROLL_SENSITIVE | SCROLL_INSENSITIVE | DEFAULT（等同于未设置）未设置 (null)
safeRowBoundsEnabled是否允许在嵌套语句中使用分页（RowBounds）。如果允许使用则设置为 false。true | falseFalse
safeResultHandlerEnabled是否允许在嵌套语句中使用结果处理器（ResultHandler）。如果允许使用则设置为 false。true | falseTrue
mapUnderscoreToCamelCase是否开启驼峰命名自动映射，即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 aColumn。true | falseFalse
localCacheScopeMyBatis 利用本地缓存机制（Local Cache）防止循环引用和加速重复的嵌套查询。 默认值为 SESSION，会缓存一个会话中执行的所有查询。 若设置值为 STATEMENT，本地缓存将仅用于执行语句，对相同 SqlSession 的不同查询将不会进行缓存。SESSION | STATEMENTSESSION
jdbcTypeForNull当没有为参数指定特定的 JDBC 类型时，空值的默认 JDBC 类型。 某些数据库驱动需要指定列的 JDBC 类型，多数情况直接用一般类型即可，比如 NULL、VARCHAR 或 OTHER。JdbcType 常量，常用值：NULL、VARCHAR 或 OTHER。OTHER
lazyLoadTriggerMethods指定对象的哪些方法触发一次延迟加载。用逗号分隔的方法列表。equals,clone,hashCode,toString
defaultScriptingLanguage指定动态 SQL 生成使用的默认脚本语言。一个类型别名或全限定类名。org.apache.ibatis.scripting.xmltags.XMLLanguageDriver
defaultEnumTypeHandler指定 Enum 使用的默认 TypeHandler 。（新增于 3.4.5）一个类型别名或全限定类名。org.apache.ibatis.type.EnumTypeHandler
callSettersOnNulls指定当结果集中值为 null 的时候是否调用映射对象的 setter（map 对象时为 put）方法，这在依赖于 Map.keySet() 或 null 值进行初始化时比较有用。注意基本类型（int、boolean 等）是不能设置成 null 的。true | falsefalse
returnInstanceForEmptyRow当返回行的所有列都是空时，MyBatis默认返回 null。 当开启这个设置时，MyBatis会返回一个空实例。 请注意，它也适用于嵌套的结果集（如集合或关联）。（新增于 3.4.2）true | falsefalse
logPrefix指定 MyBatis 增加到日志名称的前缀。任何字符串未设置
logImpl指定 MyBatis 所用日志的具体实现，未指定时将自动查找。SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING未设置
proxyFactory指定 Mybatis 创建可延迟加载对象所用到的代理工具。CGLIB | JAVASSISTJAVASSIST （MyBatis 3.3 以上）
vfsImpl指定 VFS 的实现自定义 VFS 的实现的类全限定名，以逗号分隔。未设置
useActualParamName允许使用方法签名中的名称作为语句参数名称。 为了使用该特性，你的项目必须采用 Java 8 编译，并且加上 -parameters 选项。（新增于 3.4.1）true | falsetrue
configurationFactory指定一个提供 Configuration 实例的类。 这个被返回的 Configuration 实例用来加载被反序列化对象的延迟加载属性值。 这个类必须包含一个签名为static Configuration getConfiguration() 的方法。（新增于 3.2.3）一个类型别名或完全限定类名。未设置
shrinkWhitespacesInSql从SQL中删除多余的空格字符。请注意，这也会影响SQL中的文字字符串。 (新增于 3.5.5)true | falsefalse
defaultSqlProviderTypeSpecifies an sql provider class that holds provider method (Since 3.5.6). This class apply to the type(or value) attribute on sql provider annotation(e.g. @SelectProvider), when these attribute was omitted.A type alias or fully qualified class nameNot set

一个配置完整的 settings 元素的示例如下：

<settings>
  <setting name="cacheEnabled" value="true"/>
  <setting name="lazyLoadingEnabled" value="true"/>
  <setting name="multipleResultSetsEnabled" value="true"/>
  <setting name="useColumnLabel" value="true"/>
  <setting name="useGeneratedKeys" value="false"/>
  <setting name="autoMappingBehavior" value="PARTIAL"/>
  <setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>
  <setting name="defaultExecutorType" value="SIMPLE"/>
  <setting name="defaultStatementTimeout" value="25"/>
  <setting name="defaultFetchSize" value="100"/>
  <setting name="safeRowBoundsEnabled" value="false"/>
  <setting name="mapUnderscoreToCamelCase" value="false"/>
  <setting name="localCacheScope" value="SESSION"/>
  <setting name="jdbcTypeForNull" value="OTHER"/>
  <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
</settings>

6、映射器（mappers）

首先，我们需要告诉 MyBatis 到哪里去找到这些语句。 在自动查找资源方面，Java 并没有提供一个很好的解决方案，所以最好的办法是直接告诉 MyBatis 到哪里去找映射文件。 你可以使用相对于类路径的资源引用，或完全限定资源定位符（包括 file:/// 形式的 URL），或类名和包名等。例如：

<!-- 使用相对于类路径的资源引用 -->
<mappers>
  <mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
  <mapper resource="org/mybatis/builder/BlogMapper.xml"/>
  <mapper resource="org/mybatis/builder/PostMapper.xml"/>
</mappers>

<!-- 使用完全限定资源定位符（URL） -->
<mappers>
  <mapper url="file:///var/mappers/AuthorMapper.xml"/>
  <mapper url="file:///var/mappers/BlogMapper.xml"/>
  <mapper url="file:///var/mappers/PostMapper.xml"/>
</mappers>

<!-- 使用映射器接口实现类的完全限定类名 -->
<mappers>
  <mapper class="org.mybatis.builder.AuthorMapper"/>
  <mapper class="org.mybatis.builder.BlogMapper"/>
  <mapper class="org.mybatis.builder.PostMapper"/>
</mappers>

<!-- 将包内的映射器接口实现全部注册为映射器 -->
<mappers>
  <package name="org.mybatis.builder"/>
</mappers>

5、解决属性名和字段名不一致问题

1、问题

user实体类的属性名和数据库中user表的字段名不一致

private int id;
private String name;
private String password; //数据库中的是psw

解决办法：

使用别名

<select id="getUserById" resultType="pojo.User">
	select id,name,psw as password form mybatis.user where id=#{id}
</select>

2、resultMap

结果集映射

<!--结果集映射-->
<resultMap id="userMap" type="User">
	<!--column数据库中的字段，property实体类中的属性-->
    <reslut column="id" property="id"></reslut>
    <reslut column="name" property="name"></reslut>
    <reslut column="psw" property="password"></reslut>
</resultMap>
<select id="getUserById" resultMap="userMap">
	select id,name,psw form mybatis.user where id=#{id}
</select>

resultMap 元素是 MyBatis 中最重要最强大的元素。ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。

6、日志

6.1、日志工厂

根据操作数据库时输出的日志，可以更容易找出问题所在

曾经：sout，debug

  • SLF4J
  • LOG4J 掌握
  • LOG4J2
  • JDK_LOGGING
  • COMMONS_LOGGING
  • STDOUT_LOGGING 标准日志输出 掌握
  • NO_LOGGING

6.2、Log4j

什么是Log4j?

  • Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件。
  • 我们也可以控制每一条日志的输出格式。
  • 通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。
  • 通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

  1. 导入Log4j

    <!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

  2. Log4j.properties

    ### 设置###
log4j.rootLogger = debug,stdout,D,E

### 输出信息到控制抬 ###
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = [%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n

### 输出DEBUG 级别以上的日志到=E://logs/error.log ###
log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File = E://logs/log.log
log4j.appender.D.Append = true
log4j.appender.D.Threshold = DEBUG 
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n

### 输出ERROR 级别以上的日志到=E://logs/error.log ###
log4j.appender.E = org.apache.log4j.DailyRollingFileAppender
log4j.appender.E.File =E://logs/error.log 
log4j.appender.E.Append = true
log4j.appender.E.Threshold = ERROR 
log4j.appender.E.layout = org.apache.log4j.PatternLayout
log4j.appender.E.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n

  3. 配置log4j为日志的实现

    <settings>
	<setting name="logImpl" value=""></setting>
</settings>

简单实用

  1. 在要使用Log4j的类中，导入包import org.apache.log4j.Logger;

  2. 日志对象，参数为当前类的class

    static Logger logger=Logger.getLogger(UserDaoTest.class);

7、分页

思考：为什么要分页？

​ 减少数据的处理量

使用Mybatis实现分页，核心sql

  1. 接口

    //分页查询用户
List<User> getUserByLimit(Map<String,Integer>map);

  2. Mapper.xml

    <select id="getUserByLimit" parameterType="map" resultType="pojo.User">
    select * from mybatis.user limit #{startIndex},#{pageSize}
</select>

  3. 测试

    @Test
public void getUserByLimit(){
    //获取SqlSession对象
    SqlSession sqlSession= MybatisUtils.getSqlSession();
    //执行SQL
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    HashMap<String, Integer> map = new HashMap<>();
    map.put("startIndex",0);
    map.put("pageSize",2);
    List<User> userList=userMapper.getUserByLimit(map);
    for (User user :userList){
        System.out.println(user);
    }
    sqlSession.commit();
    sqlSession.close();
}

8、使用注解开发

  1. 接口

    //查询所有用户
@Select("Select * from mybatis.user")
List<User> getUserList();

  2. 核心文件mybatis-config.xml中的配置

    <!--绑定接口-->
<mappers>
    <mapper class="dao.UserMapper"></mapper>
</mappers>

  3. 测试

    @Test
public void test(){
    //获取SqlSession对象
    SqlSession sqlSession= MybatisUtils.getSqlSession();
    //执行SQL
    UserMapper userDao = sqlSession.getMapper(UserMapper.class);
    List<User> userList=userDao.getUserList();
    for (User user:userList){
        System.out.println(user);
    }
    sqlSession.close();
}

    本质：反射机制

    底层：动态代理

CRUD

  • select

    //根据id查询用户
@Select("select * from mybatis.user where id=#{id}")
User getUserById(@Param("id") int id);

  • insert

    //插入用户
@Insert("insert into mybatis.user (id,name,psw) values(#{id},#{name},#{psw})")
void addUser(User user);

  • update

    //修改用户
@Update("update user set name=#{name},psw=#{psw} where id=#{id}")
void updateUser(User user);

  • delete

    //根据id删除用户
@Delete("delete from user where id=#{id}")
void deleteUser(@Param("id") int id);

9、多对一

  1. 创建表 SQL语句如下：

    CREATE TABLE teacher(
id	int(10) NOT NULL,
name	VARCHAR(30) DEFAULT NULL,
PRIMARY KEY (id)
)ENGINE=INNODB DEFAULT CHARSET=utf8

INSERT INTO teacher(id,name) VALUES(1,'徐老师');

CREATE TABLE student(
id int(10)	NOT NULL,
name	VARCHAR(30) DEFAULT NULL,
tid	int(10)	DEFAULT NULL,
PRIMARY KEY (id),
KEY fktid (tid),
CONSTRAINT fktid FOREIGN KEY (tid) REFERENCES teacher (id)
)ENGINE=INNODB DEFAULT CHARSET=utf8


INSERT INTO student(id,name,tid) VALUES(1,'小明',1);
INSERT INTO student(id,name,tid) VALUES(2,'小红',1);
INSERT INTO student(id,name,tid) VALUES(3,'小白',1);
INSERT INTO student(id,name,tid) VALUES(4,'小李',1);
INSERT INTO student(id,name,tid) VALUES(5,'小黄',1);

  2. 创建实体类

    • student实体类

      package pojo;

/**
 * @author Dell
 * @projectName Mybatis-study
 * @description:
 * @date 2021/3/23/16:40
 */
public class Student {

    private int id;
    private String name;
    //学生需要关联一个老师
    private Teacher teacher;

    public Student() {
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", teacher=" + teacher +
                '}';
    }
}

    • teacher实体类

      package pojo;

/**
 * @author Dell
 * @projectName Mybatis-study
 * @description:
 * @date 2021/3/23/16:41
 */
public class Teacher {

    private int id;
    private String name;

    public Teacher() {
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

  3. 创建mapper接口

    • StudentMapper接口

      //查询所有的学生信息以及相应的老师信息
List<Student> listStudent();

    • TeacherMapper接口

      package dao;

import org.apache.ibatis.annotations.Select;
import pojo.Teacher;

/**
 * @author Dell
 * @projectName Mybatis-study
 * @description:
 * @date 2021/3/23/16:43
 */
public interface TeacherMapper {

    @Select("select * from teacher")
    Teacher getTeacher();
}

  4. 创建StudentMapper.xml

    <mapper namespace="dao.StudentMapper">

    <select id="listStudent" resultMap="StudentTeacher">
        select * from student
    </select>
    <resultMap id="StudentTeacher" type="pojo.Student">
        <result column="id" property="id"/>
        <result column="name" property="name"/>
        <!--复杂的属性，我们需要单独处理-->
        <association property="teacher" column="tid" javaType="pojo.Teacher" select="getTeacher"/>
    </resultMap>
    <select id="getTeacher" resultType="pojo.Teacher">
        select * from teacher where id=#{id}
    </select>

    <!--方式二-->
    <select id="listStudent2" resultMap="StudentTeacher2">
        select s.id sid,s.name sname,t.name tname
        from student s,teacher t
        where s.tid=t.id;
    </select>
    <resultMap id="StudentTeacher2" type="pojo.Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <association property="teacher" javaType="pojo.Teacher">
            <result property="name" column="tname"/>
        </association>
        
    </resultMap>
</mapper>

  5. 测试

    @Test
public void test(){
    //获取SqlSession对象
    SqlSession sqlSession= MybatisUtils.getSqlSession();
    //执行SQL
    TeacherMapper teacherMapper = sqlSession.getMapper(TeacherMapper.class);
    Teacher teacher =teacherMapper.getTeacher(1);
    System.out.println(teacher);
    sqlSession.close();
}

@Test
public void listStudent(){
    //获取SqlSession对象
    SqlSession sqlSession= MybatisUtils.getSqlSession();
    //执行SQL
    StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
    List<Student> studentList=studentMapper.listStudent();
    for (Student student:studentList){
        System.out.println(student);
    }

    sqlSession.close();
}

@Test
public void listStudent2(){
    //获取SqlSession对象
    SqlSession sqlSession= MybatisUtils.getSqlSession();
    //执行SQL
    StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
    List<Student> studentList=studentMapper.listStudent2();
    for (Student student:studentList){
        System.out.println(student);
    }

    sqlSession.close();
}

10、一对多

  1. 创建实体类

    • Student类

      private int id;
private String name;
private int tid;

    • Teacher类

      private int id;
private String name;
private List<Student> students;

  2. 创建mapper接口

    Teacher getTeacher(@Param("tid")int id);

  3. 创建TeacherMapper.xml

    <mapper namespace="dao.TeacherMapper">
    <select id="getTeacher" resultMap="TeacherStudent">
        select s.id sid,s.name sname,t.name tname,t.id tid
        from teacher t,student s
        where s.tid=t.id and t.id=#{tid}

    </select>
     <resultMap id="TeacherStudent" type="pojo.Teacher">
         <result property="id" column="tid"/>
         <result property="name" column="tname"/>
         <collection property="students" ofType="pojo.Student">
             <result property="id" column="sid"/>
             <result property="name" column="sname"/>
             <result property="tid" column="tid"></result>
         </collection>
     </resultMap>
</mapper>

  4. 测试

    @Test
public void test(){
    //获取SqlSession对象
    SqlSession sqlSession= MybatisUtils.getSqlSession();
    //执行SQL
    TeacherMapper teacherMapper = sqlSession.getMapper(TeacherMapper.class);
    Teacher teacher =teacherMapper.getTeacher(1);
    sqlSession.close();
}

小结

  1. 关联-association [多对一]
  2. 集合-collection [一对多]
  3. javaType || ofType
    • javaType 用来指定实体类中属性的类型
    • ofType 用来指定映射到List或者集合中的pojo类型，泛型中的约束类型

11、动态SQL

什么是动态SQL：动态SQL就是根据不同的条件生成不同的SQL语句

在 MyBatis 之前的版本中，需要花时间了解大量的元素。借助功能强大的基于 OGNL 的表达式，MyBatis 3 替换了之前的大部分元素，大大精简了元素种类，现在要学习的元素种类比原来的一半还要少。

if
choose (when, otherwise)
trim (where, set)
foreach

  • If

    <select id="findActiveBlogWithTitleLike" resultType="Blog">
    SELECT * FROM BLOG
    WHERE state = ‘ACTIVE’
    <if test="title != null">
        AND title like #{title}
    </if>
</select>

    这条语句提供了可选的查找文本功能。如果不传入 “title”，那么所有处于 “ACTIVE” 状态的 BLOG 都会返回；如果传入了 “title” 参数，那么就会对 “title” 一列进行模糊查找并返回对应的 BLOG 结果（细心的读者可能会发现，“title” 的参数值需要包含查找掩码或通配符字符）。

    如果希望通过 “title” 和 “author” 两个参数进行可选搜索该怎么办呢？首先，我想先将语句名称修改成更名副其实的名称；接下来，只需要加入另一个条件即可。

    <select id="findActiveBlogLike" resultType="Blog">
    SELECT * FROM BLOG WHERE state = ‘ACTIVE’
    <if test="title != null">
        AND title like #{title}
    </if>
    <if test="author != null and author.name != null">
        AND author_name like #{author.name}
    </if>
</select>

  • choose (when, otherwise)

    有时候，我们不想使用所有的条件，而只是想从多个条件中选择一个使用。针对这种情况，MyBatis 提供了 choose 元素，它有点像 Java 中的 switch 语句。

    还是上面的例子，但是策略变为：传入了 “title” 就按 “title” 查找，传入了 “author” 就按 “author” 查找的情形。若两者都没有传入，就返回标记为 featured 的 BLOG（这可能是管理员认为，与其返回大量的无意义随机 Blog，还不如返回一些由管理员精选的 Blog）。

    <select id="findActiveBlogLike"  resultType="Blog">
    SELECT * FROM BLOG WHERE state = ‘ACTIVE’
    <choose>
        <when test="title != null">
            AND title like #{title}
        </when>
        <when test="author != null and author.name != null">
            AND author_name like #{author.name}
        </when>
        <otherwise>
            AND featured = 1
        </otherwise>
    </choose>
</select>

  • trim (where, set)

    回到之前的 “if” 示例，这次我们将 “state = ‘ACTIVE’” 设置成动态条件，看看会发生什么。

    <select id="findActiveBlogLike" resultType="Blog">
  SELECT * FROM BLOG
  WHERE
  <if test="state != null">
    state = #{state}
  </if>
  <if test="title != null">
    AND title like #{title}
  </if>
  <if test="author != null and author.name != null">
    AND author_name like #{author.name}
  </if>
</select>

    如果没有匹配的条件会怎么样？最终这条 SQL 会变成这样：

    SELECT * FROM BLOG
WHERE

    这会导致查询失败。如果匹配的只是第二个条件又会怎样？这条 SQL 会是这样:

    SELECT * FROM BLOG
WHERE
AND title like ‘someTitle’

    MyBatis 有一个简单且适合大多数场景的解决办法。而在其他场景中，可以对其进行自定义以符合需求。而这，只需要一处简单的改动：

    <select id="findActiveBlogLike" resultType="Blog">
    SELECT * FROM BLOG
    <where>
        <if test="state != null">
            state = #{state}
        </if>
        <if test="title != null">
            AND title like #{title}
        </if>
        <if test="author != null and author.name != null">
            AND author_name like #{author.name}
        </if>
    </where>
</select>

    where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且，若子句的开头为 “AND” 或 “OR”，where 元素也会将它们去除。

  • SQL片段

    使用sql标签，将复用的sql片段插入，使用时使用include标签在需要处引入

  • foreach

    动态 SQL 的另一个常见使用场景是对集合进行遍历（尤其是在构建 IN 条件语句的时候）。比如：

    <select id="selectPostIn" resultType="domain.blog.Post">
    SELECT *
    FROM POST P
    WHERE ID in
    <foreach item="item" index="index" collection="list" open="(" separator="," close=")">
        #{item}
    </foreach>
</select>

12、缓存

12.1、简介

  1. 什么是缓存？
    • 存在内存中的临时数据。
    • 将用户查询的数据放在缓存中，用户去查询数据就不用从磁盘上查询，从缓存中查询从而提高效率，解决了高并发系统的性能问题。
  2. 为什么使用缓存？
    • 减少数据库的交互次数，减小系统开销，提高系统效率。
  3. 什么样的数据可以使用缓存？
    • 经常查询并且不经常改变的数据。可以使用缓存。

12.2、Mybatis缓存

  • Mybatis包含一个非常强大的查询缓存特性，它可以很方便地定制和配置缓存。缓存可以极大的提升查询效率。
  • Mybatis系统中默认定义了两级缓存：一级缓存和二级缓存
    • 默认情况下，只有一级缓存开启。（SqlSession级别的缓存，也称为本地缓存）
    • 二级缓存需要手动开启和设置，它是基于namespace级别的缓存。
    • 为了提高扩展性，Mybatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存

12.3、一级缓存

  • 一级缓存也叫本地缓存
    • 与数据库同一次会话期间查询到的数据会放到本地缓存中。
    • 以后如果需要获取相同的数据，直接从缓存中拿，不必要再去查询数据库。

12.4、二级缓存

  • 二级缓存也叫全局缓存，一级缓存的作用域太低了，所以诞生了二级缓存。
  • 基于namespace级别的缓存，一个名称空间，对应于一个二级缓存。
  • 工作机制：
    • 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中；
    • 如果当前会话关闭了，这个会话对应的一级缓存就没有了；但是我们想要的是，会话关闭了，一级缓存中的数据被保存在二级缓存中。
    • 新的会话查询信息，就可以从二级缓存中获取内容；
    • 不同的mapper查出的数据会放在自己对应的缓存（map）中。
姓徐名凤明
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MyBatis入门案例
m0_70648941的博客
03-11 327
前者是从应用方面而后者是从目的方面给出的定义，简而言之，框架其实就是某种应用的半成品，就是一组组件，供你选用完成你自己的系统。框架要解决的最重要的一个问题是技术整合的问题，在]2EE的 框架中，有着各种各样的技术，不同的软件企业需要从J2EE 中选择不同的技术，这就使得软件企业最终的应用依赖于这些技术，技术自身的复杂性和技术的风险性将会直接对应用造成冲击。这样，软件企业的研发将集中在应用的设计上，而不是具体的技术实现，技术实现是应用的底层支撑，它不应该直接对应用产生影响。
九、生命周期和作用域
有人的地方，就是江湖
11-30 234
狂神说Java：https://www.bilibili.com/video/BV1NE411Q7Nx 不同作用域和生命周期类别是至关重要的，因为错误的使用会导致非常严重的并发问题。 1、SqlSessionFactoryBuilder 这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就不再需要它了。 因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）。 你可以重用 SqlSessionFactoryBuilder.
MyBatis入门示例
t1137471535的专栏
05-07 261
原创作品，允许转载，转载时请务必以超链接形式标明文章 原始出处 、作者信息和本声明。否则将追究法律责任。http://wanqiufeng.blog.51cto.com/409430/515132  说明： 1，本文采用的Mybatis框架版本为： mybatis-3.0.4.jar 2， 以持久化一个简单的User bean为例 User实体类的代码如下： package
Mybatis07缓存
weixin_42367504的博客
04-15 158
缓存 简介 什么是缓存 存在内存中的临时数据 将用户经常查询的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上（关系型数据库数据文件）查询，从缓存中查询，提高查询效率，解决了高并发系统的性能问题 为什么使用缓存 减少和数据库的交互次数，减少系统开销。提高系统效率 什么样的数据能使用缓存 经常查询并且不经常改变的数据 ...
MyBatis——入门示例
feng_zhiyu的博客
11-14 339
前言 此文章只是mybatis的一个入门实例，之前自己也写过一个完整【大致内容都涵盖】的后台（SSH），但是使用hibernate过程中由于数据库设计部分联系太多，而hibernate相对mybatis操作起来不灵活，所以想试试mybatis。 （个人想法，有高见的大佬可以留言指教，谢谢！） 项目目录结构 分层结构解析： controller层：控制层【此项目没有用到，后面SSM或SS...
mybatis学习
06-13
MyBatis 是一款优秀的...通过深入学习 MyBatis，你可以有效地将业务逻辑与数据访问层分离，提高代码的可维护性和可读性。同时，MyBatis 的灵活性和强大的功能使其成为 Java 开发者在处理 SQL 操作时的首选框架之一。
Mybatis学习资料
最新发布
12-18
这个“Mybatis学习资料”压缩包包含了一系列资源，旨在帮助初学者和有经验的开发者更深入地理解和掌握Mybatis框架。 首先，我们来看《Mybatis中文版指南》。这份文档详细解释了Mybatis的基本概念、安装步骤、配置...
mybatis学习使用
07-31
MyBatis学习使用 MyBatis是一个持久层的框架，封装了JDBC功能，支持定制化SQL，屏蔽所有JDBC代码，使 用XML和注解配置，数据库映射到JAVA对象。MyBatis可以复杂定制，效率略低于Hibernate。 MyBatis的特点： 1. ...
mybatis学习资料
03-12
本压缩包包含了关于Mybatis学习的多个资源，帮助你深入理解和掌握这个框架。 1. **Mybatis 学习 PDF**：这份PDF文档可能是Mybatis的官方教程或者某位专家编写的指南，涵盖了Mybatis的基础概念、配置、映射文件、...
Mybatis学习笔记
07-22
本学习笔记是作者在大学期间深入学习Mybatis后的整理，旨在帮助初学者快速入门并掌握其核心概念与功能。 笔记共分为11个章节，涵盖Mybatis的基础到高级应用，以下是主要知识点的详细讲解： 1. **Mybatis简介**：...
Mybatis入门示例
Youngholl2016的博客
08-03 1363
近期刚入职公司，从学生时代往工程师转变，有很多技术细节不得不注意了，不再是学生时代了解大概就可以。最近看公司项目，发现很多技术、框架都需要重新梳理总结学习，把每天的内容碎片整理到印象笔记，隔三差五整理成博客，给自己总结复习之用，也向业内自学者贡献一点自己的力量，毕竟我也是这么过来的，如果没有前人通过博客等无私传播知识，那我们该如何自学呢？这便是我在这里开博客的初衷~~ 很多东西不够完善，加上写作
轻量级半自动框架-MyBatis入门案例
xlecho的博客
04-07 521
xl_echo编辑整理，欢迎转载，转载请声明文章来源。更多IT、编程案例请联系QQ：1280023003 百战不败，依不自称常胜，百败不颓，依能奋力前行。——这才是真正的堪称强大！！！ MyBatis架构图 MyBatis入门程序 mybatis下载 mybaits的代码由github.com管理，地址：https://github.com/mybatis/mybatis-...
Mybatis入门案例详细演示
m0_56819050的博客
11-10 674
MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。mybatis是一个优秀的基于java的持久层框架，设计目的就是让我们对执行SQL语句时对输入输出的数据管理更加方便。 1.首先在数据库中创建自己所需要的表并添加数据 CREATE TABLE `user` (`id` INT(20) NOT NULL PRIMARY KEY,`name` VARCHAR(30) DEFAULT NULL,`pwd` VARCHAR(30) DEFAULT NULL)ENGINE=IN
Mybatis入门实例过程记录
qq_33917303的博客
03-05 659
Mybatis的入门案例：开发工具:IDEA数据库服务器：Mysql 5.1在过程中也出现了一些问题，经过面向百度和谷歌，终于解决了，得到了查询结果。下面开始记录一下过程：首先是整个工程的目录结构：这个结构中需要说明的是，我将所有的配置文件，都放入了Maven管理下的resources目录，这样也为了防止出现IDEA找不到配置文件。我的pom.xml:&lt;?xml version="1.0" ...
SqlSessionFactoryBuilder、SqlSessionFactory、SqlSession作用域（Scope）和生命周期
weixin_33743661的博客
10-26 273
　　可以说每个MyBatis都是以一个SqlSessionFactory实例为中心的。SqlSessionFactory实例可以通过SqlSessionFactoryBuilder来构建。一是可以通过XML配置文件的方式来构建SqlSessionFactory，二是可以通过Java API的方式来构建。但不管通过什么方式都有一个Configuration贯穿始终，各种配置正是通过Configura...
关于SqlSessionFactoryBuilder、SqlSessionFactory、SqlSession的生命周期和作用域
oudoudou123的博客
07-27 139
111
MyBatis 学习 -- 核心组件的作用域以及生命周期
寿春
10-08 401
MyBatis 学习 – 核心组件的作用域以及生命周期 SqlSessionFactoryBuilder SqlSessionFactoryBuilder 的作用在于创建 SqlSessionFactory，创建成功后，SqlSessionFactoryBuilder 就失去了作用，所以它只能存在于创建 SqlSessionFactory 的方法中，而不要让其长期存在。因此 SqlSessionF...
MyBatis——作用域和生命周期
一心同学的博客
11-27 916
通俗易懂讲解MyBatis的生命周期和作用域。
MyBatis学习笔记与实战指南
"这是一份关于MyBatis的学习笔记，包含笔记整理和示例代码，旨在帮助学习者全面理解并掌握MyBatis框架。" 在Java开发领域，MyBatis是一个广泛使用的开源免费数据访问层框架，原名为iBatis，自2010年起在Google Code...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值