MyBatis入门----MyBatis相关API、映射配置文件和核心配置文件，以及使用MyBatis传统方式实现Dao层

最新推荐文章于 2022-07-14 15:20:38 发布
最新推荐文章于 2022-07-14 15:20:38 发布
阅读量302 收藏
点赞数 1
分类专栏： # MyBatis 文章标签： 数据库 sql java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yyuggjggg/article/details/119793580
版权

框架是一款半成品软件 ,我们可以基于这个半成品软件继续开发，来完成我们个性化的需求!

ORM介绍

ORM(Object Relational Mapping) :对象关系映射

​ 指的是持久化数据和实体对象的映射模式，为了解决面向对象与关系型数据库存在的互不匹配的现象的技术。

映射规则:
数据表→类
表字段→类属性
表数据→对象

MyBatis介绍

原始JDBC的操作问题分析
1.频繁创建和销毁数据库的连接会造成系统资源浪费从而影响系统性能。

​ 2.sql语询在代码中硬编码,如果要修改sql语询,就需要修改java代码,造成代码不易维护

​ 3.查询操作时, 需要手动将结果集中的数据封装到实体对象中。

​ 4.增删改查操作需要参数时，要手动将实体对象的数据设置到sq|语句的占位符。

原始JDBC的操作问题解决方案
1.使用数据库连接池初始化连接资源。
2.将sql语句抽取到配置文件中。
3.使用反射、内省等底层技术,将实体与表进行属性与字段的自动映射。

​ MyBatis是一-个优秀的基于Java的持久层框架,它内部封装了JDBC相关的操作 ,使开发者只需要关注SQL语询本身，而不需要花费精力去处理加载驱动、创建连接、创建执行者等复杂的操作。
​ MyBatis通过xml或注解的方式将要执行的各种Statement配置起来，并通过Java对象和Statement中SQL的动态参数进行映射生成最终要执行的SQL语句。
​ 最后MyBatis框架执行完SQL并将结果映射为Java对象并返回。采用ORM思想解决了实体和数据库映射的问题,对JDBC进行了封装，屏蔽了JDBCAPI底层访问细节,使我们不用与JDBCAPI打交道,就可以完成对数据库的持久化操作。

​ MyBatis官网: http://www.mybatis.org/mybatis-3/ N

入门程序

1.数据准备。

​ mysql里面的db0809pm数据库里面的student表

2.导入jar包。

将这两个jar包导入libs文件夹里面
image-20210812223257806

3.在src下创建映射配置文件。

StudentMapper.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="StudentMapper">
    <select id="selectAll" resultType="com.yy.Bean.Student">
        SELECT * FROM student
    </select>
</mapper>

4.在src下创建核心配置文件。

MyBatisConfig.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="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/db0809pm"/>
                <property name="username" value="root"/>
                <property name="password" value="2184021338"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="StudentMapper.xml"/>
    </mappers>
</configuration>

5.编写测试类完成相关API的使用。

package com.yy.dao;

import com.yy.Bean.Student;
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.Test;

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

/**
 * @author Marston
 * @date 2021/8/12
 */
public class StudentTest01 {

    //查询全部
    @Test
    public void selectAll() throws Exception{
        //1.加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
        //2.获取Sq1SessionI厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        //3.通过SqISession. I厂对象获取Sq1Session对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //4.执行映射配置文件中的sq1语句，并接收结果
        List<Student> list = sqlSession.selectList("StudentMapper.selectAll");
        //5.处理结果
        for(Student stu : list){
            System.out.println(stu);
        }
        //6.释放资源
        sqlSession.close();
        is.close();
    }
}

6.运行测试查看结果。

image-20210812223521399

小结

1.框架
框架是一款半成品软件,我们可以基于框架继续开发，从而完成一些个性化的需求。

2.ORM
对象关系映射,数据和实体对象的映射。

3.MyBatis
是一个优秀的基于Java的持久层框架，它内部封装了JDBC。
4.入门步骤
导jar包。
编写映射配置文件。
编写核心配置文件。
使用相应的API来完成编码。

