MyBatis-3.5.6 框架学习

最新推荐文章于 2024-05-28 20:35:50 发布
最新推荐文章于 2024-05-28 20:35:50 发布
阅读量2.8k 收藏 25
点赞数 13
文章标签： java maven 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53410332/article/details/121311765
版权

1、MyBatis-3.5.6 第一天

环境：

  • jdk1.8
  • Mysql 5.7
  • maven 3.6.1

1.1、什么是MyBatis ？

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

1.2、 持久层

： 持久层，可以理解成数据保存在数据库或者硬盘一类可以保存很长时间的设备里面，不像放在内存中那样断电就消失了，也就是把数据存在持久化设备上，mybatis就是持久层。

​ Dao层 、Service层 、Controller层

  • 完成持久化工作的代码块

1.3、为什么需要MyBatis？

原因：

  • 传统的jdbc复杂。mybatis–方便开发，简化，框架，自动化
  • 帮助程序员将数据存到数据库中

优点：

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

1.4、 搭建环境

创建maven项目时报错：无法解析插件 org.apache.maven.plugins:maven-jar-plugin:2.4 ：应该是该jar包没有用了

  • 删除mvn_repository\org\apache\maven\plugins\maven-jar-plugin下的文件
  • 搭建maven环境，将其作为一个父工程，再创建一个子工程
<!--    导入依赖-->
    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.26</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
        </dependency>
    </dependencies>

1.5、创建mybatis的核心配置文件

<?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.cj.jdbc.Driver"/><!--注意数据库连接的版本-->
                <property name="url" value="jdbc:mysql:///mybatis?useSSL=true&amp;
                useUnicode=true&amp;characterEncoding=UTF-8"/><!--自己的数据库-->
                <property name="username" value="root"/>!<!--自己的数据库用户名-->
                <property name="password" value="xc999"/><!--自己数据库密码-->
            </dataSource>
        </environment>
    </environments>
</configuration>

1.6、编写mybatis的工具类

  1. 每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为核心的。SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得。而 SqlSessionFactoryBuilder 则可以从 XML 配置文件或一个预先配置的 Configuration 实例来构建出 SqlSessionFactory 实例。
  2. 既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例。SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。
