1. Mybatis的介绍和基本使用

最新推荐文章于 2024-03-28 08:41:17 发布
最新推荐文章于 2024-03-28 08:41:17 发布
阅读量190 收藏
点赞数
分类专栏： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hanzong110/article/details/106794572
版权

1 数据库操作框架的历程

1.1 JDBC
  1. JDBC(Java Data Base Connection，java数据库连接)是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。JDBC提供了一种基准，据此可以构建更高级的工具和接口，使数据库开发人员能够编写数据库应用程序
  2. 优点：运行期：快捷、高效
  3. 缺点：编辑期：代码量大、繁琐异常处理、不支持数据库跨平台
    在这里插入图片描述
1.2 DBUtils
  1. DBUtils是Java编程中的数据库操作实用工具，小巧简单实用
  2. DBUtils封装了对JDBC的操作，简化了JDBC操作，可以少写代码
  3. DBUtils三个核心功能介绍
    1. QueryRunner中提供对sql语句操作的API
    2. ResultSetHandler接口，用于定义select操作后，怎样封装结果集
    3. DBUtils类，它就是一个工具类，定义了关闭资源与事务处理的方法
1.3 Hibernate
  1. Hibernate 是由 Gavin King 于 2001 年创建的开放源代码的对象关系框架。它强大且高效的构建具有关系对象持久性和查询服务的 Java 应用程序
  2. Hibernate 将 Java 类映射到数据库表中，从 Java 数据类型中映射到 SQL 数据类型中，并把开发人员从 95% 的公共数据持续性编程工作中解放出来
  3. Hibernate 是传统 Java 对象和数据库服务器之间的桥梁，用来处理基于 O/R 映射机制和模式的那些对象。

在这里插入图片描述

1.3.1 Hibernate优点
  1. Hibernate 使用 XML 文件来处理映射 Java 类别到数据库表格中，并且不用编写任何代码
  2. 为在数据库中直接储存和检索 Java 对象提供简单的 APIs
  3. 如果在数据库中或任何其它表格中出现变化，那么仅需要改变 XML 文件属性
  4. 抽象不熟悉的 SQL 类型，并为我们提供工作中所熟悉的 Java 对象
  5. Hibernate 不需要应用程序服务器来操作
  6. 操控你数据库中对象复杂的关联
  7. 最小化与访问数据库的智能提取策略
  8. 提供简单的数据询问
  9. 数据移植性强
1.3.2 Hibernate缺点
  1. 过度工程化，性能较差，难以优化
  2. 学习难度较大
  3. 无法进行细致操作，例如减少查询出的列数
  4. 缓存机制不如redis
  5. 寻找bug困难
  6. 批量数据操作需要大量的内存空间而且执行过程中需要的对象太多
1.4 JDBCTemplate
  1. JdbcTemplate针对数据查询提供了多个重载的模板方法，你可以根据需要选用不同的模板方法。如果你的查询很简单，仅仅是传入相应SQL或者相关参数，然后取得一个单一的结果，那么你可以选择如下一组便利的模板方法
  2. 优点：运行期：高效、内嵌Spring框架中、支持基于AOP的声明式事务
  3. 缺点：必须于Spring框架结合在一起使用、不支持数据库跨平台、默认没有缓存

2 Mybatis

  1. MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来将原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）映射成数据库中的记录
  2. 优点
    1. 与JDBC相比，减少了50%的代码量
    2. 最简单的持久化框架，简单易学
    3. SQL代码从程序代码中彻底分离出来，可以重用
    4. 提供XML标签，支持编写动态SQL
    5. 提供映射标签，支持对象与数据库的ORM字段关系映射：
      1. O就是Object，即java对象
      2. R表示关系，其实就是数据库中的表
      3. M表示他们之间的映射关系
  3. 缺点
    1. SQL语句编写工作量大，熟练度要高
    2. 数据库移植性比较差，如果需要切换数据库的话，SQL语句会有很大的差异

3 第一个Mybatis项目

  1. 创建普通的maven项目
  2. 添加pom依赖
<?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>org.example</groupId>
    <artifactId>mybatis</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.4</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/log4j/log4j -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>

    </dependencies>

</project>
  1. 创建对应的数据表
--oracle
create table emp select * from scott.emp;

