MyBatis（十四）mybatis的注解开发

最新推荐文章于 2023-01-07 20:00:45 发布
最新推荐文章于 2023-01-07 20:00:45 发布
阅读量229 收藏
点赞数
分类专栏： Mybatis 文章标签： 数据库 mybatis java mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014565127/article/details/105962856
版权

目录

Mybatis的注解开发

一、注解开发的环境搭建

1. 创建一个新的项目

在这里插入图片描述

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.veeja</groupId>
    <artifactId>day04_03mybatis</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

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

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
        </dependency>
    </dependencies>
</project>

3. 实体类User

package com.veeja.domain;

import java.io.Serializable;
import java.util.Date;

public class User implements Serializable {
    
    private Integer id;
    private String username;
    private String address;
    private String sex;
    private Date birthday;

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

    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 String getAddress() {
        return address;
    }

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

    public String getSex() {
        return sex;
    }

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

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
}

4. dao接口

package com.veeja.dao;

import com.veeja.domain.User;

import java.util.List;

/**
 * IUserDao接口
 */
public interface IUserDao {
    /**
     * 查询所有用户信息
     *
     * @return
     */
    List<User> findAll();
}

5. log4j的配置文件

src/main/resources下的log4j.properties：

# 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

6. jdbcConfig.properties

src/main/resources下的jdbcConfig.properties：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatisdatabase
jdbc.username=root
jdbc.password=0000

7. 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>
    <!--引入外部配置文件-->
    <properties resource="jdbcConfig.properties"></properties>
    <!--配置别名-->
    <typeAliases>
        <package name="com.veeja.domain"/>
    </typeAliases>
    <!--配置环境-->
    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <!--引入带有注解的dao接口所在位置-->
    <mappers>
        <package name="com.veeja.dao"/>
    </mappers>
</configuration>

这样我们的环境就算搭建完成了。接下来我们就要尝试使用注解的方式进行开发了。

8. 给findAll()方法添加注解

/**
 * 查询所有用户信息
 *
 * @return
 */
@Select("select * from user")
List<User> findAll();

9. 测试类测试

package com.veeja.test;

import com.veeja.dao.IUserDao;
import com.veeja.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 java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class UserTest {
    /**
     * 测试基于注解的mybatis的使用
     *
     * @param args
     */
    public static void main(String[] args) throws IOException {
        //1.获取字节输入流
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.根据字节输入流构建SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //3.根据SqlSessionFactory生产一个SqlSeesion
        SqlSession session = factory.openSession();
        //4.使用sqlSession获取dao的代理对象
        IUserDao userDao = session.getMapper(IUserDao.class);
        //5.执行dao的方法
        List<User> users = userDao.findAll();
        for (User user : users) {
            System.out.println(user);
        }
        //6.释放资源
        session.close();
        in.close();
    }
}

执行一下，完全没有问题：
在这里插入图片描述
这样我们的环境就算是搭建成功了！

· 注意事项

我们要额外注意一点，如果我们在使用注解的同时配置了xml映射文件，我们再次运行测试类，就会报错：
在这里插入图片描述

二、单表CRUD操作（代理Dao方式）

1. 常用注解说明

@Insert:实现新增
@Update:实现更新
@Delete:实现删除
@Select:实现查询
@Result:实现结果集封装
@Results:可以与
@Result 一起使用，封装多个结果集
@ResultMap:实现引用
@Results 定义的封装
@One:实现一对一结果集封装
@Many:实现一对多结果集封装
@SelectProvider: 实现动态 SQL 映射
@CacheNamespace:实现注解二级缓存的使用

2. 保存用户的操作

IUserDao：

/**
 * 添加用户
 *
 * @param user
 */
@Insert("insert into user(username,address,sex,birthday) values(#{username},#{address},#{sex},#{birthday})")
void saveUser(User user);

测试：

public class AnnotationCRUDTest {
    private InputStream in;
    private SqlSessionFactory factory;
    private SqlSession session;
    private IUserDao userDao;

    @Before
    public void init() throws IOException {
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        factory = new SqlSessionFactoryBuilder().build(in);
        session = factory.openSession();
        userDao = session.getMapper(IUserDao.class);
    }

