MyBatis 数据库访问

一、Mybatis框架

Mybatis框架，是ORM（Object Relation Mapping，对象关系映射）的一种实现框架，都是对JDBC的封装。MyBatis可以通过XML或者注解的方式，来配置映射类型、接口和实体。

优点：

• MyBatis相当灵活，不会对应用程序或者数据库的现有设计强加任何影响，SQL用XML编写，与程序代码分离，降低耦合度，便于统一管理和优化，且可重用
• 提供XML标签，支持动态SQL语句编写
• 提供映射标签，支持对象与数据库的ORM字段关系映射

二、Mybatis框架基本使用

既然是框架，对数据库的增删改查肯定是不会写在程序里面的，所以我们以后Dao层的SQL语句，不会写在UserDaoImpl，而是创建实体与映射关系文件，也就是mybatis的Mapper.xml文件，通过mybatis为我们查询并按照映射返回一个封装好了的查询的值，以后的SQL语句就写在Mapper.xml文件中。

pom.xml文件对相应jar进行管理：

1、myBatis主配置文件：mybatis.xml

配置数据库连接环境：driver、url、username、password

2、myBatis局部配置文件：UserDaoMapper.xml

sql语句保存在Mybatis的局部配置文件中

3、myBatis主配置文件和局部配置文件的关联

在mybatis.xml中，编写节点的内容，于是在运行过程中，程序先读主配置文件，然后通过主配置文件找到相应的局部配置文件。

<mappers>
		<mapper resource="cn/java/dao/impl/UserDaoMapper.xml"/>
</mappers>

三、Mybatis框架完整代码

1、配置文件

log4j.properties

日志的项目开发的运行过程中的一种重要的维护工具，log4j是一个非常优秀的开源日志记录工具，配置log4j将错误信息等打印在控制台。

log4j.rootLogger=DEBUG, CONSOLE
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender  
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout  
log4j.appender.CONSOLE.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n 

mybatis.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>
	<!-- 配置数据库连接环境：driver、url、username、password -->


	<!-- 开启log4j，输出SQL语句 -->
	<settings>
		<setting name="logImpl" value="LOG4j"/>
	</settings>

	<environments default="mysql">
		<!-- 开始配置mysql -->
		<environment id="mysql">
			<!--配置事务  -->
			<transactionManager type="JDBC"></transactionManager>
			<!-- 配置数据源 -->
			<dataSource type="POOLED">
				<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
				<property name="url" value="jdbc:mysql:///myschool?serverTimezone=GMT%2B8"/>
				<property name="username" value="root"/>
				<property name="password" value="你的密码"/>
			</dataSource>
	</environment>

	</environments>
	<!-- 关联局部SQL映射配置文件 ，在每一个mapper里，指定SQL映射文件名及全路径，可使用“copy qualified name””-->
	<mappers>
		<mapper resource="cn/java/mapper/UserDaoMapper.xml"/>
		<mapper resource="cn/java/mapper/CourseDaoMapper.xml"/>
	</mappers>
	
	
</configuration>

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>org.example</groupId>
    <artifactId>你的项目名字</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <!-- mysql驱动包 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.13</version>
        </dependency>
        <!-- myBatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <!-- 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>
        <!--使用apache的log4j日志-->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>2.11.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.11.0</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.25</version>
        </dependency>
    </dependencies>
    <!--如果是WEB项目，那么不用创建bulid标签-->
    <build>
        <!--编译的时候同时也把包下面的xml同时编译进去-->
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>
        <plugins>
            <!-- 指定jdk版本 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>utf-8</encoding>
                </configuration>
            </plugin>
        </plugins>

    </build>
</project>

2、cn.java.dao

UserDao.java

package cn.java.dao;

import java.io.IOException;