--mysql
/*
 Navicat Premium Data Transfer

 Source Server         : MySQL
 Source Server Type    : MySQL
 Source Server Version : 50562
 Source Host           : localhost:3306
 Source Schema         : test

 Target Server Type    : MySQL
 Target Server Version : 50562
 File Encoding         : 65001

 Date: 15/06/2019 11:21:30
*/

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for dept
-- ----------------------------
DROP TABLE IF EXISTS `dept`;
CREATE TABLE `dept`  (
  `deptno` int(2) NOT NULL,
  `dname` varchar(15) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `loc` varchar(15) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  PRIMARY KEY (`deptno`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

-- ----------------------------
-- Records of dept
-- ----------------------------
INSERT INTO `dept` VALUES (10, 'ACCOUNTING', 'NewYork');
INSERT INTO `dept` VALUES (20, 'RESEARCH', 'Dallas');
INSERT INTO `dept` VALUES (30, 'SALES', 'Chicago');
INSERT INTO `dept` VALUES (40, 'OPERATIONS', 'Boston');

-- ----------------------------
-- Table structure for emp
-- ----------------------------
DROP TABLE IF EXISTS `emp`;
CREATE TABLE `emp`  (
  `empno` int(4) NOT NULL COMMENT '雇员编号',
  `ename` varchar(10) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `job` varchar(10) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `mgr` int(4) NULL DEFAULT NULL,
  `hiredate` date NULL DEFAULT NULL,
  `sal` decimal(7, 0) NULL DEFAULT NULL,
  `comm` decimal(7, 0) NULL DEFAULT NULL,
  `deptno` int(2) NULL DEFAULT NULL,
  PRIMARY KEY (`empno`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

-- ----------------------------
-- Records of emp
-- ----------------------------
INSERT INTO `emp` VALUES (7369, 'SMITH', 'CLERK', 7902, '1980-12-17', 800, NULL, 20);
INSERT INTO `emp` VALUES (7499, 'ALLEN', 'SALESMAN', 7698, '1981-02-20', 1600, 300, 30);
INSERT INTO `emp` VALUES (7521, 'WARD', 'SALESMAN', 7698, '1981-02-22', 1250, 500, 30);
INSERT INTO `emp` VALUES (7566, 'JONES', 'MANAGER', 7839, '1981-04-02', 2975, NULL, 20);
INSERT INTO `emp` VALUES (7654, 'MARTIN', 'SALESMAN', 7698, '1981-09-28', 1250, 1400, 30);
INSERT INTO `emp` VALUES (7698, 'BLAKE', 'MANAGER', 7839, '1981-05-01', 2850, NULL, 30);
INSERT INTO `emp` VALUES (7782, 'CLARK', 'MANAGER', 7839, '1981-06-09', 2450, NULL, 10);
INSERT INTO `emp` VALUES (7788, 'SCOTT', 'ANALYST', 7566, '1987-07-13', 3000, NULL, 20);
INSERT INTO `emp` VALUES (7839, 'KING', 'PRESIDENT', NULL, '1981-11-17', 5000, NULL, 10);
INSERT INTO `emp` VALUES (7844, 'TURNER', 'SALESMAN', 7698, '1981-09-08', 1500, 0, 30);
INSERT INTO `emp` VALUES (7876, 'ADAMS', 'CLERK', 7788, '1987-07-13', 1100, NULL, 20);
INSERT INTO `emp` VALUES (7900, 'JAMES', 'CLERK', 7698, '1981-12-03', 950, NULL, 30);
INSERT INTO `emp` VALUES (7902, 'FORD', 'ANALYST', 7566, '1981-12-03', 3000, NULL, 20);
INSERT INTO `emp` VALUES (7934, 'MILLER', 'CLERK', 7782, '1982-01-23', 1300, NULL, 10);

-- ----------------------------
-- Table structure for salgrade
-- ----------------------------
DROP TABLE IF EXISTS `salgrade`;
CREATE TABLE `salgrade`  (
  `grade` int(7) NULL DEFAULT NULL,
  `losal` int(7) NULL DEFAULT NULL,
  `hisal` int(7) NULL DEFAULT NULL
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

-- ----------------------------
-- Records of salgrade
-- ----------------------------
INSERT INTO `salgrade` VALUES (1, 700, 1200);
INSERT INTO `salgrade` VALUES (2, 1201, 1400);
INSERT INTO `salgrade` VALUES (3, 1401, 2000);
INSERT INTO `salgrade` VALUES (4, 2001, 3000);
INSERT INTO `salgrade` VALUES (5, 3001, 9999);

SET FOREIGN_KEY_CHECKS = 1;
  1. Emp.java：表对应的实体类对象
package com.mashibing.bean;

import java.util.Date;

public class Emp {

    private Integer empno;
    private String ename;
    private String job;
    private Integer mgr;
    private Date hiredate;
    private Double sal;
    private Double common;
    private Integer deptno;

    public Emp() {
    }
	
	public Emp(Integer empno, String ename) {
        this.empno = empno;
        this.ename = ename;
    }
    
    public Emp(Integer empno, String ename, String job, Integer mgr, Date hiredate, Double sal, Double common, Integer deptno) {
        this.empno = empno;
        this.ename = ename;
        this.job = job;
        this.mgr = mgr;
        this.hiredate = hiredate;
        this.sal = sal;
        this.common = common;
        this.deptno = deptno;
    }

    public Integer getEmpno() {
        return empno;
    }

    public void setEmpno(Integer empno) {
        this.empno = empno;
    }

    public String getEname() {
        return ename;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    public Integer getMgr() {
        return mgr;
    }

    public void setMgr(Integer mgr) {
        this.mgr = mgr;
    }

    public Date getHiredate() {
        return hiredate;
    }

    public void setHiredate(Date hiredate) {
        this.hiredate = hiredate;
    }

    public Double getSal() {
        return sal;
    }

    public void setSal(Double sal) {
        this.sal = sal;
    }

    public Double getCommon() {
        return common;
    }

    public void setCommon(Double common) {
        this.common = common;
    }

    public Integer getDeptno() {
        return deptno;
    }

    public void setDeptno(Integer deptno) {
        this.deptno = deptno;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "empno=" + empno +
                ", ename='" + ename + '\'' +
                ", job='" + job + '\'' +
                ", mgr=" + mgr +
                ", hiredate=" + hiredate +
                ", sal=" + sal +
                ", common=" + common +
                ", deptno=" + deptno +
                '}';
    }
}
  1. EmpDao.java：进行数据库操作的dao层接口
package com.mashibing.dao;

import com.mashibing.bean.Emp;

public interface EmpDao {

    public Emp findEmpByEmpno(Integer empno);
    
}
  1. mybatis-config.xml：resources下建立配置文件
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <environments default="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://localhost:3306/demo?serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="c50hst"/>
            </dataSource>
        </environment>
    </environments>
    <!--引入每一个接口对应点xml文件-->
    <mappers>
        <mapper resource="EmpDao.xml"/>
    </mappers>
</configuration>
  1. EmpDao.xml：resource下建立映射文件，注意这个文件名要和Dao层的类名相同，我们不必自己再写Dao层的具体实现
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--1. namespace：Dao接口的全限定类名，就是告诉要实现该配置文件是哪个接口的具体实现-->
<!--
8. DTD=类型定义(Documnet Type Definition)
9. XSD=XML结构定义 ( XML Schemas Definition )
-->
<mapper namespace="com.mashibing.dao.EmpDao">
    <!--
    2. select:表示这个操作是一个查询操作
    3. id表示的是要匹配的方法的名称
    4. resultType:表示返回值的类型，查询操作必须要包含返回值的类型
    5. #{属性名}：表示要传递的参数的名称
    -->
    <select id="findEmpByEmpno" resultType="com.mashibing.bean.Emp">
        select * from emp where empno = #{empno}
  </select>
</mapper>
  1. log4j.properties：类路径上添加
# Global logging configuration
log4j.rootLogger=ERROR, stdout
# MyBatis logging configuration...
log4j.logger.com.mashibing=TRACE
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n
  1. MyTest.java：测试类
package com.mashibing.test;

import com.mashibing.bean.Emp;
import com.mashibing.dao.EmpDao;
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.IOException;
import java.io.InputStream;

public class MyTest {

    @Test
    public void test01() {
        // 1. 根据全局配置文件创建出SqlSessionFactory：负责创建SqlSession对象的工厂
        // 2. SqlSession：表示跟数据库建议的一次会话
        String resource = "mybatis-config.xml";
        InputStream inputStream = null;
        try {
            inputStream = Resources.getResourceAsStream(resource);
        } catch (IOException e) {
            e.printStackTrace();
        }
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        Emp empByEmpno = null;
        try {
            // 3. 获取要调用的接口类，此处实际上是通过jdk的动态代理得到的实现类
            EmpDao mapper = sqlSession.getMapper(EmpDao.class);
            empByEmpno = mapper.findEmpByEmpno(7369);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            sqlSession.close();
        }
        System.out.println(empByEmpno);
    }
}

4 增删改查的基本操作

  1. EmpDao.java
package com.mashibing.dao;

import com.mashibing.bean.Emp;

public interface EmpDao {

    public Emp findEmpByEmpno(Integer empno);

    public int updateEmp(Emp emp);

    public int deleteEmp(Integer empno);

    public int insertEmp(Emp emp);

}
  1. EmpDao.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.mashibing.dao.EmpDao">
    <select id="findEmpByEmpno" resultType="com.mashibing.bean.Emp">
        select * from emp where empno = #{empno}
    </select>
    <!--1. 增删改操作不需要返回值，返回的是影响的行数，mybatis会自动做判断-->
    <insert id="insertEmp">
        insert into emp(empno,ename) values(#{empno},#{ename})
    </insert>
    <update id="updateEmp">
        update emp set ename=#{ename} where empno = #{empno}
    </update>
    <delete id="deleteEmp">
        delete from emp where empno = #{empno}
    </delete>
</mapper>
  1. MyTest.java
package com.mashibing.test;

import com.mashibing.bean.Emp;
import com.mashibing.dao.EmpDao;
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.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;

public class MyTest {
    SqlSessionFactory sqlSessionFactory = null;
    @Before
    public void init(){
        String resource = "mybatis-config.xml";
        InputStream inputStream = null;
        try {
            inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory= new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    @Test
    public void test01() {

        // 获取数据库的会话
        SqlSession sqlSession = sqlSessionFactory.openSession();
        Emp empByEmpno = null;
        try {
            // 获取要调用的接口类
            EmpDao mapper = sqlSession.getMapper(EmpDao.class);
            // 调用方法开始执行
            empByEmpno = mapper.findEmpByEmpno(7369);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            sqlSession.close();
        }
        System.out.println(empByEmpno);
    }

    @Test
    public void test02(){
        SqlSession sqlSession = sqlSessionFactory.openSession();
        EmpDao mapper = sqlSession.getMapper(EmpDao.class);
        int zhangsan = mapper.insertEmp(new Emp(1111, "zhangsan"));
        System.out.println(zhangsan);
        //1. 默认是开启事务的，所以必须commit，也可以在openSession中传入参数从而开启或关闭事务
        sqlSession.commit();
        sqlSession.close();
    }

    @Test
    public void test03(){
        SqlSession sqlSession = sqlSessionFactory.openSession();
        EmpDao mapper = sqlSession.getMapper(EmpDao.class);
        int zhangsan = mapper.updateEmp(new Emp(1111, "lisi"));
        System.out.println(zhangsan);
        sqlSession.commit();
        sqlSession.close();
    }

    @Test
    public void test04(){
        SqlSession sqlSession = sqlSessionFactory.openSession();
        EmpDao mapper = sqlSession.getMapper(EmpDao.class);
        int zhangsan = mapper.deleteEmp(1111);
        System.out.println(zhangsan);
        sqlSession.commit();
        sqlSession.close();
    }
}

5 注解的写法

  1. mybatis支持使用注解的方式，可以不用写配置文件，但如果sql非常复杂，还是建议写配置文件
  2. EmpDaoAnnotation.java
package com.mashibing.dao;

import com.mashibing.bean.Emp;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

public interface EmpDaoAnnotation {

    @Select("select * from emp where empno = #{empno}")
    public Emp findEmpByEmpno(Integer empno);

    @Update("update emp set ename=#{ename} where empno = #{empno}")
    public int updateEmp(Emp emp);

    @Delete("delete from emp where empno = #{empno}")
    public int deleteEmp(Integer empno);

    @Insert("insert into emp(empno,ename) values(#{empno},#{ename})")
    public int insertEmp(Emp emp);

}
  1. mybatis-config.xml
<mappers>
    <mapper resource="EmpDao.xml"/>
    <mapper class="com.mashibing.dao.EmpDaoAnnotation"/>
</mappers>
  1. 测试代码
@Test
public void test06(){
    SqlSession sqlSession = sqlSessionFactory.openSession();
    EmpDaoAnnotation mapper = sqlSession.getMapper(EmpDaoAnnotation.class);
    int zhangsan = mapper.insertEmp(new Emp(1111, "zhangsan"));
    System.out.println(zhangsan);
    //1. 默认是开启事务的，所以必须commit，也可以在openSession中传入参数从而开启或关闭事务
    sqlSession.commit();
    sqlSession.close();
}

6 配置文件详解

  1. 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">
<!--1. 填写标签时，需要注意相关配置的顺序，顺序写错加载也会失败-->
<configuration>
    <!--1. 引入外部配置文件，类似于Spring中的property-placeholder
            1. resource：从类路径引入，如果用的是idea，指resources资源目录下配置文件
            2. url：从磁盘路径或者网络路径引入-->
    <properties resource="db.properties"></properties>
    <!--1. settings：用来控制mybatis运行时的行为，是mybatis中的重要配置，官网有其子标签的各种值的具体含义-->
    <settings>
        <!--1. 设置列名映射的时候是否使用驼峰标识，不设置时，表与实体类映射关系为：表中列名与实体类中属性名一一对应
            2. 如果表中列明与属性名不同，例如user_id与userId，会导致映射不上，无法将查出数据放入到指定对象中
            3. 开启该标识，默认使用表中a_col列与实体类中aCol属性名进行映射-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
    <!--1. typeAliases：表示为我们引用的实体类起别名，默认情况下，在EmpDao.xml中，resultType处我们需要写类的完全限定名
		2. 配置上后就可以使用此处配置的别名替代，使用的时候可以忽略大小写
        3. 还可以通过alias属性来表示类的别名
        4. 一般不怎么使用，因为没有必要，而且使用别名后，在EmpDao.xml处就无法直接点入该类，不方便查看-->
    <typeAliases>
        <!--<typeAlias type="com.mashibing.bean.Emp" alias="Emp"></typeAlias>-->
        <!--1. 如果需要引用多个类，那么给每一个类起别名肯定会很麻烦，因此可以指定对应的包名，可以指定具体的包来保证实体类不需要写完全限定名-->
        <package name="com.mashibing.bean"/>
    </typeAliases>
    <!--1. 设置定义自己的类型处理器，类型处理器是用于将数据库中内容转换为java中的某种类型用的，mybatis中默认内置了很多类型处理器，一般不需要自己实现-->
    <typeHandlers>
        <typeHandler handler=""></typeHandler>
        <package name=""/>
    </typeHandlers>
    <!--1. 当需要自定义对象工厂时，实现此标签，完成结果集到java对象实例化的过程，就是如何将表中一条数据转为一个java中对象，一般不需要自己实现，底层使用反射实现-->
    <objectFactory type=""></objectFactory>
    <!--1. 设置插件，最常用的是pageHelper，是mybatis的分页插件-->
    <plugins>
        <plugin interceptor=""></plugin>
    </plugins>
    <!--
    1. 在实际的开发过程中，我们可能分为开发环境，生产环境，测试环境等等，每个环境的配置可以是不一样的，比如不同环境配置不同数据源
    2. environments就用来表示不同环境的细节配置，每一个环境中都需要一个事务管理器以及数据源的配置
    3. 我们在后续的项目开发中几乎都是使用spring中配置的数据源和事务管理器来配置，此处不需要研究
    -->
    <!--4. default:用来选择哪个环境作为运行时环境-->
    <environments default="development">
        <!--1. environment：配置具体的环境属性-->
        <!--2. id：表示不同环境的名称-->
        <environment id="development">
            <!--transactionManager：配置事务管理器，type表示事务管理器的类型
			    1. jdbc：表示使用jdbc原生的事务配置
			    2. managed：什么都没做-->
            <transactionManager type="JDBC"/>
            <!--1. 配置数据库连接-->
            <!--2. 配置具体数据源类型，type：表示数据源类型
			        1. pooled：使用数据库连接池
			        2. unpooled：每次都打开关和关闭一个连接-->
            <dataSource type="POOLED">
                <!--1. 使用${}来引入外部变量，如果为连接池，还可以设置连接最大个数等相关信息-->
                <property name="driver" value="${driverClassname}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    <!--1. databaseIdProvider：数据库厂商标识，在不同的数据库中，可能sql语句的写法是不一样的，为了增强移植性，可以提供不同数据库的操作实现
        2. 在编写不同的sql语句的时候，可以指定databaseId属性来标识当前sql语句可以运行在哪种数据库中
            <select id="findEmpByEmpno" resultType="com.mashibing.bean.Emp" databaseId="mysql">
                select * from emp where empno = #{empno}
            </select>
            <select id="findEmpByEmpno" resultType="com.mashibing.bean.Emp" databaseId="orcl">
                select * from emp where empno = #{empno}
            </select>
	    3. type必须写DB_VENDOR，DB_VENDOR实现会将mybatis自身的databaseId设置为，数据库产品名与property中name第一个相匹配的值，如果没有匹配属性，将设置为null
    -->
    <databaseIdProvider type="DB_VENDOR">
        <property name="MySQL" value="mysql"/>
        <property name="SQL Server" value="sqlserver"/>
        <property name="Oracle" value="orcl"/>
    </databaseIdProvider>
    <!--1. mappers：用来在程序启动时，对映射文件进行加载，需要注意，所有映射文件，都必须加入到mybatis-config.xml文件中-->
    <mappers>
        <!--1. class:本质上还是找xml文件，只不过会到class所在路径下找与class同名的xml文件，对于注解的方式，由于没有xml文件，所以必须使用class这种方式
						2. 需要填写接口的全限定类名
            <mapper class="com.mashibing.dao.EmpDaoAnnotation"></mapper>
                1. 如果不想用注解，也可以将xml文件放在dao接口的同级目录下，文件名与dao接口名相同
                2. 如果是maven构建项目，由于maven只会自动编译java文件，不会编译xml文件，会导致xml文件无法进入项目真正的target文件夹中
                    1. 可以在resources资源目录下，建立和dao层一样的同级目录，将xml配置文件放到该目录中
                    2. 也可以在pom.xml中进行如下设置，表示编译java文件的同时，也编译xml文件
                    3. 经过以上两者之一的配置后，target文件夹中，才会在EmpDao.class同级目录下生成EmpDao.xml
                    <build>
                        <resources>
                            <resource>
                                <directory>src/main/java</directory>
                                <includes>
                                    <include>**/*.xml</include>
                                </includes>
                            </resource>
                        </resources>
                    </build>
            2. url：从磁盘或者网络路径查找sql映射文件
            3. resource：在类路径下寻找sql映射文件
                <mapper resource="EmpDao.xml"/>
            4. package：相当于批量注册多个class，因此class配置时需要注意的点，package也需要注意-->
        <package name="com.mashibing.dao"/>
    </mappers>
</configuration>
含低调
关注
专栏目录
Mybatis---1、介绍
辛聪明的博客
09-04 123
1、介绍 MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。 MyBatis是一个优秀的持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注 SQL 本身，而不需要花费精力去处理...
1.mybatis介绍,以及如何使用
Aeiou.a1的博客
04-27 220
什么是mybatis? mybatis能做什么? mybtias如何使用? 介绍: 什么是框架? 是软件卡法中的一套解决方案,不同框架解决的是不同的问题 使用框架的好处在于: 框架封装了很多的细节,使开发者可以使用即简单的方式实现功能,大大提高了开发效率. 三层架构(SSM)? 2.1 表现层:? S 是用于展现数据的 2.2 业务层:? S 是处理业务需求的 2.3 持久层:? M 是和数据库交互的 持久层技术解决方案 JDBC技术 Connection PreparedSt.
1、MyBatis简介
cxycxytony的博客
07-06 161
1、MyBatis简介 1.1、什么是MyBatis Mybatis是一款优秀的持久层框架 它支持定制化SQL MyBatis避免了所有的JDBC代码和手动设置参数以及获取结果集 Mybatis可以使用简单的XML或注解来配置和映射原生类型、接口和Java的POJO（Plain Old Java Objects，普通老式Java对象）为数据库中的记录。 MyBatis本是apache的一个开源项目iBatis，2010年这个项目有apache software foundation迁移到了google c
1. MyBatis框架介绍
DevOps海洋的渔夫@专栏
04-13 418
1. MyBatis框架介绍1. 框架概述 程序开发中框架(framework)往往是对常见功能的封装，可以把框架理解为软件的设计规范或者标准化的组件，好比机械中的螺丝螺母等标准的机械部件...
MyBatis_1 简介
想太多的学习日志
03-08 258
1、什么是框架？ 它是我们软件开发中的一套解决方案，不同的框架解决的是不同的问题 使用框架的好处： 框架封装了很多的细节，使开发者可以使用极简的方式实现功能。大大提高开发效率。 2、三层架构 表现层： 是用于展示数据的 业务层： 是处理业务需求 持久层： 是和数据库交互的 3、持久层技术解决方案 JDBC技术： Connection PreparedStatement ResultSet Spri...
tk.mybatis的使用
weixin_45894305的博客
12-15 3574
简介 tk.mybatis可以节省程序员的大部分时间，对于程序员来说关于一张表的操作无非就是增删改查，tk.mybatis提供了一些基本操作的SQL语句，比如说按表的主键查询、删除等基本操作。我们接下来就来介绍一些tk.mybatis的简单使用吧。 使用（ 我这里使用的springboot+mybatis，反正就是Dao层、Service层、Controller层的操作，我就不详细解释了） 1.D...
【Mybatis】TKMybatis 介绍和使用
web13618542420的博客
08-27 971
TKMybatis 是基于 Mybatis 框架开发的一个工具，内部实现了对单表的基本数据操作，只需要简单继承 TKMybatis 提供的接口，就能够实现无需编写任何 sql 即能完成单表操作。
Mybatis-plus + 通用mapper（tk.mybatis）
qq_45981086的博客
03-28 1452
Mybatis-plus + 通用mapper（tk.mybatis）
Mybatis的介绍和基本使用
weixin_53058174的博客
11-17 414
Mybatis的介绍和基本使用
tk-mybatis使用介绍，springboot整合tk-mybatis、PageHelper实现分页查询
沐雨橙风ιε的博客
08-15 2901
目录第一步：准备数据库第二步：创建一个springboot项目 第三步：添加tk-mybatis的依赖第四步：修改配置文件第五步：创建数据库表对应的实体类第六步：持久层接口继承自Mapper接口第七步：使用tk-mybatis的API完成crud扩展：使用tk-mybatis整合PageHelper实现分页查询1、添加PageHelper依赖2、设置分页拦截器3、在所有代码之前开启分页创建数据库tkmybatis，然后执行以下脚本，为了方便起见，使用之前文章用的数据，也是我的歌单。 本篇文章将创建一个名
spring集成 tk.mybatis插件
05-31
使用tk.mybatis，你可以创建一个通用的Mapper接口，继承自`tk.mybatis.mapper.common.BaseMapper`，并指定实体类和对应的表名。例如： ```java public interface UserMapper extends BaseMapper<User> { } ```...
【微服务】mybatis typehandler使用详解
congge
02-25 6050
mybatis typehandler 使用详解
SpringCloud项目搭建(二) — tk.mybatis对mybatis的加强应用+mybatis-generator-mysql工具的代码生成(mysql版本)
qq_30977465的博客
03-14 1633
tk.mybatus的优点：通用 Mapper4 是一个可以实现任意 MyBatis 通用方法的框架，项目提供了常规的增删改查操作以及Example 相关的单表操作。通用 Mapper 是为了解决 MyBatis 使用中 90% 的基本操作，使用它可以很方便的进行开发，可以节省开发人员大量的时间。（这段抄的原作者的介绍，简单的说就是单表操作 相当 优秀） build.gradle中引入myba...
1.Mybatis入门
eeeeeeeeei的博客
01-28 1212
Mybatis入门+jdbc了解+数据库连接池（共享单车）+lombok（简化java开发）
win64 CC2022.zip
09-21
SmartTools InDesign插件
深度学习课程的课程设计-------基于ResNet优化模型的阿尔茨海默症的识别.zip
09-21
深度学习是机器学习的一个子领域，它基于人工神经网络的研究，特别是利用多层次的神经网络来进行学习和模式识别。深度学习模型能够学习数据的高层次特征，这些特征对于图像和语音识别、自然语言处理、医学图像分析等应用至关重要。以下是深度学习的一些关键概念和组成部分： 1. **神经网络（Neural Networks）**：深度学习的基础是人工神经网络，它是由多个层组成的网络结构，包括输入层、隐藏层和输出层。每个层由多个神经元组成，神经元之间通过权重连接。 2. **前馈神经网络（Feedforward Neural Networks）**：这是最常见的神经网络类型，信息从输入层流向隐藏层，最终到达输出层。 3. **卷积神经网络（Convolutional Neural Networks, CNNs）**：这种网络特别适合处理具有网格结构的数据，如图像。它们使用卷积层来提取图像的特征。 4. **循环神经网络（Recurrent Neural Networks, RNNs）**：这种网络能够处理序列数据，如时间序列或自然语言，因为它们具有记忆功能，能够捕捉数据中的时间依赖性。 5. **长短期记忆网络（Long Short-Term Memory, LSTM）**：LSTM 是一种特殊的 RNN，它能够学习长期依赖关系，非常适合复杂的序列预测任务。 6. **生成对抗网络（Generative Adversarial Networks, GANs）**：由两个网络组成，一个生成器和一个判别器，它们相互竞争，生成器生成数据，判别器评估数据的真实性。 7. **深度学习框架**：如 TensorFlow、Keras、PyTorch 等，这些框架提供了构建、训练和部署深度学习模型的工具和库。 8. **激活函数（Activation Functions）**：如 ReLU、Sigmoid、Tanh 等，它们在神经网络中用于添加非线性，使得网络能够学习复杂的函数。 9. **损失函数（Loss Functions）**：用于评估模型的预测与真实值之间的差异，常见的损失函数包括均方误差（MSE）、交叉熵（Cross-Entropy）等。 10. **优化算法（Optimization Algorithms）**：如梯度下降（Gradient Descent）、随机梯度下降（SGD）、Adam 等，用于更新网络权重，以最小化损失函数。 11. **正则化（Regularization）**：技术如 Dropout、L1/L2 正则化等，用于防止模型过拟合。 12. **迁移学习（Transfer Learning）**：利用在一个任务上训练好的模型来提高另一个相关任务的性能。 深度学习在许多领域都取得了显著的成就，但它也面临着一些挑战，如对大量数据的依赖、模型的解释性差、计算资源消耗大等。研究人员正在不断探索新的方法来解决这些问题。
机械设计课程设计说明书_带式输送机传送装置_西北工业大学.doc
最新发布
09-21
机械设计课程设计说明书_带式输送机传送装置_西北工业大学.doc
风格化欧洲城镇建筑场景模型：Modular European Town v1.1
09-21
使用 “模块化欧洲小镇” 包来改变你的游戏世界！这个套装提供了你设计一个充满活力的低多边形城市所需的一切。 套装包括： 模块化建筑：各种结构可创造多样化的建筑设计。 自然元素：树木、灌木丛和植物，以增加你的小镇的绿色景观。 基础设施：道路、人行道、边界和墙壁，以构建一个逼真的布局。 不同的道具：很多物品，如消防栓、路灯、咖啡馆桌椅、垃圾桶、长椅等等。 所有模型都采用低多边形美学制作，确保出色的性能和独特的视觉风格。这个套装非常适合所有平台上的游戏：移动设备、桌面电脑和虚拟现实。它易于使用且高度可定制，让你轻松构建自己独特的欧洲风格小镇。用 “模块化欧洲小镇” 将你的愿景变为现实！（解释说明：“lowpoly” 即低多边形，是一种在游戏和数字艺术中常用的风格，以较少的多边形数量来呈现模型，通常具有简洁的外观和较好的性能表现。
机械工艺课程设计 挂轮架轴自由锻工艺设计(全套图纸).doc
09-21
机械工艺课程设计 挂轮架轴自由锻工艺设计(全套图纸).doc
tk.mybatis官网
04-11
1. 快速入门指南：介绍了如何使用tk.mybatis进行基本的CRUD操作。 2. 高级用法：介绍了一些高级功能，如多表关联查询、分页查询等。 3. 配置指南：介绍了如何配置tk.mybatis插件，包括配置文件的编写和常用配置项的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值