    @After
    public void destroy() throws IOException {
        session.commit();
        session.close();
        in.close();
    }

    /**
     * 测试查询所有用户的信息
     */
    @Test
    public void testFindAll() {
        List<User> users = userDao.findAll();
        for (User user : users) {
            System.out.println(user);
        }
    }

    /**
     * 测试：添加用户
     */
    @Test
    public void testAddUser() {
        User user = new User();
        user.setUsername("新用户");
        user.setBirthday(new Date());
        user.setSex("男");
        user.setAddress("珠穆朗玛峰");

        userDao.saveUser(user);
        testFindAll();
    }
}

结果：
在这里插入图片描述

3. 更新用户的操作

IUserDao：

/**
 * 根据id更新用户的信息
 *
 * @param user
 */
@Update("update user " +
        "set username=#{username},sex=#{sex},address=#{address},birthday=#{birthday} " +
        "where id=#{id}")
void updateUser(User user);

测试方法：

/**
 * 测试：添加用户
 */
@Test
public void testUpdateUser() {
    User user = new User();
    user.setUsername("超级新用户");
    user.setBirthday(new Date());
    user.setSex("男");
    user.setAddress("不是珠穆朗玛峰");
    
    user.setId(75);
    
    userDao.updateUser(user);
    testFindAll();
}

测试结果：
在这里插入图片描述

4. 删除用户

IUserDao：

/**
 * 删除用户
 *
 * @param id
 */
@Delete("delete from user where id=#{id}")
void deleteUserByid(Integer id);

测试方法：

/**
 * 测试删除用户
 */
@Test
public void testDeleteUser() {
    userDao.deleteUserByid(75);
    testFindAll();
}

结果：
在这里插入图片描述

5. 根据id查询用户信息

IUserDao：

/**
 * 根据用户id查询用户信息
 *
 * @param id
 * @return
 */
@Select("select * from user where id=#{id}")
User findUserById(Integer id);

测试方法：

/**
 * 根据用户id查询用户信息
 */
@Test
public void testFindUserById() {
    User user = userDao.findUserById(41);
    System.out.println(user);
}

结果：
在这里插入图片描述

6. 根据用户名称进行模糊查询

IUserDao：

/**
 * 根据用户名查询用户信息
 *
 * @param username
 * @return
 */
@Select("select * from user where username like #{username}")
List<User> findUserByUsername(String username);

测试方法：

/**
 * 测试：根据用户名查询用户信息
 */
@Test
public void testFindUserByUsername() {
    List<User> users = userDao.findUserByUsername("%刘%");
    for (User user : users) {
        System.out.println(user);
    }
}

或者使用：
在这里插入图片描述
结果：
在这里插入图片描述

7. 查询用户数量

IUserDao：

/**
 * 查询总用户数量
 *
 * @return
 */
@Select("select count(*) from user")
int findTotal();

测试方法：

/**
 * 测试：查询用户数量
 */
@Test
public void testFindTotal() {
    int count = userDao.findTotal();
    System.out.println(count);
}

结果：
在这里插入图片描述

8. 用注解建立实体类和数据库列名的关系

如果我们的实体类中的属性名和数据库中的列名不相同的话，那么我们要进行额外的配置。
在这里插入图片描述
例如查询所有的操作：

/**
 * 查询所有用户信息
 *
 * @return
 */
@Select("select * from user")
@Results(id = "userMap", value = {
        @Result(id = true, column = "id", property = "userId"),
        @Result(column = "username", property = "userName"),
        @Result(column = "sex", property = "userSex"),
        @Result(column = "address", property = "userAddress"),
        @Result(column = "birthday", property = "userBirthday")
})
List<User> findAll();

而且我们在上面指定了Results的id，那么在下面其他的方法中就可以不用再定义一遍了，可以直接引用它的id就行了。
即：

/**
 * 根据用户名查询用户信息
 *
 * @param username
 * @return
 */
@Select("select * from user where username like '%${value}%' ")
@ResultMap(value = "userMap")
List<User> findUserByUsername(String username);

三、复杂关系映射开发、多表操作

实现复杂关系映射之前我们可以在映射文件中通过配置<resultMap>来实现，在使用注解开发时我们需要借助@Results 注解，@Result 注解，@One 注解，@Many 注解。