public interface UserDao {
    // 该方法使用User实体类
    public void getAllUser() throws IOException ;
    // 该方法返回多条记录，不使用实体类，用Map数据类型去接受
    public void getAllUserMap() throws IOException ;
    // 该方法使用了带一个参数的查询语句，返回一条记录
    public void getUserById() throws IOException ;
    // 该方法使用了有多个参数的 select语句
    public void getUserByMulCondition() throws IOException ;
    // 该方法插入一条记录，带参数，更新操作一定要提交事务
    public void addUser() throws IOException  ;
    // 该方法使用了动态查询，查询条件不确定
    public void getCourseByDynam() throws IOException  ;
    // 该方法使用了动态修改，查询条件不确定
    public void updateCourseByDynam() throws IOException ;
    public void addUserBatch() throws IOException;
}

CourseDao.java

package cn.java.dao;
import cn.java.entity.Course;

import java.io.IOException;
import java.util.List;

public interface CourseDao {
    // 该方法使用User实体类
    public void getAllCourse() throws IOException;
    // 该方法返回多条记录，不使用实体类，用Map数据类型去接受
    public void getAllCourseMap() throws IOException ;
    // 该方法使用了带一个参数的查询语句，返回一条记录
    public void getCourseById() throws IOException ;
    // 该方法使用了有多个参数的 select语句
    public void getCourseByMulCondition() throws IOException ;
    // 该方法插入一条记录，带参数，更新操作一定要提交事务
    public void addCourse() throws IOException  ;
    // 该方法使用了动态查询，查询条件不确定
    public void getCourseByDynam() throws IOException  ;
    // 该方法使用了动态修改，查询条件不确定
    public void updateCourseByDynam() throws IOException ;
    public void addCourseBatch() throws IOException;
    public void deleteCourseById() throws IOException;
    public void deleteCourseByIds() throws IOException;
}

3、cn.java.dao.impl

UserDaoImpl.java

package cn.java.dao.impl;

import cn.java.dao.UserDao;

import cn.java.entity.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


public class UserDaoImpl implements UserDao {

    public static SqlSession session;

   //启动mybatis框架，读配置文件，获取Session对象
   public void getSession() throws IOException{
        // (1)启动mybatis框架
        // SqlSession---->SqlSessionFactory---->SqlSessionFactoryBuilder
        SqlSessionFactoryBuilder sfb = new SqlSessionFactoryBuilder();
        // 读source文件下的mybatis.xml,将mybatis.xml文件转化成流
        InputStream ins = Resources.getResourceAsStream("mybatis.xml");
        // (2)创建SQLSessionFactory工厂对象
        SqlSessionFactory ssf = sfb.build(ins);
        // (3)创建SqlSession对象
         session = ssf.openSession();
    }

    @Test // 使用单元测试
    // 1.该方法使用User实体类
    public void getAllUser() throws IOException {
        getSession();
        // 调用SQL局部配置文件UserDaoIMapper.xml中的sql语句，格式为“命名空间.id”
        // 并用List<User>来接收查询结果\

        List<User> userList = session.selectList("cn.java.dao.impl.UserDaoImpl.getAllUser");
        // 遍历List<User>，并打印结果
        for (User user : userList) {
            System.out.println(user);
        }
        session.close();
    }


    @Test
    // 2.该方法返回多条记录，不使用实体类，用Map数据类型去接受
    public void getAllUserMap() throws IOException {
        getSession();
        // 调用sql映射文件中的sql语句，格式为“命名空间.id”，不使用实体类，用Map数据类型
        List<Map<String, Object>> userList = session.selectList("cn.java.dao.impl.UserDaoImpl.getAllUserMap");
        for (Map<String, Object> map : userList) {
            System.out.println(map);
        }
        session.close();
    }

    @Test
    // 3.该方法使用了带一个参数的查询语句，返回一条记录
    public void getUserById() throws IOException {
        getSession();
        // 传递参数，直接传
        Long id = 1L;
        Map<String, Object> userMap = session.selectOne("cn.java.dao.impl.UserDaoImpl.getUserById", id);
        System.out.println(userMap);
        session.close();

    }