public class MyBatisUtils {
    private static SqlSessionFactory build ;
    //静态代码块，初始就加载配置文件
    static {
        String resource="mybatis-config.xml";
        try {
            //1、获取SqlSessionFactory对象(SqlSessionFactory 的实例可以通过SqlSessionFactoryBuilder 获得
            InputStream is = Resources.getResourceAsStream(resource);
            build = new SqlSessionFactoryBuilder().build(is);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

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

1.7、编写代码，测试

  1. 实体类
public class User {
    private int id;
    private String name;
    private String age;

    public User() {
    }

    public User(int id, String name, String age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

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

    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 getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }
}
  1. 接口
public interface UserMapper {
    //查询全部用户
    List<User> getUserList();

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

    //增加用户
    int addUser(User user);

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

    //删除用户
    int deleteUser(int id);
}
  1. 接口实现类–之前（UserDaoImpl） 现在在mybatis中不写，只在配置文件(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="com.xcong.dao.UserMapper">
<!--    id:对应dao里方法名 其实就是之前实现类重写的方法名-->
<!--    resultType:sql语句执行返回的结果 对应全包名-->
  <select id="getUserList" resultType="com.xcong.pojo.User">
        select * from tab_user
  </select>
    <select id="getUserById" parameterType="int" resultType="com.xcong.pojo.User">
        select * from tab_user where id=#{id}
    </select>

<!--    对象中的属性可以直接取出来-->
    <insert id="addUser" parameterType="com.xcong.pojo.User">
        insert into  tab_user values (#{id},#{name},#{age})
    </insert>

    <update id="updateUser" parameterType="com.xcong.pojo.User">
        update tab_user set name =#{name},age=#{age} where id=#{id}
    </update>

    <delete id="deleteUser" parameterType="int">
        delete from tab_user where id=#{id}
    </delete>
</mapper>
  1. 测试

报错：

  • org.apache.ibatis.binding.BindingException: Type interface com.xcong.dao.UserDao is not known to the MapperRegistry.
  • 解决方案： 在核心配置文件中注册
<mappers>
    <mapper resource="com/xcong/dao/UserDao.xml"/>
</mappers>
  • java.lang.ExceptionInInitializerError：The error may exist in com/xcong/dao/UserDao.xml（资源过滤问题）

由于maven的约定大于配置，会导致我们写的配置文件无法导出或生效，所以我们需要在pom.xml里加入一下代码来防止我们资源导出失败的问题。

解决方案：在pom.xml 如果没有用，可以刷新下maven

<!--在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>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
   </resources>
</build>
  • 测试代码
@Test
public  void test(){
    //获取操作对象-SqlSession
    SqlSession sqlSession = MyBatisUtils.getSqlSession();
    
    //相当于之前--获取接口实现类对象，
    UserDao dao = sqlSession.getMapper(UserDao.class);
    
    //调用UserDao里方法
    List<User> userList = dao.getUserList();
    
    //遍历集合
    for (User user : userList) {
        System.out.println(user);
    }
    //关闭连接
    sqlSession.close();
}

2、MyBatis–3.5.6 第二天

2.1、CRUD

crud：主要被用在描述软件系统中数据库或者持久层的基本操作功能。

增加(Create) 检索(Retrieve) 更新(Update) 删除(Delete)

  1. id：对应 dao/Mapper 里方法名，其实就是之前实现类里重写的UserDao接口方法名
  2. ResultType：sql语句执行返回值 对应全包名
  3. parameterType：参数类型
  4. namespace：命名空间 相当于实现类 对应全包名（一直到接口）
//增删改 需要提交事务
public class UserMapperTest {
    @Test
    public  void test1(){
        //获取操作对象-SqlSession
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        //相当于之前--获取接口实现类对象，调用方法  方法1：
//        UserDao dao = sqlSession.getMapper(UserDao.class);
        //方法2
        List<User> userList = sqlSession.selectList("com.xcong.dao.UserDao.getUserList");
//        List<User> userList = dao.getUserList();
        for (User user : userList) {
            System.out.println(user);
        }
        //关闭连接
        sqlSession.close();
    }

    @Test
    public void getUserById(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);//获取接口（相当于之前实现类获取接口）
        User user = mapper.getUserById(1);
        System.out.println(user);
        sqlSession.close();
    }

    //增删改 需要提交事务
    @Test
    public void addUser(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int num = mapper.addUser(new User(3, "光头强", "14"));
        if(num>0){
            System.out.println("成功");
        }
        //提交事务
        sqlSession.commit();
        sqlSession.close();
    }

    //改
    @Test
    public void updateUser(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        mapper.updateUser(new User(3,"团子","6") );
        sqlSession.commit();
        sqlSession.close();
    }
    //删
    @Test
    public void deleteUser(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        mapper.deleteUser(3);
        sqlSession.commit();
        sqlSession.close();
    }
}

2.2、Map（DB字段过多，使用map）

User getUserById2(Map<String,Object> map);

 int addUser1(Map<String,Object> map);
  • 好处：通过 key=value
    1. Map传参，直接在sql中取出key即可–在多个参数情况下使用
    2. 对象传参，直接在sql中取对象的属性即可

2.3、模糊查询

出现问题：Invalid bound statement (not found) ——是自己在UserMapper.xml 方法名写错了–要和接口

UserMapper里面的方法名一直，否则会报错

  • List<User> getUserLike(String value);

  • <select id="getUserLike" resultType="com.xcong.pojo.User">
    select *from tab_user where name like "%"#{value}"%"
</select>

2.4、配置解析

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

  1. configuration（配置）

  2. properties（属性）：同时存在，先执行外部配置

    • 编写配置文件：db.properties

      driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql:///mybatis
username=root
password=xc999

    • 在核心配置文件引入

    <!--引入外部配置文件-->
<properties resource="db.properties">
    <property name="username" value="root"/>
    <property name="password" value="xc999"/>
</properties>

  3. settings（设置）：这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。

  4. typeAliases（类型别名）：类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置，意在降低冗余的全限定类名书写。（建议使用第二种-就是直接：resultType=“com.xcong.pojo.User” ）

    • 第一种：在核心配置文件引入

      <!--给实体类取别名-->
<typeAliases>
    <typeAlias type="com.xcong.pojo.User" alias="User"></typeAlias>
</typeAliases>

    • 第二种：也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean

      <typeAliases>
    <package name="com.xcong.pojo"/>
</typeAliases>

      扫描实体类的包，它的默认别名就是这个类的类名，首字母小写(大写也行)

      <select id="getUserList" resultType="user">
      select * from tab_user
</select>

    • 注解方式：在扫描包的情况下

    • @Alias("user")
public class User {   ~~~~~  }

  5. typeHandlers（类型处理器）

  6. objectFactory（对象工厂）

  7. plugins（插件）

  8. environments（环境配置）:

    • MyBatis 可以配置成适应多种环境，这种机制有助于将 SQL 映射应用于多种数据库之中
    • 尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。
    • 每个数据库对应一个 SqlSessionFactory 实例

    ​ environment（环境变量）

    ​ transactionManager（事务管理器）:

    • 在 MyBatis 中有两种类型的事务管理器（也就是 type="[JDBC|MANAGED(了解)]"）
    • JDBC – 这个配置直接使用了 JDBC 的提交和回滚设施，它依赖从数据源获得的连接来管理事务作用域。
    • 提示 如果你正在使用 Spring + MyBatis，则没有必要配置事务管理器，因为 Spring 模块会使用自带的管理器来覆盖前面的配置。

    ​ dataSource（数据源）：type="[UNPOOLED|POOLED|JNDI]"

    • dataSource 元素使用标准的 JDBC 数据源接口来配置 JDBC 连接对象的资源。

    • POOLED– 这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来，避免了创建新的连接实例时所必需的初始化和认证时间。 这种处理方式很流行，能使并发 Web 应用快速响应请求。

      除了上述提到 UNPOOLED 下的属性外，还有更多属性用来配置 POOLED 的数据源：

      • poolMaximumActiveConnections – 在任意时间可存在的活动（正在使用）连接数量，默认值：10
      • poolMaximumIdleConnections – 任意时间可能存在的空闲连接数。
      • poolMaximumCheckoutTime – 在被强制返回之前，池中连接被检出（checked out）时间，默认值：20000 毫秒（即 20 秒）
      • poolTimeToWait – 这是一个底层设置，如果获取连接花费了相当长的时间，连接池会打印状态日志并重新尝试获取一个连接（避免在误配置的情况下一直失败且不打印日志），默认值：20000 毫秒（即 20 秒）。
      • poolMaximumLocalBadConnectionTolerance – 这是一个关于坏连接容忍度的底层设置， 作用于每一个尝试从缓存池获取连接的线程。 如果这个线程获取到的是一个坏的连接，那么这个数据源允许这个线程尝试重新获取一个新的连接，但是这个重新尝试的次数不应该超过 poolMaximumIdleConnections 与 poolMaximumLocalBadConnectionTolerance 之和。 默认值：3（新增于 3.4.5）
      • poolPingQuery – 发送到数据库的侦测查询，用来检验连接是否正常工作并准备接受请求。默认是“NO PING QUERY SET”，这会导致多数数据库驱动出错时返回恰当的错误消息。
      • poolPingEnabled – 是否启用侦测查询。若开启，需要设置 poolPingQuery 属性为一个可执行的 SQL 语句（最好是一个速度非常快的 SQL 语句），默认值：false。
      • poolPingConnectionsNotUsedFor – 配置 poolPingQuery 的频率。可以被设置为和数据库连接超时时间一样，来避免不必要的侦测，默认值：0（即所有连接每一时刻都被侦测 — 当然仅当 poolPingEnabled 为 true 时适用）。

  9. databaseIdProvider（数据库厂商标识）

  10. mappers（映射器）：直接告诉 MyBatis 到哪里去找映射文件

    • 接口和Mapper配置文件的名字必须相同（eg:UserMapper 接口 UserMapper.xml 配置文件）
    • 接口和Mapper配置文件必须在同一个包下
<!-- 使用相对于类路径的资源引用 -->
<mappers>
  <mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
  <mapper resource="org/mybatis/builder/BlogMapper.xml"/>
  <mapper resource="org/mybatis/builder/PostMapper.xml"/>
</mappers>

2.5、生命周期

作用域和生命周期类别是至关重要的，因为错误的使用会导致非常严重的并发问题。

  • SqlSessionFactoryBuilder

：这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就不再需要它了。 因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）

  • SqlSessionFactory

：SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。因此 SqlSessionFactory 的最佳作用域是应用作用域

  • SqlSession

：连接请求。SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。及时关闭，资源释放。

2.6、ResultMap：结果集映射

  1. resultMap 元素是 MyBatis 中最重要最强大的元素。

  2. ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。

  3. 解决实体类属性名和数据库字段名不一致的问题（如果相同，可以不映射）

  <resultMap id="UserMap" type="User">
      <!--<result column="id" property="id"></result>-->
      <result column="name" property="userName"></result>
      <result column="age" property="userAge"></result>
  </resultMap>


<select id="getUserList" resultMap="UserMap">
      select * from tab_user
</select>

2.7、日志工厂

  1. 如果出现了异常，我们需要排错，就要用到日志。

  2. logImpl：指定 MyBatis 所用日志的具体实现，未指定时将自动查找。

    • LOG4J

      1. Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件
      2. 我们也可以控制每一条日志的输出格式
      3. 可以通过一个配置文件来灵活地进行配置

      第一步:导包

      ​ 加入log4j-1.2.8.jar(可以选择log4j的更高版本)到lib下。

      ​ 如果使用maven项目，也可以选择在pom.xml中新增依赖：

      <!-- 加入log4j支持 -->

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

      第二步:配置log4j.properties 文件:

      log4j.rootLogger=DEBUG,console,file

#控制台输出的相关设置
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=[%c]-%m%n
#log4j.appender.credit.layout.ConversionPattern=%d{yyyy/MM/dd HH\:mm\:ss,SSS} [%-3p][class:%l] %m %n
#文件输出的相关设置
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/logging.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n

#日志输出级别
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

      第三步：

      在要输出日志的类中加入相关语句：

      定义属性：static Logger logger = Logger.getLogger(LogDemo.class); //LogDemo为相关的类

      在相应的方法中：执行后会生成响应的log包和文件（log4j.appender.file.File=./log/logging.log）

       @Test
    public void log4j(){
        logger.info("info:log4j");
        logger.debug("debug:log4j");
        logger.error("error:log4j");
    }

    • STDOUT_LOGGING（stdout_logging）:标准日志输出（什么都不用配，直接用）

    <!--注意位置-->
<settings>
    <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

2.8、分页

好处：减少数据的处理量

使用Limit分页

select *from tab_user limit startIndex,pagesSize;

使用mybatis实现：

  1. 接口
//分页
List<User> getUserByLimit(Map<String,Integer> map);
  1. 配置
<select id="getUserByLimit" resultType="user" parameterType="map">
    select *from tab_user limit #{startIndex},#{pageSize}
</select>

  1. 测试

       @Test
    public void limit(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        HashMap<String, Integer> map = new HashMap<String, Integer>();
//        map.put("0",1);  错误的，sql里面的字段是一个个键
        map.put("startIndex",1);
        map.put("pageSize",1);
        List<User> user = mapper.getUserByLimit(map);
        for (User user1 : user) {
            System.out.println(user1);
        }
        sqlSession.close();
    }

使用RowBounds分页

  1. 接口
//分页
List<User> getUserByLimit();

  1. 配置

    <select id="getUserByLimit" resultType="user">
    select *from tab_user 
</select>

  2. 测试

@Test
public void test11(){
    SqlSession sqlSession = MyBatisUtils.getSqlSession();
    RowBounds rowBounds = new RowBounds(0, 1);
    List<User> userList = sqlSession.selectList("com.xcong.dao.UserMapper.getUserByRowBound", null, rowBounds);
    for (User user : userList) {
        System.out.println(user);
    }
    sqlSession.close();
}

分页插件：PageHelper

2.9、使用注解开发

package org.mybatis.example;
public interface BlogMapper {
  @Select("SELECT * FROM blog WHERE id = #{id}")
  Blog selectBlog(int id);
}

<mappers>
    <mapper resource="com/xcong/dao/UserMapper.xml"/>
</mappers>

在进行一些简单的增删改时使用

使用注解来映射简单语句会使代码显得更加简洁，但对于稍微复杂一点的语句，Java 注解不仅力不从心，还会让你本就复杂的 SQL 语句更加混乱不堪。 因此，如果你需要做一些很复杂的操作，最好用 XML 来映射语句。

揽星河吖
关注
  • 13
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
深入浅出 最新版 MyBatis-3.5.6_ 5. MyBatis 一对一 & 一对多 级联查询
胖子胖子大胖子的博客
03-01 1129
介绍这个之前，我们先来说说 一对一，一对多是什么玩意 一、一对一、一对多 我们来想一个问题，就是学生和班级的关系。 不难知道，一个学生肯定在一个时刻只能在一个班级，那么对于学生来说，它就是一，一对一，就是一个学生对应一个班级。 相同的，如果我们把一个班级看成一，那么，一个班级肯定不止有一个学生，这也就是说，一个班级会对应多个学生。 上个图来好好理解一下 接着我们再来想一个问题 如果按照这样我们去设计数据库的表，我们该怎么设计呢。首先是的有两个表，一个是学生表，一个是班级表 学生有主键
深入浅出 最新版 MyBatis-3.5.6_ 6. MyBatis 动态 SQL
胖子胖子大胖子的博客
03-01 1893
一、什么是动态 SQL 我们打开 MyBatis 3 官网的文档：https://mybatis.org/mybatis-3/zh/dynamic-sql.html，一边看官网一边去说 我们之前在学习 JDBC 时，好比碰到条件查询，我们需要用 Java 代码去判断，然后再进行 SQL 的拼接，有的时候多一个逗号或者是多一个逗号，都会导致我们的 SQL 的错误。 可以说是非常的痛苦，但是好在 MyBatis 给我们解决了这个问题，我们可以使用 MyBatis 的动态 SQL，让 MyBatis 帮
基于MyBatisPlus表结构维护工具
最新发布
yu57955的博客
05-28 555
用于同步表实体与数据库表结构，同步建表、删改字段、索引，种子数据…
要注意了！这样使用MyBatis框架，被攻击了！
weixin_47067712的博客
07-23 429
前言 SQL注入漏洞作为WEB安全的最常见的漏洞之一，在java中随着预编译与各种ORM框架的使用，注入问题也越来越少。新手代码审计者往往对Java Web应用的多个框架组合而心生畏惧，不知如何下手，希望通过Mybatis框架使用不当导致的SQL注入问题为例，能够抛砖引玉给新手一些思路。 一、Mybatis的SQL注入 Mybatis的SQL语句可以基于注解的方式写在类方法上面，更多的是以xml的方式写到xml文件。Mybatis中SQL语句需要我们自己手动编写或者用generator自动生成。编写xml文
mybaits源码环境搭建-3.5.6
qq_45001340的博客
03-26 838
mybaits-3.5.6源码环境搭建 mybatis源码仓库地址：https://github.com/mybatis/mybatis-3 我下载的是版本3.5.6：https://github.com/mybatis/mybatis-3/releases/tag/mybatis-3.5.6 打开pom文件查看mybatis依赖，发现他依赖 mybatis-parent 的版本32 <parent> <groupId>org.mybatis</groupId>
11-SSM_MyBatis（上）
&再见萤火虫&的博客
01-07 1073
一，Mybatis介绍 MyBatis 本是 apache 的一个开源项目 iBatis, 2010 年这个项目由 apache software foundation 迁移到了 google code，并且改名为MyBatis 。2013 年 11 月迁移到 Github。iBATIS 一词来源于“internet”和“abatis”的组合，是一个基于 Java 的持久层框架。 iBATIS 提供的持久层框架包括 SQL Maps 和 Data Access Objects（DAO）。 Myba..
mybatis-3.5.6框架包及官方文档.zip
04-09
在"Mybatis-3.5.6框架包及官方文档.zip"中，我们可以期待找到以下关键知识点： 1. **MyBatis核心组件**：包括SqlSessionFactoryBuilder、SqlSessionFactory和SqlSession等核心组件，它们各自负责构建工厂、管理会话...
mybatis-3-mybatis-3.5.6.zip
01-20
总的来说，MyBatis-3.5.6是一个强大而灵活的Java持久层框架，它降低了数据库操作的复杂性，使得开发者可以专注于业务逻辑，而不是繁琐的数据访问细节。通过深入理解并熟练运用MyBatis，开发者可以构建出高效、易维护...
mybatis3.5.6zip
12-06
在"Mybatis3.5.6"这个版本中，我们可以看到以下几个关键知识点： 1. **版本更新**：MyBatis 3.5.6是MyBatis的一个稳定版本，它可能会包含对前一版本的bug修复、性能优化以及新的功能添加。了解这个版本的变更日志，...
MyBatis的Jar包
09-24
6. **简单易用**：MyBatis的学习曲线相对较低，它允许开发者直接写SQL，保持了SQL的灵活性。 **MyBatis与Spring的整合**： 1. **SqlSessionFactoryBean**：这是一个Spring的Bean工厂，用于创建SqlSessionFactory，...
mybatis3与spring5整合.rar
08-24
在IT行业中，MyBatis和Spring是两个非常重要的框架，它们分别在持久层和容器管理方面发挥着关键作用。...在学习和使用过程中，理解这两个框架的核心概念和整合原理，对于提升开发效率和代码质量至关重要。
mybatis版本：3.5.6（jdk1.8（含）及以上）、3.4.6（jdk1.8以下）
11-18
两版mybatis，根据jdk版本选择使用哪一版，mybatis版本：3.5.6（jdk1.8（含）及以上）、3.4.6（jdk1.8以下）
mybatis-3.5.6.zip
10-18
mybatis-3.5.6.zip 最新版的mybatis-3.5.6.zip，从官网下了半天才下载下来，现在放到CSDN方便大家
mybatis3.5.6
11-04
学习mybatis 不创建maven 需要下载jar包 但是在GitHub上下载实在是太慢了，有时还可能下载不了。分享一下
【MyBatis】〖所有依赖jar包〗mybatis-3.5.6-lib
12-31
【MyBatis】〖所有依赖jar包〗mybatis-3.5.6-lib 我寻见一片海 碧蓝且耀着光 大片船只航行其上 都向着远方 Shared by Foriver_江河 © 1997-8023 江河 All Rights Reserved.
深入浅出 最新版 MyBatis-3.5.6_ 3. MyBatis 核心配置介绍
胖子胖子大胖子的博客
02-21 1956
我们这一篇主要介绍 MyBatis 的核心配置，大家可以一边看官方文档，一边看博客，当然，不管是谁写博客，都是会根据官网的内容去介绍，所以说，看啥不如看官网解释~~~ MyBatis 核心配置链接：https://mybatis.org/mybatis-3/zh/configuration.html 然后我们再上一个图 我们主要也是根据 MyBatis 官网的内容去说，当然，我们主要说一些常用的，不常用的大家可以自己去官网进行看 1.configuration 首先是configurati..
MyBatis-Plus版本升级指引
likunxing的博客
12-19 3169
mybaits、mybatis-spring、spring-boot、spring-cloud版本兼容
Spring整合Mybatis
m0_73030012的博客
11-17 712
1、将数据源文件交给spring管理，spring中提供了PropertyPlaceholderConfigurer来进行管理，将数据源的配置文件进行注入。3、将mybatis的工厂交给spring管理，spring提供了SqlSessionFactoryBean来管理，他需要依赖数据源的信息。注意需要提供spring对jdbc的支持，使用连接池还需要common-pool的包，spring-tx包 - 事务管理。注意：有location的，一般都会加classpath，表示的是src下。
深入浅出 最新版 MyBatis-3.5.6_ 8. MyBatis 缓存
胖子胖子大胖子的博客
03-02 1304
我们不难知道，数据是存储在计算机硬盘上，如果我们频繁的从数据库读取数据，时间长了会造成数据库堵塞，IO 开销高了之后，性能大打折扣。 所以为了能够减少从数据库读取，我们引入了缓存这个东西。 MyBatis 中提供了两种缓存，一级缓存和二级缓存。 一、MyBatis 一级缓存 MyBatis 中默认是开启一级缓存的，而一级缓存是 SqlSession 级别的缓存。 我们学习的时候，需要构建 SqlSession，而在这个对象中有一个数据结构（ HashMap ）,用于存储缓存数据。并且不同的sqlS
mybatis-3.5.6.jar
09-05
MyBatis是一个开源的持久化框架，3.5.6是MyBatis的一个版本。MyBatis提供了一种直观、灵活、高效的方式来访问数据库，可以帮助开发人员更轻松地处理数据库操作。 MyBatis的jar文件（mybatis-3.5.6.jar）是一个Java Archive文件，包含了MyBatis的核心代码和依赖库。通过将该jar文件添加到项目的类路径中，开发人员可以使用MyBatis的功能。 在使用MyBatis时，我们需要配置一个SqlSessionFactory对象，该对象是MyBatis的核心接口之一，负责创建SqlSession对象。SqlSession对象是实际执行SQL语句的入口，通过它可以执行数据库的增删改查操作。 除了核心功能外，MyBatis还提供了许多其他特性，如动态SQL、参数映射、结果映射等。动态SQL允许我们根据不同的条件生成不同的SQL语句，参数映射可以方便地将Java对象与SQL语句的参数进行映射，结果映射可以将SQL查询结果映射为Java对象。 MyBatis还支持与Spring等其他框架的集成，使得开发人员可以更方便地将MyBatis与其他框架结合使用。 总之，MyBatis-3.5.6.jar是MyBatis框架的一个版本，它提供了访问数据库的简单易用的方式，帮助开发人员提升开发效率。通过配置和使用MyBatis的各种功能，我们可以更轻松地处理数据库操作，提供高效可靠的数据访问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

揽星河吖

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值