当前位置： 首页 > news >正文

MyBatis的基本用法和配置方式

news 2025/8/16 5:28:13

demo目录

mybatis_helloworld/├── pom.xml
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/
│   │   │       └── demo/
│   │   │           ├── bean/
│   │   │           │   ├── Emp.java
│   │   │           │   ├── Dog.java
│   │   │           │   └── User.java
│   │   │           └── dao/
│   │   │               └── EmpDao.java
│   │   └── resources/
│   │       ├── com/
│   │       ├── db.properties
│   │       ├── log4j.properties
│   │       └── mybatis-config.xml└── test/└── java/├── MyTest.java├── MyTest2.java└── Test.java

这是一个基于MyBatis框架的简单Java项目，主要用于演示MyBatis的基本用法，包括实体类映射、SQL操作等。项目使用Maven进行依赖管理和构建。

核心配置文件

1. pom.xml

项目的Maven配置文件，管理项目依赖：

  • MyBatis 3.5.4
  • MySQL Connector Java 8.0.19
  • JUnit 4.13
  • Log4j 1.2.17

2. mybatis-config.xml

MyBatis的核心配置文件：

  • 引入外部属性文件 db.properties
  • 开启驼峰命名映射
  • 配置类型别名，指定实体类包路径
  • 配置环境（开发环境），使用JDBC事务管理器和POOLED数据源
  • 配置数据库厂商标识
  • 配置Mapper接口扫描包

3. db.properties

数据库连接配置：

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/test?serverTimezone=UTC
username=root
password=1234

实体类设计

项目包含3个实体类，位于 bean 包下：

1. Emp.java

员工实体类，对应数据库emp表：

  • empno: 员工编号
  • ename: 员工姓名
  • job: 职位
  • mgr: 上级编号
  • hiredate: 雇佣日期
  • sal: 薪水
  • comm: 佣金
  • deptno: 部门编号

2. Dog.java

狗狗实体类：

  • id: 编号
  • name: 名称
  • age: 年龄
  • gender: 性别

3. User.java

用户实体类：

  • id: 编号
  • userName: 用户名

DAO层设计

数据访问层接口位于 dao 包下：

EmpDao.java

员工数据访问接口，包含员工的CRUD操作方法：

  • save: 保存员工
  • update: 更新员工
  • delete: 删除员工
  • selectEmpByEmpno: 根据编号查询员工
  • selectAll: 查询所有员工
  • 以及多种条件查询方法

测试类

测试类位于 test 目录下：

  • MyTest.java
  • MyTest2.java
  • Test.java
    这些测试类用于测试MyBatis的各项功能。

总结

该项目是一个基础的MyBatis示例项目，展示了MyBatis的核心功能，包括：

  1. 实体类与数据库表的映射
  2. 使用Mapper接口进行数据库操作
  3. 配置文件的使用
  4. 事务管理
  5. 数据源配置

通过这个项目，可以学习MyBatis的基本用法和配置方式。

用到的sql

CREATE TABLE emp (empno INT PRIMARY KEY,ename VARCHAR(255) NOT NULL,job VARCHAR(255),mgr INT,hiredate DATE,sal DOUBLE,comm DOUBLE,deptno INT
);CREATE TABLE user (id INT PRIMARY KEY,user_name VARCHAR(255) NOT NULL
);CREATE TABLE dog (id INT PRIMARY KEY,name VARCHAR(255) NOT NULL,age INT,gender VARCHAR(255)
);

mybatis-config.xml