1. 复杂关系映射的注解说明

@Results 注解

代替的是标签<resultMap>

该注解中可以使用单个@Result 注解，也可以使用@Result 集合
@Results({@Result(),@Result()})或@Results(@Result())

@Resutl 注解

代替了 <id>标签和<result>标签

@Result 中 属性介绍：
id 是否是主键字段
column 数据库的列名
property 需要装配的属性名
one 需要使用的@One 注解(@Result(one=@One)()))
many 需要使用的@Many 注解(@Result(many=@many)()))

@One注解（一对一）

代替了<assocation>标签，是多表查询的关键，在注解中用来指定子查询返回单一对象。

@One 注解属性介绍：
select 指定用来多表查询的 sqlmapper
fetchType 会覆盖全局的配置参数 lazyLoadingEnabled
使用格式：@Result(column="",property="",one=@One(select=""))

@Many注解（多对一）

代替了<Collection>标签,是是多表查询的关键，在注解中用来指定子查询返回对象集合。

注意：聚集元素用来处理“一对多”的关系。需要指定映射的 Java 实体类的属性，属性的 javaType（一般为ArrayList）但是注解中可以不定义；

使用格式： @Result(property="",column="",many=@Many(select=""))

2. 实现一对一复杂关系映射及延迟加载

需求：
加载账户信息时并且加载该账户的用户信息，根据情况可实现延迟加载。

① User实体类 和 Account实体类
package com.veeja.domain;
public class User implements Serializable {
    private Integer userId;
    private String userName;
    private String userAddress;
    private String userSex;
    private Date userBirthday;

    @Override
    public String toString() {
        return "User{" +
                "userId=" + userId +
                ", userName='" + userName + '\'' +
                ", userAddress='" + userAddress + '\'' +
                ", userSex='" + userSex + '\'' +
                ", userBirthday=" + userBirthday +
                '}';
    }

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

	......
}


package com.veeja.domain;

import java.util.List;

/**
 * @author veeja
 */
public class Account {
    private Integer id;
    private Integer uid;
    private Double money;
    // 多对一（mybatis中称之为一对一）的对应关系
    private User user;

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", uid=" + uid +
                ", money=" + money +
                ", user=" + user +
                '}';
    }

    public Integer getId() {
        return id;
    }

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

    public Integer getUid() {
        return uid;
    }

    public void setUid(Integer uid) {
        this.uid = uid;
    }

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }
}
② 持久层接口（使用注解配置）

IAccountDao：

/**
 * 查找所有的账户信息，并且获取每个用户所属的用户的信息
 *
 * @return
 */
@Select("select * from account")
@Results(id = "accountMap", value = {
        @Result(id = true, column = "id", property = "id"),
        @Result(column = "uid", property = "uid"),
        @Result(column = "money", property = "money"),
        @Result(property = "user",
                column = "uid",
                one = @One(
                        select = "com.veeja.dao.IUserDao.findUserById",
                        fetchType = FetchType.EAGER))
})
List<Account> findAll();

IUserDao：

/**
 * IUserDao接口
 */
public interface IUserDao {
    /**
     * 查询所有用户信息
     *
     * @return
     */
    @Select("select * from user")
    @Results(id = "userMap",value = {
            @Result(id = true, column = "id", property = "userId"),
            @Result(column = "username", property = "userName"),
            @Result(column = "sex", property = "userSex"),
            @Result(column = "address", property = "userAddress"),
            @Result(column = "birthday", property = "userBirthday")
    })
    List<User> findAll();

    
    /**
     * 根据用户id查询用户信息
     *
     * @param id
     * @return
     */
    @Select("select * from user where id=#{id}")
    @ResultMap(value = "userMap")
    User findUserById(Integer id);


}
③ 测试类
/**
 * 测试：查询所有用户信息
 */
@Test
public void testFindAll() {
    List<Account> accounts = accountDao.findAll();
    for (Account account : accounts) {
        System.out.println(account);
    }
}

结果：
在这里插入图片描述

3. 一对多的复杂关系映射

需求：
查询用户信息时，也要查询他的账户列表。

① User实体类中加入List<Account>
public class User implements Serializable {