    @Test
    // 4.该方法使用了有多个参数的 select语句
    public void getUserByMulCondition() throws IOException {
        getSession();
        // 声明一个Map对象，可以使用Map或实体类同时传递多个参数，用map更简单
        Map<String, Object> paramMap = new HashMap<String, Object>();
        // 封装参数
        paramMap.put("username", "Jack");
        paramMap.put("pwd", "123");
        // 传递参数
        Map<String, Object> userMap = session.selectOne("cn.java.dao.impl.UserDaoImpl.getUserByMulCondition", paramMap);
        System.out.println(userMap);
        session.close();
    }

    // 5.该方法插入一条记录，带参数，更新操作一定要提交事务
    @Test
    public void addUser() throws IOException {
        getSession();
        Map<String, Object> paramMap = new HashMap<String, Object>();
        paramMap.put("username", "Jone");
        paramMap.put("password", "1234");
        int resultInt = session.insert("cn.java.dao.impl.UserDaoImpl.addUser", paramMap);
        session.commit(); // 更新操作一定要提交事务
        session.close();
        System.out.println(resultInt);
    }

    // 6.该方法插入多条记录
   @Test
    public void addUserBatch( ) throws IOException{
        getSession();
        List<User> list = new ArrayList<>();
        User user;
        for (int i = 10; i < 20; i++) {
            user = new User();
            user.setUsername("test" + i);
            user.setPassword("111");
            list.add(user);
        }
        int resultInt = session.insert("cn.java.dao.impl.UserDaoImpl.addUserBatch",list);
        session.commit(); // 更新操作一定要提交事务
       session.close();
        System.out.println(resultInt);
    };


    // 7.该方法使用了动态查询，查询条件不确定
    @Test
    public void getCourseByDynam() throws IOException {
        getSession();
        // 可以使用Map或实体类同时传递多个参数
        Map<String, Object> paramMap = new HashMap<String, Object>();
        paramMap.put("cname", "数据库原理");
        paramMap.put("credit", 4);
        paramMap.put("department", "软件工程");
        List<Map<String, Object>> courseList = session.selectList("cn.java.dao.impl.UserDaoImpl.getCourseByDynam",
                paramMap);
        for (Map<String, Object> map : courseList) {
            System.out.println(map);
        }
        session.close();

    }

    // 8.该方法使用了动态修改，查询条件不确定
    @Test
    public void updateCourseByDynam() throws IOException {
        getSession();
        // 可以使用Map或实体类同时传递多个参数
        Map<String, Object> paramMap = new HashMap<String, Object>();
        paramMap.put("cname", "数据库原理");
        paramMap.put("credit", 4);
        paramMap.put("id", 1);
        int resultInt = session.update("cn.java.dao.impl.UserDaoImpl.updateCourseByDynam", paramMap);
        session.commit(); // 更新操作一定要提交事务
        session.close();
        System.out.println(resultInt);
    }
}

CourseDaoImpl.java

package cn.java.dao.impl;