Mybatis相关API

Resources

image-20210813102126963

SqlSessionFactoryBuilder

image-20210813102330098

SqlSessionFactory

image-20210813102552743

SqlSession*

image-20210813130451571

小结

●Resources
加载资源的工具类。
●SqISessionFactoryBuilder
获取SqISessionFactory工厂对象的功能类。
●SqISessionFactory
获取SqISession构建者对象的工厂接口。
指定事务的提交方式。
●SqISession
构建者对象接口。
执行SQL。
管理事务。
接口代理。

MyBatis映射配置文件

映射配置文件介绍

image-20210816195327551

StudentMapper.xml

配置文件的详细说明

参数如果为空会报错

<?xml version="1.0" encoding="UTF-8" ?>

<!--MyBatis的DTD约束-->
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--
    mapper：核心根标签
    namespace属性：名称空间    要想执行里面的sql语句必须
                            要借助与名称空间配合上id才能找到这条sql语句
-->
<mapper namespace="StudentMapper">
<!--
    select：查询功能的标签
    id属性：唯一标识，与名称空间配合使用
    resultType属性：指定结果映射对象类型
                    执行完下面的查询的sql语句会用一些数据，
                    而这些数据我们想要将他们封装到那个对象中，
                    就通过这个属性来进行指定
    parameterType属性：指定参数映射对象类型，也就是参数的参数
                    如果有where这些条件的话，就通过parameterType来指定所需要的参数类型
-->
    <select id="selectAll" resultType="com.yy.Bean.Student" parameterType="">
        SELECT * FROM student
    </select>
</mapper>

查询的功能

image-20210816074806629

 <select id="selectById" resultType="com.yy.Bean.Student" parameterType="java.lang.Integer">
        SELECT * FROM student WHERE id = #{id}
    </select>
        
        
@Test
public void selectById() throws Exception{
    //加载核心配置文件
    InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
    //获取sqlSession工厂对象
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    //通过工厂对象获取SqlSession对象
    SqlSession sqlSession = sqlSessionFactory.openSession();
    //执行映射配置文件的sql语句，并接受结果
    Student stu = sqlSession.selectOne("StudentMapper.selectById",3);
    //处理结果
    System.out.println(stu);
    sqlSession.close();
    is.close();
}

新增功能

image-20210816104552679