    private Integer userId;
    private String userName;
    private String userAddress;
    private String userSex;
    private Date userBirthday;

    List<Account> accounts;

    public List<Account> getAccounts() {
        return accounts;
    }

    public void setAccounts(List<Account> accounts) {
        this.accounts = accounts;
    }
	
	......
}
② 持久层接口配置

IUserDao：

/**
 * IUserDao接口
 */
public interface IUserDao {
    /**
     * 查询所有用户信息
     *
     * @return
     */
    @Select("select * from user")
    @Results(id = "userMap", value = {
            @Result(id = true, column = "id", property = "userId"),
            @Result(column = "username", property = "userName"),
            @Result(column = "sex", property = "userSex"),
            @Result(column = "address", property = "userAddress"),
            @Result(column = "birthday", property = "userBirthday"),
            @Result(property = "accounts",
                    column = "id",
                    many = @Many(
                            select = "com.veeja.dao.IAccountDao.findAccountsByUid",
                            fetchType = FetchType.LAZY
                    ))
    })
    List<User> findAll();

    /**
     * 根据用户id查询用户信息
     *
     * @param id
     * @return
     */
    @Select("select * from user where id=#{id}")
    @ResultMap(value = "userMap")
    User findUserById(Integer id);
}

IAccountDao：

public interface IAccountDao {
    /**
     * 查找所有的账户信息，并且获取每个用户所属的用户的信息
     *
     * @return
     */
    @Select("select * from account")
    @Results(id = "accountMap", value = {
            @Result(id = true, column = "id", property = "id"),
            @Result(column = "uid", property = "uid"),
            @Result(column = "money", property = "money"),
            @Result(property = "user",
                    column = "uid",
                    one = @One(
                            select = "com.veeja.dao.IUserDao.findUserById",
                            fetchType = FetchType.EAGER))
    })
    List<Account> findAll();


    /**
     * 根据用户id查询用户的账号信息
     *
     * @return
     */
    @Select("select * from account where uid=#{uid}")
    List<Account> findAccountsByUid(Integer uid);
}
③ 测试方法：
/**
 * 测试：查询所有用户信息
 */
@Test
public void testFindAll() {
    List<User> users = userDao.findAll();
    for (User user : users) {
        System.out.println(user);
        System.out.println(user.getAccounts());
    }
}

结果：
在这里插入图片描述

四、缓存的配置

1. 在SqlMapConfig.xml中开启二级缓存支持

<settings>
    <setting name="cacheEnabled" value="true"/>
</settings>

2. 在持久层接口中使用注解配置二级缓存

/**
 * IUserDao接口
 */
@CacheNamespace(blocking = true)
public interface IUserDao {
	......
}

3. 测试方法

InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);

//使用第一个session操作
SqlSession session = factory.openSession();
IUserDao userDao = session.getMapper(IUserDao.class);
User user = userDao.findUserById(41);
System.out.println(user);
System.out.println(user.getAccounts());
session.close();

// 使用第二个session操作
SqlSession session2 = factory.openSession();
IUserDao userDao2 = session2.getMapper(IUserDao.class);
User user2 = userDao2.findUserById(41);
System.out.println(user2);
System.out.println(user2.getAccounts());
session2.close();

in.close();

结果，我们是可以看到，只进行了一次查询的：
在这里插入图片描述

end.
mybatis的系列算是结束了，基础知识基本上都总结了。