import cn.java.dao.CourseDao;
import cn.java.entity.Course;
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;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class CourseDaoImpl implements CourseDao{
    public static SqlSession session;

    //启动mybatis框架，读配置文件，获取Session对象
    public void getSession() throws IOException {
        // (1)启动mybatis框架
        // SqlSession---->SqlSessionFactory---->SqlSessionFactoryBuilder
        SqlSessionFactoryBuilder sfb = new SqlSessionFactoryBuilder();
        // 读source文件下的mybatis.xml,将mybatis.xml文件转化成流
        InputStream ins = Resources.getResourceAsStream("mybatis.xml");
        // (2)创建SQLSessionFactory工厂对象
        SqlSessionFactory ssf = sfb.build(ins);
        // (3)创建SqlSession对象
        session = ssf.openSession();
    }

    @Test // 使用单元测试
    // 1.该方法使用Course实体类
    public void getAllCourse() throws IOException {
        getSession();
        // 调用SQL局部配置文件CourseDaoIMapper.xml中的sql语句，格式为“命名空间.id”
        // 并用List<Course>来接收查询结果
        List<Course> courseList = session.selectList("cn.java.dao.impl.CourseDaoImpl.getAllCourse");
        // 遍历List<Course>，并打印结果
        for (Course course : courseList) {
            System.out.println(course);
        }
        session.close();
    }

    @Test
    // 2.该方法返回多条记录，不使用实体类，用Map数据类型去接受
    public void getAllCourseMap() throws IOException {
        getSession();
        // 调用sql映射文件中的sql语句，格式为“命名空间.id”，不使用实体类，用Map数据类型
        List<Map<String, Object>> courseList = session.selectList("cn.java.dao.impl.CourseDaoImpl.getAllCourseMap");
        for (Map<String, Object> map : courseList) {
            System.out.println(map);
        }
        session.close();
    }

    @Test
    // 3.该方法使用了带一个参数的查询语句，返回一条记录
    public void getCourseById() throws IOException {
        getSession();
        // 传递参数，直接传
        Long id = 3L;
        Map<String, Object> courseMap = session.selectOne("cn.java.dao.impl.CourseDaoImpl.getCourseById", id);
        System.out.println(courseMap);
        session.close();

    }

    @Test
    // 4.该方法使用了有多个参数的 select语句
    public void getCourseByMulCondition() throws IOException {
        getSession();
        // 声明一个Map对象，可以使用Map或实体类同时传递多个参数，用map更简单
        Map<String, Object> paramMap = new HashMap<String, Object>();
        // 封装参数
        paramMap.put("cname", "数据库原理");
        paramMap.put("credit", "4");
        paramMap.put("department", "软件工程");
        paramMap.put("content", "week7");
        // 传递参数
        Map<String, Object> courseMap = session.selectOne("cn.java.dao.impl.CourseDaoImpl.getCourseByMulCondition", paramMap);
        System.out.println(courseMap);
        session.close();
    }

    // 5.该方法插入一条记录，带参数，更新操作一定要提交事务
    @Test
    public void addCourse() throws IOException {
        getSession();
        Map<String, Object> paramMap = new HashMap<String, Object>();
        paramMap.put("cname", "非关系型数据库");
        paramMap.put("credit", "4");
        paramMap.put("department", "软件工程");
        paramMap.put("content", "week7");
        int resultInt = session.insert("cn.java.dao.impl.CourseDaoImpl.addCourse", paramMap);
        session.commit(); // 更新操作一定要提交事务
        session.close();
        System.out.println(resultInt);
    }

    // 6.该方法插入多条记录
    @Test
    public  void addCourseBatch() throws IOException{
        getSession();
        List<Course> list = new ArrayList<>();
        Course course;
        for (int i = 0; i < 10; i++) {
            course = new Course();
            course.setCname("class" + i);
            course.setCredit(i);
            course.setDepartment("测试");
            course.setContent("测试");
            list.add(course);
        }
        int resultInt = session.insert("cn.java.dao.impl.CourseDaoImpl.addCourseBatch",list);
        session.commit(); // 更新操作一定要提交事务
        session.close();
        System.out.println(resultInt);
    };


    // 7.该方法使用了动态查询，查询条件不确定
    @Test
    public void getCourseByDynam() throws IOException {
        getSession();
        // 可以使用Map或实体类同时传递多个参数
        Map<String, Object> paramMap = new HashMap<String, Object>();
        paramMap.put("cname", "数据挖掘");
        paramMap.put("credit", 4);
        paramMap.put("department", "软件工程");
        List<Map<String, Object>> courseList = session.selectList("cn.java.dao.impl.CourseDaoImpl.getCourseByDynam",
                paramMap);
        for (Map<String, Object> map : courseList) {
            System.out.println(map);
        }
        session.close();

    }

    // 8.该方法使用了动态修改，查询条件不确定
    @Test
    public void updateCourseByDynam() throws IOException {
        getSession();
        // 可以使用Map或实体类同时传递多个参数
        Map<String, Object> paramMap = new HashMap<String, Object>();
        paramMap.put("cname", "数据库原理");
        paramMap.put("id", 1);
        paramMap.put("content", "week7");
        int resultInt = session.update("cn.java.dao.impl.CourseDaoImpl.updateCourseByDynam", paramMap);
        session.commit(); // 更新操作一定要提交事务
        session.close();
        System.out.println(resultInt);
    }

    //9.删除通过课程id
    @Test
    public void deleteCourseById() throws IOException {
        getSession();
        // 传递参数，直接传
        int id = 21;
        int resultInt = session.delete("cn.java.dao.impl.CourseDaoImpl.deleteCourseById", id);
        System.out.println(resultInt);
        session.commit(); // 更新操作一定要提交事务
        session.close();

    }
    //10.多个删除通过课程id
    @Test
    public void deleteCourseByIds() throws IOException {
        getSession();
        // 传递参数，直接传
        int[] ids = new int[]{22,23,24};
        int resultInt = session.delete("cn.java.dao.impl.CourseDaoImpl.deleteCourseByIds", ids);
        System.out.println(resultInt);
        session.commit(); // 更新操作一定要提交事务
        session.close();
    }
}

