MyBatis框架的配置及使用MyBatis框架对表进行CRUD（增删改查）练习（软件工程综合实践课程第七周作业）

GCTTTTTT

已于 2022-12-15 21:30:17 修改

阅读量1k

点赞数 3

分类专栏：软件工程综合实践文章标签： mybatis 软件工程 java intellij-idea mysql

于 2022-10-12 23:23:34 首次发布

本文链接：https://blog.csdn.net/GCTTTTTT/article/details/127291979

版权

软件工程综合实践专栏收录该内容

12 篇文章 8 订阅

订阅专栏

一、练习要求

要求：针对 MySchool 数据库的 course 表，使用 mybatis 框架对其进行 CRUD 操作。
步骤：
（1 ）创建一个maven 项目，项目名为” ” week7_Mybatis_学号 ” ；
（2）使用Junit 单元测试功能；
（3）使用 log4j日志功能；
（4）创建 dao 层接口类 ,dao 层实现类， entity 层中的实体类；
（5）编写好 mybatis的两个配置文件，完成对 course表的 CRUD 操作；

二、准备工作

新建一个Maven项目

配置pom.xml文件

MyBatis依赖配置：

<!-- myBatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>

Junit 单元测试依赖配置：

<!-- 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

log4j日志功能依赖配置：

<!--使用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>

完整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.12</version>
        </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.8.1</version>-->
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>utf-8</encoding>
                </configuration>
            </plugin>
        </plugins>

    </build>


</project>

配置resources文件夹

在resources文件夹中配置mybatis.xml和log4j.properties文件

注意：如果resources文件夹的图标没有像下图这样的话，需要在resources文件夹上右键—Mark Directory as — resources root ，不然可能运行代码的时候程序会找不到resources文件夹里面的文件

配置mybatis.xml

关于mabatis.xml配置文件和映射文件…Mapper.xml可以创建一个代码模板，就可以快速生成了
框架的搭建和代码模板的创建具体操作参考：
IDEAIntellij中MyBatis框架搭建全过程及MyBatis工程基本的使用方法

IntellijIDEA中创建MyBatis部分代码模板详细过程

1、重点关注数据源dataSource标签的配置，要按照自己的数据库环境配置：

<dataSource type="POOLED">
				<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
<!-- 				<property name="driver" value="com.mysql.jdbc.Driver"/> -->
				<property name="url" value="jdbc:mysql://localhost:3306/myschool?characterEncoding=utf8&amp;useSSL=false&amp;serverTimezone=UTC&amp;rewriteBatchedStatements=true"/>
				<!-- 				<property name="url" value="jdbc:mysql://localhost:3306/myschool"/> -->
				<property name="username" value="root"/>
				<property name="password" value="密码"/>
			</dataSource>

注意： 1、用mysql8的话url的配置最好为<property name="url" value="jdbc:mysql://localhost:3306/myschool?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&rewriteBatchedStatements=true"/>，用老师给的可能会报错
2、xml文件中的“&”需要用"&"来转义

2、要注意当有新的mapper文件（如CourseDaoMapper.xml）时需要配置一下mappers标签

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

完整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>

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

	<!-- 配置数据库连接环境：driver、url、username、password -->
	<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="driver" value="com.mysql.jdbc.Driver"/> -->
				<property name="url" value="jdbc:mysql://localhost:3306/myschool?characterEncoding=utf8&amp;useSSL=false&amp;serverTimezone=UTC&amp;rewriteBatchedStatements=true"/>
				<!-- 				<property name="url" value="jdbc:mysql://localhost:3306/myschool"/> -->
				<property name="username" value="root"/>
				<property name="password" value="密码"/>
			</dataSource>
	</environment>

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

</configuration>

配置log4j.properties

# log4J日志框架的配置文件 文件名字不能改
# 第一句：控制日志的输出级别及往哪里输出信息
# 日志的输出级别：fatal>error>warn>info>debug
# 日志输出在控制台：Console

log4j.rootLogger=DEBUG, CONSOLE

#也可以如下设置，提高总的输出级别，但是降低某一个包或类或方法的级别，这样可以减少输出日志信息
#log4j.rootLogger=ERROR,CONSOLE
#log4j.logger.cn.java.dao.impl=DEBUG
#负责输出日志的类，格式
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中还需要配置：

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

搭建好项目结构

项目完整结构：
在这里插入图片描述

三、完整代码

com.java.dao包

com.java.dao.impl包

com.java.dao.impl.CourseDaoImpl

package com.java.dao.impl;

import com.java.dao.CourseDao;
import com.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;

/**
 * @projectName: week7_Mybatis_x
 * @package: com.java.dao.impl
 * @className: CourseDaoImpl
 * @author: GCT
 * @description: TODO
 * @date: 2022/10/12 17:48
 * @version: 1.0
 */
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("com.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("com.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 = 4L;
        Map<String, Object> courseMap = session.selectOne("com.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", "test");
        paramMap.put("credit", "4");
        paramMap.put("department", "test");
        paramMap.put("content", "test");
        // 传递参数
        Map<String, Object> courseMap = session.selectOne("com.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", "test_Mybatis");
        paramMap.put("credit", "4");
        paramMap.put("department", "test_Mybatis");
        paramMap.put("content", "test_Mybatis");
        int resultInt = session.insert("com.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("test" + i);
            course.setCredit(i);
            course.setDepartment("test"+i);
            course.setContent("test"+i);
            list.add(course);
        }
        int resultInt = session.insert("com.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("com.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", "数据库原理666");
//        paramMap.put("credit", 4);
        // paramMap.put("department", "软工1");
        paramMap.put("id", 1);
        paramMap.put("content", "Mybatis_test");
        int resultInt = session.update("com.java.dao.impl.CourseDaoImpl.updateCourseByDynam", paramMap);
        session.commit(); // 更新操作一定要提交事务
        session.close();
        System.out.println(resultInt);
    }

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

    }

    @Test
    public void deleteCourseByIds() throws IOException {
        getSession();
        // 传递参数，直接传
        int[] ids = new int[]{56,57,58};
        int resultInt = session.delete("com.java.dao.impl.CourseDaoImpl.deleteCourseByIds", ids);
        System.out.println(resultInt);
        session.commit(); // 更新操作一定要提交事务
        session.close();
    }
}