veejaLiu
关注
专栏目录
Mybatis源码解析之SqlSessionFactory
ccccc202的博客
09-11 299
Mybatis实战教程-入门必看 上面我们已经探讨了mybatis的使用,但mybatis的调用流程咱们还是不知道,下面咱们花点时间来探讨下整个流程 SqlSessionFactory build = new SqlSessionFactoryBuilder().build(resourceAsStream); 第一步是获取SqlSessionFactory 对象,我们看下里面做了啥? 创建XMLConfigBuilder对象 new SqlSessionFactoryBuilder().build
Mybatis关联映射；Mybatis注解
qq_65687461的博客
04-15 2283
Mybatis关联映射 Mybatis关联映射的用途： 在实际的开发过程中，对于数据库的操作除了单表外往往会涉及到多张表，这些操作在面向对象中就涉及到了对象与对象之间的关联关系。针对多表之间的操作，MyBatis提供了关联映射，通过关联映射就可以很好的处理对象与对象之间的关联关系。 关联关系的种类： 在关系型数据库中，多表之间存在着三种关联关系，分别为一对一（1:1）、一对多（1：N）和多对多（M：N）。 一对一（1:1）：在任意一方引入对方主键作为外键。 一对多（1：N）：在“多”的一方，
Mybatis源码分析之SqlSessionFactory（一）
weixin_33861800的博客
01-11 168
简介MyBatis的前身叫iBatis，本是apache的一个开源项目, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis。MyBatis是支持普通SQL查询，存储过程和高级映射的优秀持久层框架。MyBatis消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。MyBatis使用简单的XML或注解用于配置和...
Mybatis使用注解增删改查
fxy12333的博客
04-23 121
在接口写上注解 //使用注解 @Select("select * from user") List<User> getUserList2(); 在主配置文件绑定接口 <!--绑定接口--> <mappers> <mapper class="com.fxy.dao.UserDao"/> </ma...
mybatis学习（三）SqlSessionFactory
leo
05-24 631
使用 XML 中创建 SqlSessionFactory 从 XML 文件中创造 SqlSessionFactory 实例是非常简单的。推荐使用一个类路径资源来进行配置，也可以使用一个 Reader 实例，甚至使用 URL 路径。MyBatis 有一个 Resources 通用类，类中有许多方法可以简单地从类路径和其他地址中加载资源。public class MyBatisUtil {
MyBatis源码解析之SqlSessionFactory的构建
mist蒙的博客
02-03 367
mybatis他是一个基于jdbc封装好的一个持久层框架。 在使用mybatis的时候，我们需要创建一个sqlSessionFactory与sqlSession，然后使用sqlSession创建出我们的代理对象，由代理对象去执行目标方法，拿到最终的执行结果。 因为我们这一块的所有的mapper都是基于接口的，所以mybatis使用jdk的动态代理来创建代理对象。 首先看一下官方文档对于这几个名字的解释 SqlSessionFactoryBuilder 这个类可以被实例化、使用和丢弃，一旦创建了 SqlSes
MyBatis Generator去掉生成的注解
09-01
MyBatis Generator是一款强大的自动化工具，它能够帮助开发者自动生成Java实体类、Mapper接口和XML映射文件，极大地提高了开发效率。然而，在实际使用过程中，有些人可能会觉得MyBatis Generator生成的注解过多，...
整合Mybatis和Spring框架进行注解开发SSM框架的学习与应用-Java EE企业级应用开发学习记录（第十天）
最新发布
09-11
本资源记录了在Java EE企业级应用开发学习过程中的第十天内容，重点关注了整合Spring、Spring MVC和MyBatis（SSM框架）进行注解开发的学习和应用。通过这一天的学习，您将掌握如何构建强大的Web应用程序，同时提供了...
MyBatis使用注解开发实现步骤解析
08-18
MyBatis使用注解开发实现步骤解析 MyBatis是一个流行的持久层框架，它提供了两种方式来开发映射语句，一种是使用XML文件，另一种是使用注解。使用注解开发可以减少配置文件的数量，提高开发效率，但需要注意一些...
Mybatis系列教程Mybatis注解开发共9页.pdf
11-19
【标题】"Mybatis系列教程Mybatis注解开发共9页.pdf" 提供的是一个关于Mybatis框架注解开发的教程，重点在于讲解如何在Mybatis中使用注解进行数据库操作。Mybatis是一个轻量级的Java持久层框架，它允许开发者通过...
Mybatis源码解析一： SqlSessionFactoryBuilder以及Configuration解析配置，生成SqlSessionFacroty
Fighting_Man的博客
01-07 1462
SqlSessionFactoryBuilder就是负责解析mybatis配置文件，将解析的配置都存放到Configuration实例中，最后对外提供一个SqlSessionFactory实例。
MyBatis复习(三)：MyBatis核心对象SqlSessionFactory和SqlSession
想好了就去做吧 即便失败了 至少这条路上留下了你的脚印
05-17 834
MyBatis有两个核心对象：SqlSessionFactory、SqlSession SqlSessionFactory是MyBatis的核心对象，主要用于加载配置文件，初始化MyBatis，并创建SqlSession的作用。所以需要保证SqlSessionFactory在应用中全局唯一 SqlSession是MyBatis操作数据库的核心对象。SqlSession实在原始JDBC的基础上进行扩展，简化了与数据库的交互工作。并且SqlSession对象提供了数据表的CRUD对应的API方法。
MyBatis的核心组件：SqlSessionFactoryBuilder、SqlSessionFactory、SqlSession和SQL Mapper
段远山
05-01 480
MyBatis的核心组件：SqlSessionFactoryBuilder、SqlSessionFactory、SqlSession和SQL Mapper 1）SqlSessionFactoryBuilder（构造器）：它会根据配置或者代码来生成 SqlSessionFactory，采用的是分步构建的 Builder 模式。 2）SqlSessionFactory（工厂接口）：依靠它来生成...
mybatis 最常用的 SqlSessionFactory 和 SqlSession，你真的了解吗？
LoveSummer
05-31 4768
前言 学习框架一个比较好的路径阅读源码。本文介绍的SqlSessionFactory和SqlSession。可以通过了解SqlSessionFactory接口和SqlSession接口以及两个的实现类入手，去看源码了解实现过程。最好能把项目下载到本地，慢慢分析实现过程。 MyBatis的持久化解决方案是将用户从原始的JDBC访问中解放出来，用户只需要定义需要操作的SQL语句，无须关注底层的JDBC操作，就可以以面向对象的方式来进行持久化层操作。底层数据库连接的获取，数据访问的实现，事务控制等都无须用户关心
Mybatis 之 SqlSessionFactory
zsg88的专栏
08-24 1378
基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为中心的。SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得。而 SqlSessionFactoryBuilder 则可以从 XML 配置文件或一个预先定制的 Configuration 的实例构建出 SqlSessionFactory 的实例。 一.
MyBatis原理分析之获取SqlSessionFactory
小小默：进无止境
08-02 3585
MyBatis的执行原理分为如下四步: ① 获取SqlSessionFactory ② 获取SqlSession ③ 获取mapper的代理对象 ④ sqlsession进行具体CRUD过程 这里又分为三种场景： ① 无spring环境 自己手动根据mybatis配置文件获取SqlSessionFactory和SqlSession ② 传统ssm环境 通常在applicationContext.xml中注册了SqlSessionFactory和SqlSession ③ SpringBoot
MyBatis入门系列(22) -MyBatis-Spring核心源码解析之SqlSessionFactoryBean
记录知识、锤炼自我
11-01 5108
前言 在之前使用了mybatis的文档中，我们需要手动创建SqlSessionFactory对象来获取SqlSession，然后通过SqlSession获取mapper代理对象，进行数据库操作。 // 根据xml配置文件（全局配置文件）创建一个SqlSessionFactory对象 String resource = "mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); Sql
MyBatis--注解方式
热门推荐
菜鸟Li
11-06 1万+
注解方式是MyBatis的一种比较简单容易实现的方式，相对起xml文件方式，更适合简单的SQL语句。 下面我用MyBatis来实现一个利用注解形式返回给前端数据库中的表查询结果，返回结果格式是Json。 开发环境：Windows10+MySql5.7+Intellij IDEA SQL表： tb_user | CREATE TABLEtb_user(idint(11) NOT NULL AUTO_...
Mybatis复习笔记（个人查漏补缺）
gxzhaha的博客
06-08 383
不建议收藏，不建议点赞，建议评论错误的地方，小白自己学过一遍SSM，又来复习一下，比较多知识点第一次学不是那么理解，可能做的总结也会有些错误，望指点。 第一章 框架概述 框架:整个或部分系统的可重用设计 常见框架： 1.解决数据持久化问题的框架 2.解决web层问题的mvc框架 3.解决技术整合问题的框架Spring 传统JDBC 1.数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题。 ...
Struts2 Mybatis3 Spring3 整合注解教程
"该资源提供了一个使用Struts2.1.8、Mybatis3.0和Spring3.0（全注解）的小型示例项目，适合初学者学习。文档详细解释了配置和使用这些技术的步骤。" 在这个示例项目中，开发者将体验到三大主流Java框架——Struts2...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值