<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configurationPUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--在填写标签的时候一定要注意相关配置的顺序-->
<configuration><!--当需要引入外部的配置文件的时候，可以使用这样的方式类似于<context:property-placeholder location>resource:表示从当前项目的类路径中进行加载，如果用的是idea指的是resource资源目录下的配置文件url:可以从当前文件系统的磁盘目录查找配置，也可以从网络上的资源进行引入--><properties resource="db.properties" ></properties><!--可以影响mybatis运行时的行为，包含N多个属性，需要什么引入什么--><settings><!--开启驼峰标识验证--><setting name="mapUnderscoreToCamelCase" value="true"/></settings><!--typeAliases:表示在引入实体类的名称时候，可以使用别名，而不需要写完全限定名--><typeAliases><!--每一个具体的类都需要单独来写，如果有100个类呢？--><!--再配-->
<!--        <typeAlias type="com.demo.bean.Emp" alias="aaa"></typeAlias>--><!--可以指定具体的包来保证实体类不需要写完全限定名--><package name="com.demo.bean"/></typeAliases><!--设置定义自己的类型处理器，mybatis中默认内置了很多类型处理器，一般不需要自己来实现-->
<!--    <typeHandlers>-->
<!--        <typeHandler handler="" ></typeHandler>-->
<!--        <package name=""/>-->
<!--    </typeHandlers>-->
<!--当需要自定义对象工厂的时候实现此标签，完成结果集到java对象实例化的过程-->
<!--    <objectFactory type=""></objectFactory>--><!--在项目开发过程中，会包含开发环境，测试环境，生产环境，有可能会使用不同的数据源进行连接操作，在此配置文件中可以指定多个环境default:表示选择哪个环境作为运行时环境--><environments default="development"><!--配置具体的环境属性id:表示当前环境的名称--><environment id="development"><!--事务管理器，每一种数据源都需要配置具体的事务管理器type:表示事务管理器的类型jdbc:使用jdbc原生的事务控制managed:什么都没做--><transactionManager type="JDBC"/><!--配置具体的数据源的类型type:表示数据源的类型pooled:使用数据库连接池unpooled：每次都打开和关闭一个链接--><dataSource type="POOLED"><!--链接数据的时候需要添加的必备的参数，一般是四个，如果是连接池的话，可以设置连接最大个数等相关信息--><property name="driver" value="${driver}"/><property name="url" value="${url}"/><property name="username" value="${username}"/><property name="password" value="${password}"/></dataSource></environment></environments>
<!--提供了不同的数据库厂商的标识，当有数据库移植的需求的时候，可以根据不同的数据库来执行不同的sql语句
用来扩展数据库的移植性
--><databaseIdProvider type="DB_VENDOR"><property name="MySQL" value="mysql"/><property name="SQL Server" value="sqlserver"/><property name="Oracle" value="oracle"/></databaseIdProvider><!--是来将mapper映射文件引入到配置文件中，方便程序启动的时候进行加载每次在进行填写的时候需要注意，写完xml映射之后一定要添加到mybatis-config文件中resource:从项目的类路径下加载对应的映射文件url:从本地磁盘目录或者网络中引入映射文件class:可以直接引入类的完全限定名，可以使用注解的方式进行使用,如果不想以注解的方式引入呢？如果想要class的方式引入配置文件，可以将xml文件添加到具体的类的同级目录下1、      如果是maven的项目的话，需要添加如下配置，因为maven默认只会编译java文件，需要把xml文件也添加到指定目录中<build><resources><resource><directory>src/main/java</directory><includes><include>**/*.xml</include></includes></resource></resources></build>2、在resource资源目录下，创建跟dao层一样的同级目录即可，将配置文件放到指定的目录--><mappers>
<!--        <mapper resource="EmpDao.xml" />-->
<!--        <mapper resource="UserDao.xml"/>-->
<!--        <mapper class="com.demo.dao.UserDaoAnnotation"></mapper>-->
<!--        <mapper class="com.demo.dao.UserDao"></mapper>--><!--如果需要引入多个配置文件，可以直接定义包的名称resource目录下配置的映射文件必须要具体相同的目录--><package name="com.demo.dao"/></mappers>
</configuration>

测试类

import com.demo.bean.Emp;
import com.demo.bean.User;
import com.demo.dao.EmpDao;
import com.demo.dao.UserDao;
import com.demo.dao.UserDaoAnnotation;
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;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;public class MyTest {SqlSessionFactory sqlSessionFactory = null;//在执行任意方法之前，先执行这个@Beforepublic void init() {String resource = "mybatis-config.xml";InputStream in = null;try {in = Resources.getResourceAsStream(resource);} catch (IOException e) {e.printStackTrace();}sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);}@Testpublic void test01() {//获取与数据库相关的会话SqlSession sqlSession = sqlSessionFactory.openSession(true);//获取对应的映射接口对象EmpDao mapper = sqlSession.getMapper(EmpDao.class);//执行具体的sql语句Emp emp = mapper.selectEmpByEmpno(1111);System.out.println(emp);//关闭会话sqlSession.close();}@Testpublic void test045() {//获取与数据库相关的会话SqlSession sqlSession = sqlSessionFactory.openSession();//获取对应的映射接口对象EmpDao mapper = sqlSession.getMapper(EmpDao.class);//执行具体的sql语句List<Emp> emps = mapper.selectAll();for (Emp emp : emps) {System.out.println(emp);}//关闭会话sqlSession.close();}@Testpublic void test02() {
//        true为自动提交SqlSession sqlSession = sqlSessionFactory.openSession(true);EmpDao mapper = sqlSession.getMapper(EmpDao.class);Emp emp = new Emp();emp.setEmpno(null);emp.setEname("zhangsan");emp.setJob("gongzuo");emp.setMgr(1963);emp.setHiredate(new Date());emp.setSal(1222.00);emp.setComm(222.00);emp.setDeptno(55);Integer save = mapper.save(emp);
//        System.out.println(save);
//        提交sqlSession.commit();sqlSession.close();}@Testpublic void test03() {SqlSession sqlSession = sqlSessionFactory.openSession();EmpDao mapper = sqlSession.getMapper(EmpDao.class);Emp emp = new Emp();emp.setEmpno(1111);emp.setEname("zhangsan");emp.setJob("gongzuo");emp.setMgr(1963);emp.setHiredate(new Date());emp.setSal(1222.00);emp.setComm(222.00);emp.setDeptno(595);Integer update = mapper.update(emp);
//        System.out.println(update);sqlSession.commit();sqlSession.close();}@Testpublic void test04() {SqlSession sqlSession = sqlSessionFactory.openSession();EmpDao mapper = sqlSession.getMapper(EmpDao.class);Integer delete = mapper.delete(3333);System.out.println(delete);sqlSession.commit();sqlSession.close();}@Testpublic void test05() throws IOException {//获取与数据库相关的会话SqlSession sqlSession = sqlSessionFactory.openSession(true);//获取对应的映射接口对象UserDao mapper = sqlSession.getMapper(UserDao.class);//执行具体的sql语句User user = mapper.selectUserById(1);System.out.println(user);//关闭会话sqlSession.close();}@Testpublic void test055() throws IOException {//获取与数据库相关的会话SqlSession sqlSession = sqlSessionFactory.openSession(true);//获取对应的映射接口对象UserDaoAnnotation mapper = sqlSession.getMapper(UserDaoAnnotation.class);//执行具体的sql语句User user = mapper.selectUserById(1);System.out.println(user);//关闭会话sqlSession.close();}@Testpublic void test06() {SqlSession sqlSession = sqlSessionFactory.openSession();UserDao mapper = sqlSession.getMapper(UserDao.class);User user = new User();user.setUserName("lisi");Integer save = mapper.saveUser(user);System.out.println(save);System.out.println(user);sqlSession.commit();sqlSession.close();}@Testpublic void test07() {SqlSession sqlSession = sqlSessionFactory.openSession();EmpDao mapper = sqlSession.getMapper(EmpDao.class);List<Emp> list = mapper.selectAll();for (Emp emp : list) {System.out.println(emp);}sqlSession.commit();sqlSession.close();}@Testpublic void test077() {SqlSession sqlSession = sqlSessionFactory.openSession();EmpDao mapper = sqlSession.getMapper(EmpDao.class);Map<String, Emp> stringEmpMap = mapper.selectAll2();for (String key : stringEmpMap.keySet()) {System.out.println("key::" + key + "value::" + stringEmpMap.get(key));}sqlSession.commit();sqlSession.close();}@Testpublic void test0777() {SqlSession sqlSession = sqlSessionFactory.openSession();EmpDao mapper = sqlSession.getMapper(EmpDao.class);Map<Integer, Emp> stringEmpMap = mapper.selectAll3();for (Integer key : stringEmpMap.keySet()) {System.out.println("key::" + key + "value::" + stringEmpMap.get(key));}sqlSession.commit();sqlSession.close();}@Testpublic void test07777() {SqlSession sqlSession = sqlSessionFactory.openSession();EmpDao mapper = sqlSession.getMapper(EmpDao.class);Emp emp = mapper.selectbyno4("emp", 1111);System.out.println(emp);sqlSession.commit();sqlSession.close();}@Testpublic void test8() {SqlSession sqlSession = sqlSessionFactory.openSession();EmpDao mapper = sqlSession.getMapper(EmpDao.class);Emp emp = new Emp();emp.setEmpno(1111);emp.setSal(122.00);List<Emp> emps = mapper.selectEmpByEmpnoAndSal(emp);for (Emp emp1 : emps) {System.out.println(emp1);}sqlSession.commit();sqlSession.close();}@Testpublic void test88() {SqlSession sqlSession = sqlSessionFactory.openSession();EmpDao mapper = sqlSession.getMapper(EmpDao.class);List<Emp> list = mapper.selectEmpByEmpnoAndSal2(1111,12.0);for (Emp emp : list) {System.out.println(emp);}sqlSession.commit();sqlSession.close();}@Testpublic void test08() {SqlSession sqlSession = sqlSessionFactory.openSession();EmpDao mapper = sqlSession.getMapper(EmpDao.class);Map<String, Object> map = new HashMap<String, Object>();map.put("empno", 1111);map.put("sal", 1222.0);List<Emp> list = mapper.selectEmpByEmpnoAndSal3(map);for (Emp emp : list) {System.out.println(emp);}sqlSession.commit();sqlSession.close();}@Testpublic void test09() {SqlSession sqlSession = sqlSessionFactory.openSession();EmpDao mapper = sqlSession.getMapper(EmpDao.class);Map<Object, Object> objectObjectMap = mapper.selectEmpByEmpnoReturnMap(1111);System.out.println(objectObjectMap);sqlSession.commit();sqlSession.close();}@Testpublic void test10() {SqlSession sqlSession = sqlSessionFactory.openSession();EmpDao mapper = sqlSession.getMapper(EmpDao.class);Map<String, Emp> stringEmpMap = mapper.selectAll2();System.out.println(stringEmpMap);sqlSession.commit();sqlSession.close();}@Testpublic void test100() {SqlSession sqlSession = sqlSessionFactory.openSession();EmpDao mapper = sqlSession.getMapper(EmpDao.class);Map<Integer, Emp> stringEmpMap = mapper.selectAll3();System.out.println(stringEmpMap);sqlSession.commit();sqlSession.close();}
}import com.demo.bean.Dog;
import com.demo.bean.Emp;
import com.demo.bean.User;
import com.demo.dao.DogDao;
import com.demo.dao.EmpDao;
import com.demo.dao.UserDao;
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;
import java.util.HashMap;
import java.util.List;
import java.util.Map;public class MyTest2 {SqlSessionFactory sqlSessionFactory =  null;@Beforepublic void init(){String resource = "mybatis-config.xml";InputStream inputStream = null;try {inputStream = Resources.getResourceAsStream(resource);} catch (IOException e) {e.printStackTrace();}sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);}@Testpublic void test01() throws IOException {//获取与数据库相关的会话SqlSession sqlSession = sqlSessionFactory.openSession();//获取对应的映射接口对象DogDao mapper = sqlSession.getMapper(DogDao.class);//执行具体的sql语句Dog dog = mapper.selectDogById(1);System.out.println(dog);//关闭会话sqlSession.close();}}public class Test {public static void main(String[] args) {for (int row = 0; row < 5; row++) {for (int col = 1; col <= 2 * row - 1; col++) {System.out.print("*");}System.out.println();}for (int row = 0; row < 5; row++) {for (int col = 4; col >= 2 * row ; col--) {System.out.print("*");}System.out.println();}}
}

dao层

import com.demo.bean.User;
import org.apache.ibatis.annotations.Select;public interface UserDaoAnnotation {@Select("select * from user where id = #{id}")public User selectUserById(Integer id);
}
import com.demo.bean.Emp;
import com.demo.bean.User;
import org.omg.PortableInterceptor.Interceptor;
import java.util.List;
public interface UserDao {public User selectUserById(Integer id);public Integer saveUser(User user);
}package com.demo.dao;import com.demo.bean.Emp;
import com.sun.tracing.dtrace.ProviderAttributes;
import org.apache.ibatis.annotations.*;import java.util.List;
import java.util.Map;
//批量增加 insert into emp(empno,ename) values(1,1),(2,2),(3,3)public interface EmpDao {
//    @Select()
//    @Delete()
//    @Update()
//    @Insert()public Integer save(Emp emp);
@Update("update emp set " +"ename=#{ename},job=#{job},mgr=#{mgr},hiredate=#{hiredate},sal=#{sal},comm=#{comm},deptno=#{deptno} " +"where empno = #{empno}")public Integer update(Emp emp);public Integer delete(Integer empno);public Emp selectEmpByEmpno(Integer empno);public Map<Object,Object> selectEmpByEmpnoReturnMap(Integer empno);public List<Emp> selectAll();@MapKey("ename")public Map<String,Emp> selectAll2();@MapKey("empno")public Map<Integer,Emp> selectAll3();public Emp selectbyno4(String T,Integer empno);public List<Emp> selectEmpByEmpnoAndSal(Emp emp);public List<Emp> selectEmpByEmpnoAndSal2(@Param("empno") Integer empno, @Param("sal") Double sal);public List<Emp> selectEmpByEmpnoAndSal3(Map<String,Object> map);}import com.demo.bean.Dog;
import org.omg.PortableInterceptor.Interceptor;public interface DogDao {public Dog selectDogById(Integer id);
}

实体类

public class Dog {private Integer id;private String name;private Integer age;private String gender;
}public class Emp {private Integer empno;private String ename;private String job;private Integer mgr;private Date hiredate;private Double sal;private Double comm;private Integer deptno;
}public class User {private Integer id;private String userName;
}

mapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--在使用mybatis的时候，有些情况下需要我们封装结果集，一般情况下mybatis会帮我们自动封装（字段名跟属性值必须一一对应），但是如果字段的值和类中的值
不匹配的时候，怎么处理？1、可以在sql语句中添加别名字段，来保证赋值成功，但是太麻烦了，而且不可重用2、resultMap：
--><mapper namespace="com.demo.dao.DogDao"><!--自定义结果集id:表示当前结果集的唯一标识type:表示当前结果集的类型--><resultMap id="myDog" type="com.demo.bean.Dog"><!--id:表示指定对应的主键property:实体类中对应的属性值column：表中字段的名称--><id property="id" column="id"></id><!--除主键外的其他字段映射--><result property="name" column="dname"></result><result property="age" column="dage"></result><result property="gender" column="dgender"></result></resultMap><select id="selectDogById" resultMap="myDog">select * from dog where id = #{id}</select>
</mapper><?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.demo.dao.EmpDao"><!--在mybatis中，会包含非常多的查询操作，因此查询的参数比较麻烦id:用来设置当前sql语句匹配的dao接口的方法，必须要跟方法的名字统一resultType:表示返回的结果的类型,一般使用的并不多，此类型只能返回单一的对象，而我们在查询的时候特别是关联查询的时候，需要自定义结果集当返回的结果是一个集合的时候，并不需要resultmap，只需要使用resulttype指定集合中的元素类型即可resultMap:当进行关联查询的时候，在返回结果的对象中还包含另一个对象的引用时，此时需要自定义结果集合，使用resultmap--><!--参数的获取值的方式：每次在向sql语句中设置结果值的时候，可以使用#{}，还可以使用${}这样的方式，那么哪种比较好？#{}：select * from emp where empno = ?${}: select * from emp where empno = 7369通过sql语句可以得出结论：#{}的处理方式是使用了参数预编译的方式，不会引起sql注入的问题${}的处理方式是直接拼接sql语句，得到对应的sql语句，会有sql注入的危险因此，我们推荐大家使用#{}的方式但是要注意，${}也是有自己的使用场景的？当需要传入动态的表名，列名的时候就需要使用${},就是最直接的拼接字符串的行为--><!--当查询语句中包含多个参数的时候，我们应该如何获取需要的参数1、如果是单个参数，基本数据类型：那么可以使用#{}随便获取引用数据类型:使用#{}获取值的是必须要使用对象的属性名2、如果是多个参数：我们在获取参数值的时候，就不能简单的通过#{}来获取了,只能通过arg0,arg1,param1,param2...这样的方式来获取参数的值原因在于，mybatis在传入多个参数的时候，会讲这些参数的结果封装到map结构中，在map中key值就是(arg0,arg1,...)(param1,param2...),这种方式非常不友好，没有办法根据属性名来获取具体的参数值如果想要使用参数的话，可以进行如下的设置：public List<Emp> selectEmpByEmpnoAndSal2(@Param("empno") Integer empno, @Param("sal") Double sal);这样的方式其实是根据@Param来进行参数的获取3、自定义map结构--><select id="selectEmpByEmpnoAndSal3" resultType="com.demo.bean.Emp">select * from emp where empno = #{empno} and sal >#{sal}</select><select id="selectEmpByEmpnoAndSal2" resultType="com.demo.bean.Emp">select * from emp where empno = #{empno} and sal >#{sal}</select>
<!--  select * from emp where empno = #{aaa} and sal >#{ccc} 俩参数就不能瞎写了--><select id="selectEmpByEmpnoAndSal" resultType="com.demo.bean.Emp">select * from emp where empno = #{empno} and sal >#{sal}</select><select id="selectEmpByEmpno" resultType="com.demo.bean.Emp">select * from emp where empno = #{empno} and sal >#{sal}</select><!--当返回值是map结构的时候，会把查询结构的字段值作为key，结果作为value--><select id="selectEmpByEmpnoReturnMap" resultType="map">select * from emp where empno = #{empno}</select><!--当需要返回的结果是一个map的集合的时候，同时map中包含多个对象，那么此时必须要在dao的方法上添加@MapKey注解，来标识到底是哪一个属性值作为key--><select id="selectbyno4" resultType="Emp">select * from ${arg0} where empno=#{arg1}</select><select id="selectAll3" resultType="Emp">select * from emp</select><select id="selectAll2" resultType="Emp">select * from emp</select><select id="selectAll" resultType="Emp">select * from emp</select><!--insert delete update分别用来标识不同类型的sql语句id:用来标识跟dao接口中匹配的方法，必须与方法的名字一一对应上flushCache：用来标识当前sql语句的结果是否进入二级缓存statementType：用来选择执行sql语句的方式statement：最基本的jdbc的操作，用来表示一个sql语句，不能防止sql注入PREPARED: preareStatement：采用预编译的方式，能够防止sql注入，设置参数的时候需要该对象来进行设置CALLABLE：调用存储过程useGeneratedKeys：放完成插入操作的时候，可以将自增生成的主键值返回到具体的对象keyProperty：指定返回的主键要赋值到哪个属性中在编写sql语句的过程中，无论你是否配置了驼峰标识的识别settting，都需要在sql语句中写具体的表的属性名，不能写对象名称--><insert id="save" >insert into emp(empno,ename,job,mgr,hiredate,sal,comm,deptno) values(#{empno},#{ename},#{job},#{mgr},#{hiredate},#{sal},#{comm},#{deptno})</insert>
<!--    <update id="update">-->
<!--        update emp set ename=#{ename},job=#{job},mgr=#{mgr},hiredate=#{hiredate},sal=#{sal},comm=#{comm},deptno=#{deptno} where empno = #{empno}-->
<!--    </update>--><delete id="delete">delete from emp where empno = #{empno}</delete><!--===============================================================================--><!--如果需要定义一个自定义结果集，那么该如何进行处理resultMap--></mapper><?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.demo.dao.UserDao"><select id="selectUserById" resultType="com.demo.bean.User">select * from user where id = #{id}</select>
<!--    useGeneratedKeys：放完成插入操作的时候，可以将自增生成的主键值返回到具体的对象keyProperty：指定返回的主键要赋值到哪个属性中
在编写sql语句的过程中，无论你是否配置了驼峰标识的识别settting，都需要在sql语句中写具体的表的属性名，不能写对象名称--><insert id="saveUser" useGeneratedKeys="true" keyProperty="id">insert into user(user_name) values(#{userName})</insert>
</mapper>

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.demo</groupId><artifactId>mybatis_helloworld</artifactId><version>1.0-SNAPSHOT</version><dependencies>
<!--        mybatis--><!-- https://mvnrepository.com/artifact/org.mybatis/mybatis --><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.19</version></dependency><!-- https://mvnrepository.com/artifact/junit/junit --><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.13</version><scope>test</scope></dependency>
<!--        日志文件的jar--><!-- https://mvnrepository.com/artifact/log4j/log4j --><dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>1.2.17</version></dependency></dependencies>
<!--    <build>-->
<!--        <resources>-->
<!--            <resource>-->
<!--                <directory>src/main/java</directory>-->
<!--                <includes>-->
<!--                    <include>**/*.xml</include>-->
<!--                </includes>-->
<!--            </resource>-->
<!--        </resources>-->
<!--    </build>-->
</project>
http://www.xdnf.cn/news/1300789.html