4、实体类

Course.java

package cn.java.entity;

public class Course {
    private int id;

    private String cname;

    private int credit;

    private String department;

    private String content;

    public Course() {

    }

    public Course(int id, String cname, int credit, String department, String content) {
        this.id = id;
        this.cname = cname;
        this.credit = credit;
        this.department = department;
        this.content = content;
    }

    public int getId() {
        return id;
    }

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

    public String getCname() {
        return cname;
    }

    public void setCname(String cname) {
        this.cname = cname;
    }

    public int getCredit() {
        return credit;
    }

    public void setCredit(int credit) {
        this.credit = credit;
    }

    public String getDepartment() {
        return department;
    }

    public void setDepartment(String department) {
        this.department = department;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    @Override
    public String toString() {
        return "Course{" +
                "id=" + id +
                ", cname='" + cname + '\'' +
                ", credit=" + credit +
                ", department='" + department + '\'' +
                ", content='" + content + '\'' +
                '}';
    }
}

5、mapper

UserDaolMapper.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">
<!--  sql语句保存在Mybatis的局部配置文件中
     解释：
	（1）namespace：命名空间，其值为某一个dao层实现类的具体路径,
	    表示这个类要使用相应的SQL语句，这个具体路径不要自己写，可以选中该类，右键，选择“copy qualified name”,然后粘贴即可
	（2）select标签存放查询语句；
	 （3）id:在整个配置文件中id值必须唯一，一般情况下，其值与dao层类中的使用该SQL语句的方法名保持一致；
	 （4）resultType：指定当前sql查询语句返回的数据类型。类型不是为sql语句的最终类型，
	     而是某一条数据的类型，一般用实体类表示，也要用该实体类的“copy qualified name”来表示，运行时系统会自动将实体类的对象创建出来
       （5）可以编写多条sql语句
 -->

<!--dao层实现类的具体路径-->
<mapper namespace="cn.java.dao.impl.UserDaoImpl">

     <!-- 
		1.select语句返回多条User实体对象
		resultType="cn.java.entity.User"表示返回User实体类
	 -->
    <select id="getAllUser" resultType="cn.java.entity.User">
		SELECT * FROM users
	</select>


	<!-- 
		2.select语句返回List<Map<String,Object>，可以不使用实体类,直接用Map数据类型，更加简单，简化程序
	 -->
	<select id="getAllUserMap" resultType="Map">
		SELECT * FROM users
	</select>
	