com.java.dao.impl.UserDaoImpl

package com.java.dao.impl;

import com.java.dao.UserDao;
import com.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("com.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("com.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 = 4L;
        Map<String, Object> userMap = session.selectOne("com.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", "admin");
        paramMap.put("pwd", "123");
        // 传递参数
        Map<String, Object> userMap = session.selectOne("com.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", "Rose");
        paramMap.put("password", "1234");
        int resultInt = session.insert("com.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 = 0; i < 10; i++) {
            user = new User();
            user.setUsername("test" + i);
            user.setPassword("666");
            list.add(user);
        }
        int resultInt = session.insert("com.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("com.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("department", "软工1");
        paramMap.put("id", 1);
        int resultInt = session.update("com.java.dao.impl.UserDaoImpl.updateCourseByDynam", paramMap);
        session.commit(); // 更新操作一定要提交事务
        session.close();
        System.out.println(resultInt);
    }

}

com.java.dao.CourseDao

interface类型文件

package com.java.dao;

import java.io.IOException;

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;

    //    根据id删除记录
    public void deleteCourseById() throws IOException;
    //    根据多个id删除多条记录
    public void deleteCourseByIds() throws IOException;
}

com.java.dao.UserDao

interface类型文件

package com.java.dao;

import java.io.IOException;

/**
 * description:
 * author :
 * date: 2020/10/3
 */
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;
}

com.java.entity包

com.java.entity.Course

package com.java.entity;

/**
 * @projectName: week7_Mybatis_z
 * @package: com.java.entity
 * @className: Course
 * @author: GCT
 * @description: TODO
 * @date: 2022/10/12 17:33
 * @version: 1.0
 */
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 + '\'' +
                '}';
    }
}

com.java.entity.User

package com.java.entity;

public class User {
    private Long id;
    private String username;
    private String password;
    public User(Long id, String username, String password) {
		super();
		this.id = id;
		this.username = username;
		this.password = password;
	}
	public User() {
		super();
		// TODO Auto-generated constructor stub
	}



	public Long getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", password=" + password + "]";
    }
}

com.java.mapper包

com/java/mapper/CourseDaoMapper.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.java.dao.impl.CourseDaoImpl">
    <!--
		1.select语句返回多条User实体对象
		resultType="cn.java.entity.User"表示返回User实体类
	 -->
    <select id="getAllCourse" resultType="com.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}' AND CREDIT='${credit}' AND CONTENT='${content}'
    </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="com.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>

<!--    根据id删除记录-->
    <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>

com/java/mapper/UserDaoMapper.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="com.java.dao.impl.UserDaoImpl">
     <!-- 
		1.select语句返回多条User实体对象
		resultType="cn.java.entity.User"表示返回User实体类
	 -->
    <select id="getAllUser" resultType="com.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="com.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>

src/main/resources文件夹

src/main/resources/log4j.properties


# log4J日志框架的配置文件 文件名字不能改
# 第一句：控制日志的输出级别及往哪里输出信息
# 日志的输出级别：fatal>error>warn>info>debug
# 日志输出在控制台：Console

log4j.rootLogger=DEBUG, CONSOLE

#也可以如下设置，提高总的输出级别，但是降低某一个包或类或方法的级别，这样可以减少输出日志信息
#log4j.rootLogger=ERROR,CONSOLE
#log4j.logger.cn.java.dao.impl=DEBUG
#负责输出日志的类，格式
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

src/main/resources/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>

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

	<!-- 配置数据库连接环境：driver、url、username、password -->
	<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="driver" value="com.mysql.jdbc.Driver"/> -->
				<property name="url" value="jdbc:mysql://localhost:3306/myschool?characterEncoding=utf8&amp;useSSL=false&amp;serverTimezone=UTC&amp;rewriteBatchedStatements=true"/>
				<!-- 				<property name="url" value="jdbc:mysql://localhost:3306/myschool"/> -->
				<property name="username" value="root"/>
				<property name="password" value="密码"/>
			</dataSource>
	</environment>

	</environments>
	<!-- 关联局部SQL映射配置文件 ，在每一个mapper里，指定SQL映射文件名及全路径，可使用“copy qualified name””-->
	<mappers>
		<mapper resource="com/java/mapper/UserDaoMapper.xml"/>
		<mapper resource="com/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.12</version>
        </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.8.1</version>-->
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>utf-8</encoding>
                </configuration>
            </plugin>
        </plugins>

    </build>


</project>

四、数据库表结构

course表：
在这里插入图片描述

users表：
在这里插入图片描述

五、运行结果

CourseDaoImpl.java程序的运行结果及SQL语句截图：
getAllCourse()：
在这里插入图片描述
getAllCourseMap()：

getCourseById()

getCourseByMulCondition()

addCourse()

addCourseBatch()

getCourseByDynam()

在这里插入图片描述
updateCourseByDynam()

deleteCourseById()

deleteCourseByIds()

GCTTTTTT

关注

3
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
1
评论
MyBatis框架的配置及使用MyBatis框架对表进行CRUD（增删改查）练习（软件工程综合实践课程第七周作业）

软件工程综合实践课程第七周作业（MyBatis框架的配置及使用MyBatis框架对表进行CRUD（增删改查）练习）
复制链接

扫一扫