相关文章：

  • Highcharts Dashboards ｜ 打造企业级数据仪表板：从图表到数据驾驶舱
  • 全球电商业财一体化：让出海品牌实现“看得见的增长“
  • demo 通讯录 + 城市选择器 （字母索引左右联动 ListItemGroup+AlphabetIndexer）笔记
  • Nginx反向代理与缓存实现
  • 人工智能与社会治理：从工具到生态的范式重构
  • Kafka生产者——提高生产者吞吐量
  • 切换VSCODE 中的默认 shell
  • GitHub 上 Star 数量前 18 的开源 AI Agent 项目
  • 制造装配、仓储搬运、快递装卸皆适配！MinkTec 弯曲形变传感器助力，让人体工学改变劳动生活
  • Vue3从入门到精通： 4.5 数据持久化与同步策略深度解析
  • Elasticsearch 深分页问题
  • 计算图的力量：从 PyTorch 动态图到 TensorFlow 静态图的全景与实战
  • Nginx蜘蛛请求智能分流：精准识别爬虫并转发SEO渲染服务
  • 【Java EE进阶 --- SpringBoot】初识Spring（创建SpringBoot项目）
  • iceberg 底层存储HDFS与juiceFS的区别
  • nflsoi 8.14 题解
  • 集成电路学习：什么是Video Processing视频处理
  • 《量子雷达》第4章 量子雷达的检测与估计 预习2025.8.14
  • ATAM：基于场景的软件架构权衡分析法
  • 解剖HashMap的put ＜三＞ JDK1.8
  • Linux入门指南：基础开发工具---yum/apt
  • MacOS 系统计算机专业好用工具安装
  • P5967 [POI 2016] Korale 题解
  • Java 8 新特性介绍
  • 【Docker】安装kafka案例
  • 【深度学习】深度学习的四个核心步骤：从房价预测看机器学习本质
  • 《Leetcode》-面试题-hot100-动态规划
  • 【无标题】卷轴屏手机前瞻：三星/京东方柔性屏耐久性测试进展
  • 待办事项小程序开发
  • 【C#】PNG 和 JPG、JPEG的应用以及三种格式的区别？