	<!-- 
		3.SQL语句带一个参数
		parameterType：指定接收参数类型，返回一条记录，用下标取参数
		parameterType：参数类型
	 -->
	<select id="getUserById" resultType="map" parameterType="Long">
		SELECT * FROM users WHERE id=#{0}
	</select>
	
	<!--
		4.SQL语句带多个参数，用Map封装，parameterType=Map，返回一条记录,按key取参数值
		#在获取参数时可防止SQL注入攻击，应尽量使用#；模糊查询时，使用$
	  -->
	<select id="getUserByMulCondition" resultType="map" parameterType="Map">
		SELECT * FROM users WHERE username='${username}' AND PASSWORD='${pwd}'
	</select>
	
	<!-- 添加数据
		5. delete、insert、update操作没有resultType属性，默认返回int型
		  parameterType=Map，表示参数类型为Map，用Map封装参数
		  #表示在获取参数时可防止SQL注入攻击，应尽量使用#；模糊查询时，使用$
	      INSERT INTO users SET username=，这种SQL语句是MmySql特有的扩展功能
	 -->
	<insert id="addUser" parameterType="Map">
		INSERT INTO users SET username=#{username},PASSWORD=#{password}
	</insert>

	<insert id="addUserBatch" parameterType="cn.java.entity.User">
		insert into
		users(username,PASSWORD)
		values
		<foreach collection="list" item="user" separator=",">
			(#{user.username},#{user.password})
		</foreach>
	</insert>
	
	<!-- 
		6.动态SQL语句,实现动态查询
		  &lt:小于
		  &gt:大于
		  where标签:当有查询条件时，就使用where命令，当没有查询条件时，就不用where命令
		  if test：判断是否对某个字段进行查询
		  根据用户的选择去生成
	 -->
	<select id="getCourseByDynam" resultType="Map" parameterType="Map">
		SELECT * FROM course 
        <where>
		   <if test="cname!=null">
		       cname=#{cname}		
		   </if>
		   <if test="credit!=null">
		       and credit=#{credit}		
		   </if> 
		   <if test="department!=null">
		       and department=#{department}		
		   </if>
		</where>
	</select>
	
	<!-- 
		7.动态修改update语句
		 set标签:当有更新字段时，就使用set命令，当没有更新字段时，
		     语句为UPDATE course SET id=NULL WHERE id=NULL
	 -->
	<update id="updateCourseByDynam" parameterType="Map">
	   update course 
	   <set>
	       <if test="cname!=null">
		       cname=#{cname},		
		   </if>
		   <if test="credit!=null">
		       credit=#{credit},	
		   </if> 
		   <if test="department!=null">
		       department=#{department},		
		   </if>
		    id=#{id}
	  </set>  
	  where id=#{id} 
	</update>
	
</mapper>

CourseDaolMapper.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">
<!--  sql语句保存在Mybatis的局部配置文件中
     解释：
	（1）namespace：命名空间，其值为某一个dao层实现类的具体路径,
	    表示这个类要使用相应的SQL语句，这个具体路径不要自己写，可以选中该类，右键，选择“copy qualified name”,然后粘贴即可
	（2）select标签存放查询语句；
	 （3）id:在整个配置文件中id值必须唯一，一般情况下，其值与dao层类中的使用该SQL语句的方法名保持一致；
	 （4）resultType：指定当前sql查询语句返回的数据类型。类型不是为sql语句的最终类型，
	     而是某一条数据的类型，一般用实体类表示，也要用该实体类的“copy qualified name”来表示，运行时系统会自动将实体类的对象创建出来
       （5）可以编写多条sql语句
 -->
<mapper namespace="cn.java.dao.impl.CourseDaoImpl">
     <!-- 
		1.select语句返回多条User实体对象
		resultType="cn.java.entity.User"表示返回User实体类
	 -->
    <select id="getAllCourse" resultType="cn.java.entity.Course">
		SELECT * FROM course
	</select>


	<!-- 
		2.select语句返回List<Map<String,Object>，可以不使用实体类,直接用Map数据类型，更加简单，简化程序
	 -->
	<select id="getAllCourseMap" resultType="Map">
		SELECT * FROM course
	</select>
	
	<!-- 
		3.SQL语句带一个参数
		parameterType：指定接收参数类型，返回一条记录，用下标取参数
		parameterType：参数类型
	 -->
	<select id="getCourseById" resultType="map" parameterType="Long">
		SELECT * FROM course WHERE id=#{0}
	</select>
	
	<!--
		4.SQL语句带多个参数，用Map封装，parameterType=Map，返回一条记录,按key取参数值
		#在获取参数时可防止SQL注入攻击，应尽量使用#；模糊查询时，使用$
	  -->
	<select id="getCourseByMulCondition" resultType="map" parameterType="Map">
		SELECT * FROM course WHERE cname='${cname}' AND DEPARTMENT='${department}'
	</select>
	
	<!-- 添加数据
		5. delete、insert、update操作没有resultType属性，默认返回int型
		  parameterType=Map，表示参数类型为Map，用Map封装参数
		  #表示在获取参数时可防止SQL注入攻击，应尽量使用#；模糊查询时，使用$
	      INSERT INTO users SET username=，这种SQL语句是MmySql特有的扩展功能
	 -->
	<insert id="addCourse" parameterType="Map">
		INSERT INTO course SET cname=#{cname},credit=#{credit},department=#{department},content=#{content}
	</insert>

	<insert id="addCourseBatch" parameterType="cn.java.entity.Course">
		insert into
		course(cname,credit,department,content)
		values
		<foreach collection="list" item="course" separator=",">
			(#{course.cname},#{course.credit},#{course.department},#{course.content})
		</foreach>
	</insert>
	
	<!-- 
		6.动态SQL语句,实现动态查询
		  &lt:小于
		  &gt:大于
		  where标签:当有查询条件时，就使用where命令，当没有查询条件时，就不用where命令
		  if test：判断是否对某个字段进行查询
		  根据用户的选择去生成
	 -->
	<select id="getCourseByDynam" resultType="Map" parameterType="Map">
		SELECT * FROM course 
        <where>
		   <if test="cname!=null">
		       cname=#{cname}		
		   </if>
		   <if test="credit!=null">
		       and credit=#{credit}		
		   </if> 
		   <if test="department!=null">
		       and department=#{department}		
		   </if>
		</where>
	</select>
	
	<!-- 
		7.动态修改update语句
		 set标签:当有更新字段时，就使用set命令，当没有更新字段时，
		     语句为UPDATE course SET id=NULL WHERE id=NULL
	 -->
	<update id="updateCourseByDynam" parameterType="Map">
	   update course 
	   <set>
	       <if test="cname!=null">
		       cname=#{cname},		
		   </if>
		   <if test="credit!=null">
		       credit=#{credit},	
		   </if> 
		   <if test="department!=null">
		       department=#{department},		
		   </if>
		   <if test="content!=null">
			   content=#{content},
		   </if>
		    id=#{id}
	  </set>  
	  where id=#{id} 
	</update>
	
	<delete id="deleteCourseById" parameterType="int">
		DELETE FROM course WHERE id=#{id}
	</delete>
	
	<delete id="deleteCourseByIds" parameterType="int[]" >
		DELETE FROM course WHERE id IN
		<foreach collection="array" item="id" open="(" close=")" separator=",">
			#{id}
		</foreach>
	</delete>
</mapper>

三、运行结果

1、getAllCourse()

2、getAllCourseMap()

3、getCourseById()

4、getCourseByMulCondition()

5、addCourse()

6、addCourseBatch()

7、getCourseByDynam()

8、updateCourseByDynam()

9、deleteCourseById()

10、deleteCourseByIds()