<!--    在parameterType里面传递过滤一个学生对象，如何从学生对象里面获取id、name、age等参数-->
<!--    因为它返回的是int数值，所以resultType可以不用写-->
    <insert id="insert" parameterType="com.yy.Bean.Student">
        INSERT INTO student VALUES (#{id},#{name},#{age},#{gender},#{score})
    </insert>

//新增功能
    @Test
    public void insert() throws Exception{
        //加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
        //获取SQLSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        //通过工厂对象获取SqlSession对象，不添加参数为true
        // ，默认为false需要手动提交（但是我刚刚测试不需要。。）
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //false也不需要添加事务，也能够将数据添加数据库。。
//        SqlSession sqlSession = sqlSessionFactory.openSession(false);
        //true也不需要添加事务，也能够将数据添加数据库。。
//        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        //执行映射文件的sql语句，并接受结果
        Student stu = new Student(10,"破朝",18,"男",99);
        int insert = sqlSession.insert("StudentMapper.insert",stu);

        //增删改需要多一步步骤，那就是提交事务（刚测试如果不添加参数，也不提交事务，也是能够添加进入数据库里面的
//        sqlSession.commit();

        //处理结果
        System.out.println(insert);
        //释放资源
        sqlSession.close();
        is.close();
    }

修改功能

image-20210816175811363

<update id="update" parameterType="com.yy.Bean.Student">
    UPDATE student SET name=#{name},age=#{age},gender=#{gender},score=#{score} WHERE id = #{id}
</update>

//修改
    public void update() throws Exception{
        //加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
        //获取SQLSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        //通过工厂对象获取SqlSession对象，不添加参数为true
        // ，默认为false需要手动提交（但是我刚刚测试不需要。。）
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //false也不需要添加事务，也能够将数据添加数据库。。
//        SqlSession sqlSession = sqlSessionFactory.openSession(false);
        //true也不需要添加事务，也能够将数据添加数据库。。
//        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        //执行映射文件的sql语句，并接受结果
        Student stu = new Student(10,"破朝",98,"男",99);
        int insert = sqlSession.update("StudentMapper.update",stu);

        //增删改需要多一步步骤，那就是提交事务（刚测试如果不添加参数，也不提交事务，也是能够添加进入数据库里面的
//        sqlSession.commit();

        //处理结果
        System.out.println(insert);
        //释放资源
        sqlSession.close();
        is.close();
    }

删除功能

image-20210816195136343

    <delete id="delete" parameterType="java.lang.Integer">
        DELETE FROM student WHERE id = #{id}
    </delete>
    
       //删除功能
    @Test
    public void delete() throws Exception{
        InputStream is = Resources.getResourceAsStream("MybatisConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        int result = sqlSession.delete("StudentMapper.delete", 10);
        sqlSession.commit();
        System.out.println(result);
        sqlSession.close();
        is.close();

    }

MyBatis核心配置文件

image-20210816201827650

介绍

<?xml version="1.0" encoding="UTF-8"   ?><!--XML文档说明-->
<!--MyBatis的DTD约束：对标签的约束以及相应的提示的功能-->
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--configuration：核心根标签-->
<configuration>
<!-- environments   配置数据库环境 ，环境可以有多高 default属性指定使用的是哪一个  -->
    <environments default="mysql"><!--default:指定是下面的哪一个数据库 -->
<!--     environment 配置数控环境 id属性代表唯一标识  -->
        <environment id="mysql">
<!--           transactionManager代表事务的管理 type属性，采用JDBC默认的事务处理 -->
            <transactionManager type="JDBC"></transactionManager>
<!--            dataSource 数据源的信息 type属性代表连接池-->
            <dataSource type="POOLED">
<!--             property 获取数据库连接的信息   -->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/db0809pm"/>
                <property name="username" value="root"/>
                <property name="password" value="2184021338"/>
            </dataSource>
        </environment>
    </environments>
<!--   mappers 代表引入映射配置文件 -->
    <mappers>
<!--        引入指定的映射配置文件  resource 属性指定映射配置文件的名称（路径）-->
        <mapper resource="StudentMapper.xml"/>
    </mappers>
</configuration>

数据库连接配置文件的引入

properties
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/db0809pm
username=root
password=2184021338

<?xml version="1.0" encoding="UTF-8"   ?><!--XML文档说明-->
<!--MyBatis的DTD约束：对标签的约束以及相应的提示的功能-->
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--configuration：核心根标签-->
<configuration>

    <!--    引入数据库连接的配置文件-->
    <properties resource="jdbc.properties"/>

<!-- environments   配置数据库环境 ，环境可以有多高 default属性指定使用的是哪一个  -->
    <environments default="mysql"><!--default:指定是下面的哪一个数据库 -->
<!--     environment 配置数控环境 id属性代表唯一标识  -->
        <environment id="mysql">
<!--           transactionManager代表事务的管理 type属性，采用JDBC默认的事务处理 -->
            <transactionManager type="JDBC"></transactionManager>
<!--            dataSource 数据源的信息 type属性代表连接池-->
            <dataSource type="POOLED">
<!--             property 获取数据库连接的信息   -->
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
<!--   mappers 代表引入映射配置文件 -->
    <mappers>
<!--        引入指定的映射配置文件  resource 属性指定映射配置文件的名称（路径）-->
        <mapper resource="StudentMapper.xml"/>
    </mappers>
</configuration>

image-20210816200802079

起别名

image-20210816201038481
image-20210816201407920

<!-MybatisConfig.xml  -->
<?xml version="1.0" encoding="UTF-8"   ?><!--XML文档说明-->
<!--MyBatis的DTD约束：对标签的约束以及相应的提示的功能-->
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--configuration：核心根标签-->
<configuration>

    <!--    引入数据库连接的配置文件-->
    <properties resource="jdbc.properties"/>

<!--    起别名-->
    <typeAliases>
        <typeAlias type="com.yy.Bean.Student" alias="student"/>
<!--        <package name="com.yy.Bean"/>-->
    </typeAliases>
 ......
</configuration>

<?xml version="1.0" encoding="UTF-8" ?>

<!--MyBatis的DTD约束-->
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--
    mapper：核心根标签
    namespace属性：名称空间    要想执行里面的sql语句必须
                            要借助与名称空间配合上id才能找到这条sql语句
-->
<mapper namespace="StudentMapper">
<!--
    select：查询功能的标签
    id属性：唯一标识，与名称空间配合使用
    resultType属性：指定结果映射对象类型
                    执行完下面的查询的sql语句会用一些数据，
                    而这些数据我们想要将他们封装到那个对象中，
                    就通过这个属性来进行指定
    parameterType属性：指定参数映射对象类型
                    如果有where这些条件的话，就通过parameterType来指定所需要的参数类型
-->
    <select id="selectAll" resultType="student">
        SELECT * FROM student
    </select>
    <select id="selectById" resultType="student" parameterType="int">
        SELECT * FROM student WHERE id = #{id}
    </select>
<!--    在parameterType里面传递过滤一个学生对象，如何从学生对象里面获取id、name、age等参数-->
<!--    因为它返回的是int数值，所以resultType可以不用写-->
    <insert id="insert" parameterType="student">
        INSERT INTO student VALUES (#{id},#{name},#{age},#{gender},#{score})
    </insert>

    <update id="update" parameterType="student">
        UPDATE student SET name=#{name},age=#{age},gender=#{gender},score=#{score} WHERE id = #{id}
    </update>

    <delete id="delete" parameterType="int">
        DELETE FROM student WHERE id = #{id}
    </delete>
</mapper>

MyBatis传统方式实现Dao层

package com.yy.mapper.Impl;

import com.yy.Bean.Student;
import com.yy.mapper.StudentMapper;
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;

/**
 * @author Marston
 * @date 2021/8/16
 */
public class StudentMapperImpl implements StudentMapper {
    @Override
    public List<Student> selectAll() {
        InputStream is = null;
        SqlSession sqlSession = null;
        List<Student> list = null;
        try{
            //加载核心配置文件
            is = Resources.getResourceAsStream("MyBatisConfig.xml");
            //获取SqlSession工厂对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
            //通过工厂对象，获取SqlSession对象
            sqlSession = sqlSessionFactory.openSession(true);
            //执行映射配置文件中的sql语句，并接收结果
            list = sqlSession.selectList("StudentMapper.selectAll");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //释放资源
            if (sqlSession != null){
                sqlSession.close();
            }
            if (is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        //返回结果
        return list;
    }

    @Override
    public Student selectById(Integer id) {
        InputStream is = null;
        SqlSession sqlSession = null;
        Student stu = null;
        try{
            //加载核心配置文件
            is = Resources.getResourceAsStream("MyBatisConfig.xml");
            //获取SqlSession工厂对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
            //通过工厂对象，获取SqlSession对象
            sqlSession = sqlSessionFactory.openSession(true);
            //执行映射配置文件中的sql语句，并接收结果
            stu = sqlSession.selectOne("StudentMapper.selectById",id);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //释放资源
            if (sqlSession != null){
                sqlSession.close();
            }
            if (is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        //返回结果
        return stu;
    }

    @Override
    public Integer insert(Student stu) {
        InputStream is = null;
        SqlSession sqlSession = null;
        Integer result = null;
        try{
            //加载核心配置文件
            is = Resources.getResourceAsStream("MyBatisConfig.xml");
            //获取SqlSession工厂对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
            //通过工厂对象，获取SqlSession对象
            sqlSession = sqlSessionFactory.openSession(true);
            //执行映射配置文件中的sql语句，并接收结果
            result = sqlSession.insert("StudentMapper.insert",stu);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //释放资源
            if (sqlSession != null){
                sqlSession.close();
            }
            if (is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        //返回结果
        return result;
    }

    @Override
    public Integer update(Student stu) {
        InputStream is = null;
        SqlSession sqlSession = null;
        Integer result = null;
        try{
            //加载核心配置文件
            is = Resources.getResourceAsStream("MyBatisConfig.xml");
            //获取SqlSession工厂对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
            //通过工厂对象，获取SqlSession对象
            sqlSession = sqlSessionFactory.openSession(true);
            //执行映射配置文件中的sql语句，并接收结果
            result = sqlSession.update("StudentMapper.update",stu);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //释放资源
            if (sqlSession != null){
                sqlSession.close();
            }
            if (is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        //返回结果
        return result;
    }

    @Override
    public Integer delete(Integer id) {
        InputStream is = null;
        SqlSession sqlSession = null;
        Integer result = null;
        try{
            //加载核心配置文件
            is = Resources.getResourceAsStream("MyBatisConfig.xml");
            //获取SqlSession工厂对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
            //通过工厂对象，获取SqlSession对象
            sqlSession = sqlSessionFactory.openSession(true);
            //执行映射配置文件中的sql语句，并接收结果
            result = sqlSession.delete("StudentMapper.delete",id);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //释放资源
            if (sqlSession != null){
                sqlSession.close();
            }
            if (is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        //返回结果
        return result;
    }
}




package com.yy.Service.Impl;

import com.yy.Bean.Student;
import com.yy.Service.StudentService;
import com.yy.mapper.Impl.StudentMapperImpl;
import com.yy.mapper.StudentMapper;

import java.util.List;

/**
 * @author Marston
 * @date 2021/8/16
 */
public class StudentServiceImpl implements StudentService {
    //创建持久层对象
    private StudentMapper mapper = new StudentMapperImpl();

    @Override
    public List<Student> selectAll() {
        return mapper.selectAll();
    }

    @Override
    public Student selectById(Integer id) {
        return mapper.selectById(id);
    }

    @Override
    public Integer insert(Student stu) {
        return mapper.insert(stu);
    }

    @Override
    public Integer update(Student stu) {
        return mapper.update(stu);
    }

    @Override
    public Integer delete(Integer id) {
        return mapper.delete(id);
    }
}


package com.yy.controller;

import com.yy.Bean.Student;
import com.yy.Service.Impl.StudentServiceImpl;
import com.yy.Service.StudentService;
import org.junit.Test;
import org.w3c.dom.ls.LSOutput;

import java.util.List;

/**
 * @author Marston
 * @date 2021/8/16
 */
public class StudentController {
    //创建业务层对象
    private StudentService service = new StudentServiceImpl();

    //查询全部功能测试
    @Test
    public void selectAll(){
        List<Student> students = service.selectAll();
        for(Student stu : students){
            System.out.println(stu);
        }
    }

    @Test
    public void selectById(){
        Student stu = service.selectById(3);
        System.out.println(stu);
    }
    @Test
    public void insert(){
        Student stu = new Student(10,"破朝",18,"男",99);
        Integer result = service.insert(stu);
        System.out.println(result);
    }
    @Test
    public void update(){
        Student stu = new Student(10,"破朝",88,"男",99);
        Integer result = service.update(stu);
        System.out.println(result);
    }
    @Test
    public void delete(){
        Integer result = service.delete(10);
        System.out.println(result);
    }



}

image-20210816205122273

LOG4J

在日常开发过程中,排查问题时难免需要输出MyBatis真正执行的SQL语询、参数、结果等信息,我们就可以借助LOG4J的功能来实现执行信息的输出。

image-20210816213103950

image-20210816213214497

image-20210816213038731

?abc!
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Mybatis创建一套规则以XML为载体映射SQL，你见过？
如果频繁就私信一下呢
09-29 209
简介 除了配置相关之外，另一个核心就是SQL映射，MyBatis 的真正强大也在于它的映射语句。Mybatis创建了一套规则以XML为载体映射SQL 之前提到过，各项配置信息将Mybatis应用的整体框架搭建起来，而映射部分则是准备了一次SQL操作所需的信息 一次SQL执行的主要事件是什么？ 输入参数解析，绝大多数SQL都是需要参数的 SQL，通过SQL与数据库交互，所以最根本的是SQL，如果连SQL都没有，还扯个蛋蛋？ 结果映射，Mybatis可以帮我们完成字段与Java类型的映射 所以
1:mybatis入门准备
Hhytyq的博客
04-09 190
1:三层架构 表现层: 是用于展示数据的 业务层 是处理业务需求的 持久层 是和数据库交互的 2:持久层技术解决方案 JDBC技术 Connection PreparedStatement ResultSt Spring的JdbcTemplate spring对jdbc的简单封装 Apache的DBUti...
mysql映射文件_java框架之mybatis（SQL映射文件）
weixin_42503757的博客
02-02 161
MyBatis真正的强大在于映射语句，专注于SQL，功能强大，SQL映射的配置却是相当简单SQL映射文件的几个顶级元素(按照定义的顺序)mapper-namespacecache-配置给定命名空间的缓存cache-ref - 从其他命名空间引用缓存配置resultMap -用来描述数据库结构集和对象的对应关系sql -可以重用的SQL块，也可以被其他语句引用insert - 映射插入语句updat...
Mybatis入门程序的详细教程
qq_45646289的博客
12-22 1344
Mybatis入门程序 一、资源的准备 1、mybatis的jar包 通过访问mybatis的官网下载相关的jar包。 mybatis官网 2、mysql连接的jar包 可以根据自己的版本导入合适的jar包 二、创建项目 1、创建普通的java项目，导入好准备好的jar包 项目的目录结构如下： 2、数据库的创建表（这里直接用图形化界面建立表） 三、编写代码 1、创建实体类（由于没用用到Hash...
MyBatis基础使用(上)
weixin_43939924的博客
03-29 128
Mybatis-01 1. 框架 ​ 框架相当于是一个脚手架，内部已经写好了很多代码，我们只要其基础上进行开发就可以提高我们的开发效率。 2.Mybatis介绍 MyBatis 是一款优秀的持久层框架。 MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。 官网：https://mybatis.org/mybatis-3/zh/# 3. 快速入门 ①数据准备 CREATE DATABASE /*!32312 IF NOT EXISTS*/`mybatis_db`
mybatis-generator-core自动生成实体类、dao接口和mapping映射文件
03-23
利用mybatis-generator-core可以自动生成实体类、dao接口和mapping映射文件，里头也提供了使用说明： 1、进入lib文件夹里头。 2、修改generatorConfig.xml配置 主要修改数据库地址，用户名，密码，以及数据库名称，...
mybatis-generator-core生成数据库表与对象sql映射
07-14
mybatis-generator-core生成sql、对象、dao等Java文件。可以直接使用
mybatis-generator自动生成代码 （全部文件）
06-07
使用MyBatis Generator 自动生成Dao、Bean、Mapping。将mysql数据库中的表转换为java中的实体类，接口，和映射文件
MyBatis学习---使用MyBatis_Generator生成Dto、Dao、Mapping
05-07
由于MyBatis属于一种半自动的ORM框架，所以主要的工作将是书写Mapping映射文件，但是由于手写映射文件很容易出错，所以查资料发现有现成的工具可以自动生成底层模型类、Dao接口类甚至Mapping映射文件。
mybatis-mysql-generator
07-13
最近用到了比较流行SSM开源框架，标准的MVC设计...主要是配置Mapping映射文件，但是由于手写配置Mapping映射文件容易出错，所以可以利用MyBatis生成器自动生成实体类、DAO接口、Mapping映射文件，这样可以节省很多时间
Mybatis核心配置文件概述、相应API
折叠伞的博客
02-12 522
Mybatis的增删改查 <!--User Mapper.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="userMapper"> <!--删除操作
3、建立核心配置文件和映射文件模板
weixin_48312484的博客
07-14 152
在搭建MyBatis框架时，我们要建立核心配置文件和映射文件，如果每次都从官方文档拷贝比较麻烦，这里直接将其建立模板方便后续使用。 打开设置：
【MyBatis】【相关API 、配置映射文件、核心配置文件、传统方式实现Dao层】
qq_41440031的博客
02-27 671
Mybatis相关的API org.aoache.ibatis.io.Resources：加载资源工具类。 org.aoache.ibatis.session.SqlSessionFactoryBuilder：获取SqlSessionFactory工厂对象的功能类。 org.aoache.ibatis.session.SqlSessionFactory：获取SqlSession构建这对象的工厂接口。 org.aoache.ibatis.session.SqlSession：构建者对象.
MyBatis关联映射之表一对一关系的实现
沐晨的博客
04-14 349
文章目录前言一、关系1.1 类与类的关系1.2 对象与对象的关系二、关联映射使用步骤三、一对一的实现3.1 设计表3.2 设计实体类1.设计实体类方法2.设计类Person.java实体类Card.java实体类3.3 编写映射文件1.CardMapper接口2.CardMapper.xml3.EmployeeMapper接口4.EmployeeMapper.xml四、一对多的实现4.1 设计表4.2 设计实体类1.设计实体类方法2.设计类Student持久化实体类Clazz持久化实体类4.3 编写映射文件
Mybatis创建dao接口、Mybatis主配置文件、创建映射配置文件
韦恩少爷的博客
02-07 1494
初学Mybatis Part 2 创建dao接口、Mybatis主配置文件、创建映射配置文件 接续Part1 我们已经创建maven工程并导入坐标 接下来 一、创建实体类和dao的接口 1.创建的实体类 public class User implements Serializable{ private Integer id; private String username; ...
Mybatis学习笔记
asd747571569的博客
06-15 1153
MyBatis 1. MyBatis简介 1.1 什么是MyBatis？ MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。 MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。 MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。 MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目
Mybatis的mapper文件和全局配置文件详解
qq_41931364的博客
01-26 4788
Mybatis的Mapper文件和全局配置文件详解1、mapper文件2、mybatis配置文件3、测试类 1、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"> <!-- mapp
【Java】——MyBatis 中mapper.xml的语法
热门推荐
汤庆
01-29 1万+
一、前言 MyBatis是"半自动"的ORM框架，即SQL语句需要开发者自定义，MyBatis的关注点在POJO与SQL之间的映射关系。那么SQL语句在哪里配置自定义呢？就在Mapper.xml中配置。当然了该配置文件可以自定义文件名。文件的样式如下： <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" > <mappe..
myBatis入门程序介绍
guoyp2126的博客
10-14 892
前言 Mybaits框架也称为对象关系映射（ORM）框架，它通过描述java对象与数据库表之间映射关系，自动的将java应用程序中的对象持久化到关系型数据库中。这些功能的完成主要依赖两种配置文件，主配置文件（通常叫做：mybaits-config.xml）和完成关系与对象映射文件（一般为Mapper.xml）,前者主要目的是告诉框架，要创建一个什么样数据库会话（包括：数据库连接信息、是否使用二级缓存、连接池、懒加载、mapper文件位置等）；后者则具体处理数据库表与对象映射关系和数据的持久化问题。 myBa
mybatis-plus-code-generator-3.5.2.x.jar
最新发布
07-14
通过使用mybatis-plus-code-generator-3.5.2.x.jar工具，开发者可以根据数据库中的表结构自动生成对应的实体类、Mapper接口以及SQL映射文件，并且可以自定义生成规则，灵活地生成满足自己需求的代码。这样，开发者就...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

?abc!

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

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

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

打赏作者

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

抵扣说明：

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

余额充值