-
软件工程综合实践课程第八周作业（MyBatis框架的优化练习及MyBatis框架的多表查询练习（一对多，多对一，多对多））
文章目录
一、要求
MyBatis框架的优化练习要求
要求：使用 mybatis 框架对数据表进行 CRUD 操作。
步骤：
（1） 数据库准备： 在 MySchool 数据库中，建立一个student 表，表结构如下：
student(
id bigint(20) 自增,
sname varchar(40),
dept varchar(40),
age int)
并在表中插入几条数据，其中一条为自己的信息 （2） 创建 Maven项目，项目名为” ” week8_ 学号_1 ” ；
项目的包名及类名要符合规范；
每个类前要加上文档注释模板；
完成对 student 表的 CRUD 操作；
封装 Mybatis架 框架 session 对象的工具类； 只使用 mapper层接口和 SQL 配置文件，不用 mapper 层接口的实现类；
对测试类使用 @Before 和 @After 注解，优化代码；
在 Mybatis 配置文件中，配置实体类包的别名，简化代码;
使用单元测试进行代码测试；
将程序的运行结果截屏，复制到一个 word 文件中 ， 和项目一起提交。MyBatis框架的多表查询练习要求
作业要求：
利用instructor表和department表，完成以下查询：
一对多：根据系的名字，查询该系及其包含的老师信息；
多对一：根据老师的ID，查询每个老师及其所属系的信息；
利用instructor表、course表和teaches表，完成以下查询：
多对多：根据课程的ID，查询该课程及其授课老师的信息；
多对多：根据老师的ID，查询每个老师及其所授课程的信息；
创建普通项目，项目名为” week8 __ 学号_ _2 2”；
使用Idea自动生成相关表的实体类；
项目的包名及类名要符合规范；
使用实体类别名，简化代码；
使用包名完成局部SQL配置文件和主配置文件的关联；
将程序的运行结果截屏，复制到一个word文件中，和项目一 起提交。二、知识总结
1、MyBatis 框架的优化练习知识总结
编程规范
- 项目名：英文名
- 包名：公司域名倒写，如 cn.edu.gdufs
- 类名：大驼峰，如 UserMapper
- 方法或属性名:小驼峰，如 getUser
- 实体层：entity,model,bean,pojo(Spring 框架用, 如 cn.edu.gdufs.pojo)
其中的类：关系表名 - 数据访问层（持久层）：dao, mapper （MyBatis 建议用,如 cn.edu.gdufs.mapper）
其中的接口：实体类名+Mapper
接口的实现类：实体类名+Mapper+Impl - 业务逻辑层：service, 如 cn.edu.gdufs.service
其中的接口：实体类名+Service
接口的实现类：实体类名+ Service +Impl - 控制器层:controller,如 cn.edu.gdufs.controller
接口的类：实体类名+ Controller - 注释：
类上和方法上使用文档注释/** /
方法里面使用多行/ */或单行//
封装一个用来获取MyBatis中 Session的工具类
MybatisUtil.java
package cn.java.utils; import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.SqlSession; import org.apache.ibatis.session.SqlSessionFactory; import org.apache.ibatis.session.SqlSessionFactoryBuilder; import java.io.IOException; import java.io.InputStream; public class MybatisUtil { // 获取SqlSession public static SqlSession getSession(){ SqlSession session=null; InputStream inputStream=null; try { //配置文件的路径 String resource = "mybatis.xml"; //加载配置文件，得到一个输入流 inputStream = Resources.getResourceAsStream(resource); //获取MyBatis的Session工厂 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); //通过session工厂获取到一个session session = sqlSessionFactory.openSession(true); //true表示自动提交事务 //调用session的查询集合方法 return session; } catch (IOException e) { e.printStackTrace(); }finally { try { inputStream.close(); } catch (IOException e) { e.printStackTrace(); } } return null; } // 关闭SqlSession public static void closeSession(SqlSession session){ if(session!=null){ session.close(); } } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
使用database.properties 文件进行数据库连接相关配置
database.properties
#mysql8 driver=com.mysql.cj.jdbc.Driver url=jdbc:mysql://localhost:3306/myschool?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&rewriteBatchedStatements=true username=root password=密码 #mysql 5 #driver=com.mysql.jdbc.Driver #url=jdbc:mysql://localhost:3306/myschool?useUnicode=true&characterEncoding=utf8 #username=root #password=- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
需要在主配置文件mybatis.xml中引入配置文件！
<!-- 引入数据库配置文件 --> <properties resource="database.properties"/>- 1
- 2
在mybatis.xml中使用"${…}"即可取到database.properties中对应的值
使用@Before 和@After 注解，简化代码
在测试类中的某个方法前加 @Before 注解 ， 可以使得在执行其他方法前 ， 先执行该方法，如以下代码：
@Before public void init(){ session= MybatisUtil.getSession (); //um 就是 Mapper 的实现类 um= session.getMapper(UserMapper.class); }- 1
- 2
- 3
- 4
- 5
- 6
在测试类中的某个方法前加 @After 注解，可以使得在执行其他方法后，再执行该方法，如以下代码：
@After public void destory(){ //关闭 session 会话 MybatisUtil. closeSession (session); }- 1
- 2
- 3
- 4
- 5
使用别名
指定包名，直接给包下所有的实体类取别名，默认的实体类的别名就是类名(不区分小大写)，如 User 实体类的别名可以是 User、user、USER。
<!-- 配置别名 --> <typeAliases> <typeAlias type="cn.java.pojo.Student" alias="student"/> <typeAlias type="cn.java.pojo.User" alias="user"/> </typeAliases>- 1
- 2
- 3
- 4
- 5
使用包名完成局部SQL配置文件和主配置文件的关联
<!-- 关联局部SQL映射配置文件 ，在每一个mapper里，指定SQL映射文件名及全路径，可使用“copy qualified name””--> <mappers> <!-- <mapper resource="cn/java/mapper/UserMapper.xml"/>--> <!-- <mapper resource="cn/java/mapper/StudentMapper.xml"/>--> <!-- 使用包名完成局部SQL配置文件和主配置文件的关联--> <!-- 直接映射包的名字，那么这个包下面所有的 Mapper 配置文件全部关联！ <package name="cn.java.mapper"/> </mappers>- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
2、MyBatis框架的多表查询练习知识总结
关系型数据库中，表与表之间的联系可以分为：
- 一对一 (1:1)
- 一对多(1:n )
- 多对一（n:1）
- 多对多m (n:m )
resultMap
resultMap 标签可以表示两个表之间的关系
一对多（使用collection）
例：一个系可以有多个学生，则 系 和 学生 是一对多的关系
如果想查询每个系的学生信息时，可以在DepartmentMapper.xml 局部配置文件中,使用 resultMap 标签进行如下配置：<resultMap id="departmentMap" type="cn.java.pojo.Department"> <!—定义主键--> <id property="deptName" column="dept_name"/> <result property="building" column="building"/> <!—定义普通属性--> <result property="budget" column="budget"/> <collection property="students" ofType="cn.java.pojo.Student"> <id property="ID" column="ID"/> <result property="sname" column="name"/> <result property="sdept" column="dept_name"/> <result property="tot_cred" column="tot_cred"/> collection> resultMap>- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
多对一（一对一或多对一）（使用association）
一对一
例：一个系有一个系主任，则 系 和 系主任 是一对一的关系，如果想查询每个系的系主任信息时，可以在DepartmentMapper.xml 局部配置文件中,使用 resultMap 标签进行如下配置：
<resultMap id="departmentMap" type="cn.java.pojo.Department"> <!—定义主键--> <id property="deptName" column="dept_name"/> <result property="building" column="building"/> <!—定义普通属性--> <result property="budget" column="budget"/> <!—每个系有一个系主任，表达一对一联系--> <association property="Dean" javaType="cn.java.pojo.Dean"> <id property="id" column="did"/> <result property="name" column="name"/> association> resultMap>- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
多对一
例：多个老师属于同一个系，则 老师 和 系 是多对一的关系，如果想查询每个系的系主任信息时，可以在InstructorMapper.xml 局部配置文件中,使用 resultMap 标签进行如下配置(实体类使用别名简化了代码）：
<resultMap id="TeacherMap" type="Instructor"> <id property="id" column="ID"/> <result property="name" column="name" /> <result property="deptName" column="dept_name" /> <result property="salary" column="salary" /> <association property="department" javaType="Department"> <id property="deptName" column="dept_name"/> <result property="building" column="building"/> <result property="budget" column="budget"/> association> resultMap>- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
重要标签或属性说明
<resultMap id="departmentMap" type="cn.java.pojo.Department">- 1
功能： resultMap： 进行多表查询的查询结果集说明；
id: 给结果集命名，要唯一
type: 对应相应的实体类<id property="deptName" column="dept_name"/>- 1
功能：定义该实体类的主键 property=“deptName” 定义在实体类中的主键的属性名
column="dept_name"定义在关系表中的主键的字段名
属性名指的是在项目中实体类（pojo包）中对应写的属性名，而字段名指的是在数据表中对应的列名！一般数据表中使用下划线“_”来连接两个词（如dept_name），而在实体类中使用驼峰法命名（如deptName）<result property="building" column="building"/>- 1
功能： 定义实体类的普通属性
property=" building " 定义在实体类中的普通属性名
column=" building "定义在关系表中的普通字段名<collection property="students" ofType="cn.java.bean.Student">- 1
功能：定义一对多关系，如一个系里有多个学生，定义多方的数据集合
property=“students” 定义多方学生集合
ofType=“cn.java.bean.Student” 定义对应的实体类<association property="Dean" javaType="cn.java.bean.Dean">- 1
功能：定义一对一或多对一关系，如一个系对应一个系主任，多个老师对应一个系
多对多
注意多对多配置完resultMap后要记得配置对应的实体类！！
例：
观察 student 表和 course 表，两个表之间的关系是多对多联系，即每个学生可以选修多门课，每门课程可以由多位学生学习
第三方表： takes 表，该表存储学生选修某门课程的成绩数据；
注意：多对多联系一定涉及到 3 个表；
查询需求：查询每个学生选修的课程信息，及课程的分数。分析：每个学生（对应Student实体类）可以选修多门课程（对应Course实体类），因此后面会在Student实体类中添加一个List
courseListtakeList 的属性及其对应的get/set方法修改 Student 实体类
- 在== Student 实体类中==，添加一个 List
courseList
private List<Course> courseList ; //表示某个学生的选的课程（可能不止一节课）- 1
- 为该属性生成相应的 get/set 方法；
修改 Course 实体类
- 在 Course 实体类中，添加一个 ==List
takeList ==属性:
private List<Takes> takesList; //表示某门课程的分数情况- 1
- 为该属性生成相应的 get/set 方法；
编写 sql 映射文件 StudentMapper.xml
<resultMap id" ="StudentCourseTakesMap" type ="cn.java.pojo.Student"> <id property" ="id" column ="ID"/> <result property" ="name" column" ="name" /> <result property" ="deptName" column" ="dept_name" /> <result property" ="totCred" column" ="tot_cred" /> <collection property" ="courseList" ofType ="cn.java.bean.Course"> <id property" ="courseId" column ="course_id"/> <result property" ="title" column ="title"/> <result property" ="deptName" column ="dept_name"/> <result property" ="credits" column ="credits"/> <collection property" ="takesList" ofType ="cn.java.bean.Takes"> <id property" ="id" column ="ID"/> <id property" ="courseId" column ="course_id"/> <id property" ="secId" column ="sec_id"/> <id property" ="semester" column ="semester"/> <id property" ="year" column ="year"/> <result property" ="grade" column ="grade"/> collection> collection> resultMap> <select id" ="getStudGrade" resultMap ="StudentCourseTakesMap"> SELECT * FROM student,takes,course WHERE student. `ID`=takes. `ID` AND course. `course_id`=takes. `course_id` select>- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
三、项目结构
week8_学号_1
week8_学号_2
四、完整参考代码
week8_学号_1项目参考代码
pom.xml
<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.0modelVersion> <groupId>org.examplegroupId> <artifactId>week8_学号_1artifactId> <version>1.0-SNAPSHOTversion> <properties> <maven.compiler.source>8maven.compiler.source> <maven.compiler.target>8maven.compiler.target> properties> <dependencies> <dependency> <groupId>mysqlgroupId> <artifactId>mysql-connector-javaartifactId> <version>8.0.13version> dependency> <dependency> <groupId>org.mybatisgroupId> <artifactId>mybatisartifactId> <version>3.4.5version> dependency> <dependency> <groupId>junitgroupId> <artifactId>junitartifactId> <version>4.12version> dependency> <dependency> <groupId>commons-logginggroupId> <artifactId>commons-loggingartifactId> <version>1.2version> dependency> <dependency> <groupId>org.apache.logging.log4jgroupId> <artifactId>log4j-apiartifactId> <version>2.11.0version> dependency> <dependency> <groupId>org.apache.logging.log4jgroupId> <artifactId>log4j-coreartifactId> <version>2.11.0version> dependency> <dependency> <groupId>org.slf4jgroupId> <artifactId>slf4j-log4j12artifactId> <version>1.7.25version> dependency> dependencies> <build> <resources> <resource> <directory>src/main/javadirectory> <includes> <include>**/*.xmlinclude> includes> resource> resources> <plugins> <plugin> <groupId>org.apache.maven.pluginsgroupId> <artifactId>maven-compiler-pluginartifactId> <configuration> <source>1.8source> <target>1.8target> <encoding>utf-8encoding> configuration> plugin> plugins> build> project>- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
cn/java/utils包
cn/java/utils/MybatisUtil.java
package cn.java.utils; import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.SqlSession; import org.apache.ibatis.session.SqlSessionFactory; import org.apache.ibatis.session.SqlSessionFactoryBuilder; import java.io.IOException; import java.io.InputStream; public class MybatisUtil { // 获取SqlSession public static SqlSession getSession(){ SqlSession session=null; InputStream inputStream=null; try { //配置文件的路径 String resource = "mybatis.xml"; //加载配置文件，得到一个输入流 inputStream = Resources.getResourceAsStream(resource); //获取MyBatis的Session工厂 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); //通过session工厂获取到一个session session = sqlSessionFactory.openSession(true); //true表示自动提交事务 //调用session的查询集合方法 return session; } catch (IOException e) { e.printStackTrace(); }finally { try { inputStream.close(); } catch (IOException e) { e.printStackTrace(); } } return null; } // 关闭SqlSession public static void closeSession(SqlSession session){ if(session!=null){ session.close(); } } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
cn/java/pojo包
cn/java/pojo/Student.java
package cn.java.pojo; /** * @projectName: week8_ _1 * @package: cn.java.pojo * @className: Student * @author: GCT * @description: TODO * @date: 2022/10/18 21:49 * @version: 1.0 */ public class Student { private Long id; private String sname; private String dept; private int age; public Student() { } public Student(Long id, String sname, String dept, int age) { this.id = id; this.sname = sname; this.dept = dept; this.age = age; } public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getSname() { return sname; } public void setSname(String sname) { this.sname = sname; } public String getDept() { return dept; } public void setDept(String dept) { this.dept = dept; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "Student{" + "id=" + id + ", sname='" + sname + '\'' + ", dept='" + dept + '\'' + ", age=" + age + '}'; } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
cn/java/pojo/User.java
package cn.java.pojo; 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 + "]"; } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
cn/java/mapper包
cn/java/mapper/StudentMapper.java
package cn.java.mapper; import cn.java.pojo.Student; import cn.java.pojo.User; import org.apache.ibatis.annotations.Select; import java.util.List; import java.util.Map; public interface StudentMapper { // 该方法使用Student实体类 public List<Student> getAllStudent(); //直接在以下方法上加@Select注解，简化代码 @Select("select * from student") public List<Student> findAllStudent(); // 该方法返回多条记录，不使用实体类，用Map数据类型去接受 public List<Map<String, Object>> getAllStudentMap(); // 该方法使用了带一个参数的查询语句，返回一条记录 public Map<String, Object> getStudentById(long id); // 该方法使用了有多个参数的 select语句 public Map<String, Object> getStudentByMulCondition(Map<String, Object> map); // 该方法插入一条记录，带参数，更新操作一定要提交事务 public int addStudent(Map<String, Object> map); // 该方法插入多条记录，带参数，更新操作一定要提交事务 public int addStudentBatch(List<Student> list) ; // 该方法使用了动态查询，查询条件不确定 public List<Map<String, Object>> getStudentByDynam(Map<String, Object> map) ; // 该方法使用了动态修改，查询条件不确定 public int updateStudentByDynam(Map<String, Object> map) ; // 根据id删除记录 public int deleteStudentById(int id); // 根据多个id删除多条记录 public int deleteStudentByIds(int[] ids); }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
cn/java/mapper/StudentMapper.xml
DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="cn.java.mapper.StudentMapper"> <select id="getAllStudent" resultType="student"> SELECT * FROM student select> <select id="getAllStudentMap" resultType="Map"> SELECT * FROM student select> <select id="getStudentById" resultType="map" parameterType="Long"> SELECT * FROM student WHERE id=#{0} select> <select id="getStudentByMulCondition" resultType="map" parameterType="Map"> SELECT * FROM student WHERE sname='${sname}' AND dept='${dept}' AND age='${age}' select> <insert id="addStudent" parameterType="Map"> INSERT INTO student SET sname=#{sname},dept=#{dept},age=#{age} insert> <insert id="addStudentBatch" parameterType="student"> insert into student(sname,dept,age) values <foreach collection="list" item="student" separator=","> (#{student.sname},#{student.dept},#{student.age}) foreach> insert> <select id="getStudentByDynam" resultType="Map" parameterType="Map"> SELECT * FROM student <where> <if test="sname!=null"> sname=#{sname} if> <if test="dept!=null"> and dept=#{dept} if> <if test="age!=null"> and age=#{age} if> where> select> <update id="updateStudentByDynam" parameterType="Map"> update student <set> <if test="sname!=null"> sname=#{sname}, if> <if test="dept!=null"> dept=#{dept}, if> <if test="age!=null"> age=#{age}, if> id=#{id} set> where id=#{id} update> <delete id="deleteStudentById" parameterType="int"> DELETE FROM student WHERE id=#{id} delete> <delete id="deleteStudentByIds" parameterType="int[]" > DELETE FROM student WHERE id IN <foreach collection="array" item="id" open="(" close=")" separator=","> #{id} foreach> delete> mapper>- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
cn/java/mapper/UserMapper.java
package cn.java.mapper; import cn.java.pojo.User; import org.apache.ibatis.annotations.Select; import java.util.List; import java.util.Map; /** * description: * author : * date: 2020/10/3 */ public interface UserMapper { // 该方法使用User实体类 public List<User> getAllUser(); //直接在以下方法上加@Select注解，简化代码 @Select("select * from users") public List<User> findAllUser(); // 该方法返回多条记录，不使用实体类，用Map数据类型去接受 public List<Map<String, Object>> getAllUserMap(); // 该方法使用了带一个参数的查询语句，返回一条记录 public Map<String, Object> getUserById(long id); // 该方法使用了有多个参数的 select语句 public Map<String, Object> getUserByMulCondition(Map<String, Object> map); // 该方法插入一条记录，带参数，更新操作一定要提交事务 public int addUser(Map<String, Object> map); // 该方法插入多条记录，带参数，更新操作一定要提交事务 public int addUserBatch(List<User> list) ; // 该方法使用了动态查询，查询条件不确定 public List<Map<String, Object>> getCourseByDynam(Map<String, Object> map) ; // 该方法使用了动态修改，查询条件不确定 public int updateCourseByDynam(Map<String, Object> map) ; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
cn/java/mapper/UserMapper.xml
DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="cn.java.mapper.UserMapper"> <select id="getAllUser" resultType="user"> SELECT * FROM users select> <select id="getAllUserMap" resultType="Map"> SELECT * FROM users select> <select id="getUserById" resultType="map" parameterType="Long"> SELECT * FROM users WHERE id=#{0} select> <select id="getUserByMulCondition" resultType="map" parameterType="Map"> SELECT * FROM users WHERE username='${username}' AND PASSWORD='${pwd}' select> <insert id="addUser" parameterType="Map"> INSERT INTO users SET username=#{username},PASSWORD=#{password} insert> <insert id="addUserBatch" parameterType="user"> insert into users(username,PASSWORD) values <foreach collection="list" item="user" separator=","> (#{user.username},#{user.password}) foreach> insert> <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> <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>- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
src/main/resources包
database.properties
#mysql8 driver=com.mysql.cj.jdbc.Driver url=jdbc:mysql://localhost:3306/myschool?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&rewriteBatchedStatements=true username=root password=密码 #mysql 5 #driver=com.mysql.jdbc.Driver #url=jdbc:mysql://localhost:3306/myschool?useUnicode=true&characterEncoding=utf8 #username=root #password=- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
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- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
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> <!-- 顺序！--> <!-- properties?,settings?,typeAliases?,typeHandlers?,objectFactory?,objectWrapperFactory?,reflectorFactory?,plugins?,environments?,databaseIdProvider?,mappers?--> <!-- 引入数据库配置文件 --> <properties resource="database.properties"/> <!-- 开启log4j，输出SQL语句 --> <settings> <setting name="logImpl" value="LOG4j"/> </settings> <!-- 配置别名 --> <typeAliases> <typeAlias type="cn.java.pojo.Student" alias="student"/> <typeAlias type="cn.java.pojo.User" alias="user"/> </typeAliases> <!-- 配置数据库连接环境：driver、url、username、password --> <environments default="mysql"> <!-- 开始配置mysql --> <environment id="mysql"> <!--配置事务 --> <transactionManager type="JDBC"></transactionManager> <!-- 配置数据源 --> <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映射配置文件 ，在每一个mapper里，指定SQL映射文件名及全路径，可使用“copy qualified name””--> <mappers> <!-- <mapper resource="cn/java/mapper/UserMapper.xml"/>--> <!-- <mapper resource="cn/java/mapper/StudentMapper.xml"/>--> <!-- 使用包名完成局部SQL配置文件和主配置文件的关联--> <package name="cn.java.mapper"/> </mappers> </configuration>- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
src/test/java包
src/test/java/Test_Student.java
import cn.java.mapper.StudentMapper; import cn.java.mapper.UserMapper; import cn.java.pojo.Student; import cn.java.pojo.User; import cn.java.utils.MybatisUtil; import org.apache.ibatis.session.SqlSession; import org.junit.After; import org.junit.Before; import org.junit.Test; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; /** * @projectName: week8_ _1 * @package: PACKAGE_NAME * @className: Test_Student * @author: GCT * @description: TODO * @date: 2022/10/18 21:59 * @version: 1.0 */ public class Test_Student { // SqlSession session=null; SqlSession session=null; StudentMapper um=null; //Before注解：在每次调用测试方法之前，自动调用init()方法 @Before public void init(){ session= MybatisUtil.getSession(); //um就是Mapper的实现类 um=session.getMapper(StudentMapper.class); } //每次调用测试方法之后，自动调用一下destory() @After public void destory(){ MybatisUtil.closeSession(session); } @Test public void testGetAllStudent(){ um= session.getMapper(StudentMapper.class); List<Student> studentList = um.getAllStudent(); for (Student student : studentList) { System.out.println(student); } } @Test public void testFindAllStudent(){ List<Student> studentList = um.findAllStudent(); for (Student student : studentList) { System.out.println(student); } } @Test // 2.该方法返回多条记录，不使用实体类，用Map数据类型去接受 public void testGetAllStudentMap() { List<Map<String, Object>> studentList =um.getAllStudentMap(); for (Map<String, Object> map : studentList) { System.out.println(map); } } @Test // 3.该方法使用了带一个参数的查询语句，返回一条记录 public void testGetStudentById() { // 传递参数，直接传 Long id =2L; Map<String, Object> studentMap = um.getStudentById(id); System.out.println(studentMap); } @Test // 4.该方法使用了有多个参数的 select语句 public void testGetStudentByMulCondition() { // 声明一个Map对象，可以使用Map或实体类同时传递多个参数，用map更简单 Map<String, Object> paramMap = new HashMap<String, Object>(); // 封装参数 paramMap.put("sname", "ss"); paramMap.put("dept", "ss"); paramMap.put("age", "1"); // 传递参数 Map<String, Object> studentMap = um.getStudentByMulCondition(paramMap); System.out.println(studentMap); } // 5.该方法插入一条记录，带参数，更新操作一定要提交事务 @Test public void testAddStudent() { Map<String, Object> paramMap = new HashMap<String, Object>(); paramMap.put("sname", "test"); paramMap.put("dept", "test"); paramMap.put("age", "2"); int resultInt = um.addStudent(paramMap); System.out.println(resultInt); } // 6.该方法插入多条记录，带参数，更新操作一定要提交事务 @Test public void testAddStudentBatch() { List<Student> list = new ArrayList<>(); Student student; for (int i = 0; i < 10; i++) { student = new Student(); student.setSname("test" + i); student.setDept("test666"); student.setAge(i); list.add(student); } int resultInt = um.addStudentBatch(list); System.out.println(resultInt); }; // 7.该方法使用了动态查询，查询条件不确定 @Test public void getStudentByDynam() { // 可以使用Map或实体类同时传递多个参数 Map<String, Object> paramMap = new HashMap<String, Object>(); paramMap.put("sname", "test"); paramMap.put("dept", "test"); paramMap.put("age", "2"); List<Map<String, Object>> studentList =um.getStudentByDynam(paramMap); for (Map<String, Object> map : studentList) { System.out.println(map); } } // 8.该方法使用了动态修改，查询条件不确定 @Test public void updateStudentByDynam() { // 可以使用Map或实体类同时传递多个参数 Map<String, Object> paramMap = new HashMap<String, Object>(); paramMap.put("id",1); paramMap.put("sname", "test"); paramMap.put("dept", "test"); paramMap.put("age", "2"); int resultInt = um.updateStudentByDynam(paramMap); System.out.println(resultInt); } @Test public void deleteStudentById(){ int id = 80; int resInt = um.deleteStudentById(id); System.out.println(resInt); } @Test public void deleteStudentByIds(){ int[] ids = new int[]{77,78,79}; int resInt = um.deleteStudentByIds(ids); System.out.println(resInt); } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
- 165
- 166
src/test/java/Test_User.java
import cn.java.mapper.UserMapper; import cn.java.pojo.User; import cn.java.utils.MybatisUtil; import org.apache.ibatis.session.SqlSession; import org.junit.After; import org.junit.Before; import org.junit.Test; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; /** * description: * author :hj * date: 2020/10/12 */ public class Test_User { // SqlSession session=null; SqlSession session=null; UserMapper um=null; //Before注解：在每次调用测试方法之前，自动调用init()方法 @Before public void init(){ session= MybatisUtil.getSession(); //um就是Mapper的实现类 um=session.getMapper(UserMapper.class); } //每次调用测试方法之后，自动调用一下destory() @After public void destory(){ MybatisUtil.closeSession(session); } @Test public void testGetAllUser(){ um= session.getMapper(UserMapper.class); List<User> userList = um.getAllUser(); for (User user : userList) { System.out.println(user); } } @Test public void testFindAllUser(){ SqlSession session = MybatisUtil.getSession(); //MyBatis在底层,使用反射技术自动生成Mapper实现类，不需要实现类了 //um就是Mapper的实现类 UserMapper um= session.getMapper(UserMapper.class); List<User> userList = um.findAllUser(); for (User user : userList) { System.out.println(user); } } @Test // 2.该方法返回多条记录，不使用实体类，用Map数据类型去接受 public void testGetAllUserMap() { List<Map<String, Object>> userList =um.getAllUserMap(); for (Map<String, Object> map : userList) { System.out.println(map); } } @Test // 3.该方法使用了带一个参数的查询语句，返回一条记录 public void testGetUserById() { // 传递参数，直接传 Long id =2L; Map<String, Object> userMap = um.getUserById(id); System.out.println(userMap); } @Test // 4.该方法使用了有多个参数的 select语句 public void testGetUserByMulCondition() { // 声明一个Map对象，可以使用Map或实体类同时传递多个参数，用map更简单 Map<String, Object> paramMap = new HashMap<String, Object>(); // 封装参数 paramMap.put("username", "admin"); paramMap.put("pwd", "123"); // 传递参数 Map<String, Object> userMap = um.getUserByMulCondition(paramMap); System.out.println(userMap); } // 5.该方法插入一条记录，带参数，更新操作一定要提交事务 @Test public void testAddUser() { Map<String, Object> paramMap = new HashMap<String, Object>(); paramMap.put("username", "Rose"); paramMap.put("password", "1234"); int resultInt = um.addUser(paramMap); System.out.println(resultInt); } // 6.该方法插入多条记录，带参数，更新操作一定要提交事务 @Test public void testAddUserBatch( ) { 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 = um.addUserBatch(list); System.out.println(resultInt); }; // 7.该方法使用了动态查询，查询条件不确定 @Test public void getCourseByDynam() { // 可以使用Map或实体类同时传递多个参数 Map<String, Object> paramMap = new HashMap<String, Object>(); paramMap.put("cname", "数据结构"); paramMap.put("credit", 4); paramMap.put("department", "软件工程"); List<Map<String, Object>> courseList =um.getCourseByDynam(paramMap); for (Map<String, Object> map : courseList) { System.out.println(map); } } // 8.该方法使用了动态修改，查询条件不确定 @Test public void updateCourseByDynam() { // 可以使用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 = um.updateCourseByDynam(paramMap); System.out.println(resultInt); } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
week8_学号_2项目参考代码
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>week8_20201003016_2</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> </dependencies> <!--如果是WEB项目，那么不用创建bulid标签--> <build> <!--编译的时候同时也把包下面的xml同时编译进去--> <resources> <resource> <directory>src/main/java</directory> <includes> <include>**/*.xmlorg.apache.maven.plugins maven-compiler-plugin 1.8 1.8 utf-8 - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
cn/java/utils包
cn/java/utils/MybatisUtil.java
package cn.java.utils; import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.SqlSession; import org.apache.ibatis.session.SqlSessionFactory; import org.apache.ibatis.session.SqlSessionFactoryBuilder; import java.io.IOException; import java.io.InputStream; /** * description: * author :hj * date: 2020/10/11 */ public class MybatisUtil { // 获取SqlSession public static SqlSession getSession(){ SqlSession session=null; InputStream inputStream=null; try { //配置文件的路径 String resource = "mybatis.xml"; //加载配置文件，得到一个输入流 inputStream = Resources.getResourceAsStream(resource); //获取MyBatis的Session工厂 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); //通过session工厂获取到一个session session = sqlSessionFactory.openSession(true); //true表示自动提交事务 //调用session的查询集合方法 return session; } catch (IOException e) { e.printStackTrace(); }finally { try { inputStream.close(); } catch (IOException e) { e.printStackTrace(); } } return null; } // 关闭SqlSession public static void closeSession(SqlSession session){ if(session!=null){ session.close(); } } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
cn/java/pojo包
cn/java/pojo/Course.java
package cn.java.pojo; import java.util.List; public class Course { private String courseId; private String title; private String deptName; private double credits; //表示含义 每个课程由多个老师授课 private List<Instructor> instructorList; //老师集合 public List<Instructor> getInstructorList() { return instructorList; } public void setInstructorList(List<Instructor> instructorList) { this.instructorList = instructorList; } public String getCourseId() { return courseId; } public void setCourseId(String courseId) { this.courseId = courseId; } public String getTitle() { return title; } public void setTitle(String title) { this.title = title; } public String getDeptName() { return deptName; } public void setDeptName(String deptName) { this.deptName = deptName; } public double getCredits() { return credits; } public void setCredits(double credits) { this.credits = credits; } @Override public String toString() { return "Course{" + "courseId='" + courseId + '\'' + ", title='" + title + '\'' + ", deptName='" + deptName + '\'' + ", credits=" + credits + '}'; } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
cn/java/pojo/Department.java
package cn.java.pojo; import java.util.List; public class Department { private String deptName; private String building; private double budget; //表示含义 1个系里有多个老师 private List<Instructor> instructors; //老师集合 多的一方 public List<Instructor> getInstructors() { return instructors; } public void setInstructors(List<Instructor> instructors) { this.instructors = instructors; } public String getDeptName() { return deptName; } public void setDeptName(String deptName) { this.deptName = deptName; } public String getBuilding() { return building; } public void setBuilding(String building) { this.building = building; } public double getBudget() { return budget; } public void setBudget(double budget) { this.budget = budget; } // 测试类中System.out.println("系的信息是 " + dept);会用到toString @Override public String toString() { return "Department{" + "deptName='" + deptName + '\'' + ", building='" + building + '\'' + ", budget=" + budget + // ", instructors=" + instructors + '}'; } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
cn/java/pojo/Instructor.java
package cn.java.pojo; import java.util.List; public class Instructor { private String id; private String name; private String deptName; private double salary; //表示含义 老师属于哪个系 private Department department; //系 多对一中“1”的一方 //表示含义 每个老师授多门课程 private List<Teaches> teachesList; //老师教授的课程集合 public List<Teaches> getTeachesList() { return teachesList; } public void setTeachesList(List<Teaches> teachesList) { this.teachesList = teachesList; } public Department getDepartment() { return department; } public void setDepartment(Department department) { this.department = department; } public String getId() { return id; } public void setId(String id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getDeptName() { return deptName; } public void setDeptName(String deptName) { this.deptName = deptName; } public double getSalary() { return salary; } public void setSalary(double salary) { this.salary = salary; } @Override public String toString() { return "Instructor{" + "id='" + id + '\'' + ", name='" + name + '\'' + ", deptName='" + deptName + '\'' + ", salary=" + salary + // ", department=" + department + '}'; } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
cn/java/pojo/Teaches.java
package cn.java.pojo; import java.util.List; public class Teaches { private String id; private String courseId; private String secId; private String semester; private double year; //表示含义 该老师的信息 private Instructor instructor; //该老师的信息 //表示含义 该老师授课课程（可能不止一个）及其信息 private List<Course> courseList; //老师教授的课程集合 public Instructor getInstructor() { return instructor; } public void setInstructor(Instructor instructor) { this.instructor = instructor; } public List<Course> getCourseList() { return courseList; } public void setCourseList(List<Course> courseList) { this.courseList = courseList; } public String getId() { return id; } public void setId(String id) { this.id = id; } public String getCourseId() { return courseId; } public void setCourseId(String courseId) { this.courseId = courseId; } public String getSecId() { return secId; } public void setSecId(String secId) { this.secId = secId; } public String getSemester() { return semester; } public void setSemester(String semester) { this.semester = semester; } public double getYear() { return year; } public void setYear(double year) { this.year = year; } @Override public String toString() { return "Teaches{" + "id='" + id + '\'' + ", courseId='" + courseId + '\'' + ", secId='" + secId + '\'' + ", semester='" + semester + '\'' + ", year=" + year + '}'; } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
cn/java/mapper包
cn/java/mapper/CourseMapper.java
package cn.java.mapper; import cn.java.pojo.Course; import java.util.List; public interface CourseMapper { /** * @param : * @return List* @author GCT * @description 多对多：查询全部课程及其授课老师的信息； * @date 2022/10/19 20:48 */ public List<Course> getAllCourseAndTeacher(); /** * @param Cid: * @return Course * @author GCT * @description 多对多：根据课程的ID，查询该课程及其授课老师的信息； * @date 2022/10/19 20:46 */ public Course getAllCourseAndTeacherByCid(String Cid); }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
cn/java/mapper/CourseMapper.xml
DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="cn.java.mapper.CourseMapper"> <resultMap id="TeachesInstructorCourseMap" type="Course"> <id property="courseId" column="course_id"/> <result property="title" column="title"/> <result property="deptName" column="dept_name"/> <result property="credits" column="credits"/> <collection property="instructorList" ofType="Instructor"> <id property="id" column="ID"/> <result property="name" column="name"/> <result property="deptName" column="dept_name"/> <result property="salary" column="salary"/> <collection property="teachesList" ofType="Teaches"> <id property="id" column="ID"/> <id property="courseId" column="course_id"/> <id property="secId" column="sec_id"/> <id property="semester" column="semester"/> <id property="year" column="year"/> collection> collection> resultMap> <select id="getAllCourseAndTeacher" resultMap="TeachesInstructorCourseMap"> SELECT * FROM course C, teaches T, instructor I WHERE C.course_id = T.course_id AND T.id = I.id select> <select id="getAllCourseAndTeacherByCid" resultMap="TeachesInstructorCourseMap"> SELECT * FROM course C, teaches T, instructor I WHERE C.course_id = T.course_id AND T.id = I.id AND C.course_id = #{Cid} select> mapper>- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
cn/java/mapper/DepartmentMapper.java
package cn.java.mapper; import cn.java.pojo.Department; import java.util.List; /** * description: * author :hj * date: 2020/10/17 */ public interface DepartmentMapper { /** * @param : * @return List* @author GCT * @description 一对多：查询所有系及其包含的老师信息 * @date 2022/10/20 15:33 */ public List<Department> getAllDeptAndTeacher(); /** * @param dept: * @return Department * @author GCT * @description 一对多：根据系的名字，查询该系及其包含的老师信息 * @date 2022/10/19 20:41 */ public Department getDeptAndTeacherByDName(String DName); }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
cn/java/mapper/DepartmentMapper.xml
DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="cn.java.mapper.DepartmentMapper"> <resultMap id="departmentMap" type="Department"> <id property="deptName" column="dept_name"/> <result property="building" column="building"/> <result property="budget" column="budget"/> <collection property="instructors" ofType="Instructor"> <id property="id" column="ID"/> <result property="name" column="name"/> <result property="deptName" column="dept_name"/> <result property="salary" column="salary"/> collection> resultMap> <select id="getAllDeptAndTeacher" resultMap="departmentMap"> select D.*,I.* from department D , instructor I where D.dept_name = I.dept_name select> <select id="getDeptAndTeacherByDName" resultMap="departmentMap"> select D.*,I.* from department D , instructor I where D.dept_name = I.dept_name and D.dept_name=#{dept_name} select> mapper>- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
cn/java/mapper/InstructorMapper.java
package cn.java.mapper; import cn.java.pojo.Instructor; import cn.java.pojo.Teaches; import java.util.List; public interface InstructorMapper { /** * @param : * @return List* @author GCT * @description 多对一：查询每个老师及其所属系的信息 * @date 2022/10/20 15:34 */ public List<Instructor> getAllTeacherAndDept(); /** * 多对一：根据老师的ID，查询每个老师及其所属系的信息 * @param Iid * @return */ public Instructor getTeacherAndDeptByIid(String Iid); /** * @param : * @return List* @author GCT * @description 多对多：查询每个老师及其所授课程的信息 * @date 2022/10/19 20:48 */ public List<Instructor> getAllTeacherAndCourse(); /** * @param Tid: * @return Instructor * @author GCT * @description 多对多：根据老师的ID，查询每个老师及其所授课程的信息 * @date 2022/10/19 20:47 */ public Instructor getTeacherAndCourseByTid(String Tid); }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
cn/java/mapper/InstructorMapper.xml
DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="cn.java.mapper.InstructorMapper"> <resultMap id="TeacherMap" type="Instructor"> <id property="id" column="ID"/> <result property="name" column="name" /> <result property="deptName" column="dept_name" /> <result property="salary" column="salary" /> <association property="department" javaType="Department"> <id property="deptName" column="dept_name"/> <result property="building" column="building"/> <result property="budget" column="budget"/> association> resultMap> <resultMap id="TeachesInstructorCourseMap" type="Instructor"> <id property="id" column="ID"/> <result property="name" column="name" /> <result property="deptName" column="dept_name" /> <result property="salary" column="salary" /> <collection property="teachesList" ofType="Teaches"> <id property="id" column="ID"/> <id property="courseId" column="course_id"/> <id property="secId" column="sec_id"/> <id property="semester" column="semester"/> <id property="year" column="year"/> <collection property="courseList" ofType="Course"> <id property="courseId" column="course_id"/> <result property="title" column="title"/> <result property="deptName" column="dept_name"/> <result property="credits" column="credits"/> collection> collection> resultMap> <select id="getAllTeacherAndDept" resultMap="TeacherMap"> select * from instructor I left join department D on I.dept_name=D.dept_name select> <select id="getTeacherAndDeptByIid" resultMap="TeacherMap"> select * from instructor I left join department D on I.dept_name=D.dept_name where I.id = #{Iid} select> <select id="getAllTeacherAndCourse" resultMap="TeachesInstructorCourseMap"> SELECT * FROM teaches T, instructor I,course C WHERE T.id = I.id AND T.course_id = C.course_id select> <select id="getTeacherAndCourseByTid" resultMap="TeachesInstructorCourseMap"> SELECT * FROM teaches T, instructor I,course C WHERE T.id = I.id AND T.course_id = C.course_id AND T.id = #{Tid} select> mapper>- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
src/main/resources文件夹
src/main/resources/database.properties
#mysql8 driver=com.mysql.cj.jdbc.Driver url=jdbc:mysql://localhost:3306/university?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&rewriteBatchedStatements=true username=root password=你的密码 #mysql 5 #driver=com.mysql.jdbc.Driver #url=jdbc:mysql://localhost:3306/myschool?useUnicode=true&characterEncoding=utf8 #username=root #password=- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
src/main/resources/mybatis.xml
DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration> <properties resource="database.properties"/> <typeAliases> <package name="cn.java.pojo"/> typeAliases> <environments default="mysql"> <environment id="mysql"> <transactionManager type="JDBC">transactionManager> <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> <mappers> <package name="cn.java.mapper"/> mappers> configuration>- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
src/test/java包
src/test/java/TestCourseMapper.java
import cn.java.mapper.CourseMapper; import cn.java.pojo.Course; import cn.java.pojo.Instructor; import cn.java.pojo.Teaches; import cn.java.utils.MybatisUtil; import org.apache.ibatis.session.SqlSession; import org.junit.After; import org.junit.Before; import org.junit.Test; import java.util.List; /** * @projectName: week8_ _2 * @package: PACKAGE_NAME * @className: TestCourseMapper * @author: GCT * @description: TODO * @date: 2022/10/19 21:52 * @version: 1.0 */ public class TestCourseMapper { SqlSession session = null; CourseMapper courseMapper = null; @Before public void init() { session = MybatisUtil.getSession(); //dm就是Mapper的实现类 courseMapper = session.getMapper(CourseMapper.class); // studentMapper = session.getMapper(StudentMapper.class); // takesMapper = session.getMapper(TakesMapper.class); } // 查询全部课程及其授课老师的信息(老师的学习及其教授的课程）； @Test public void getAllCourseAndTeacher() { List<Course> courses = courseMapper.getAllCourseAndTeacher(); for (Course course : courses) { System.out.println("课程的信息是 " + course); System.out.println("================================================"); System.out.println(course.getCourseId()+" 课程的授课教师信息是:"); List<Instructor> instructorList = course.getInstructorList(); for (Instructor instructor : instructorList) { System.out.println(instructor); System.out.println("该教师 "+instructor.getName()+" 教授的课程有:"); List<Teaches> teaches = instructor.getTeachesList(); for (Teaches teach : teaches) { System.out.println(teach); } System.out.println("==========================================="); } System.out.println("==========================================="); } } @Test public void getAllCourseAndTeacherByCid() { Course course = courseMapper.getAllCourseAndTeacherByCid("CS-101"); // for (Course course : courses) { System.out.println("课程的信息是 " + course); System.out.println("================================================"); System.out.println(course.getCourseId()+" 课程的授课教师信息是:"); List<Instructor> instructorList = course.getInstructorList(); for (Instructor instructor : instructorList) { System.out.println(instructor); System.out.println("该教师 "+instructor.getName()+" 教授的课程有:"); List<Teaches> teaches = instructor.getTeachesList(); for (Teaches teach : teaches) { System.out.println(teach); } System.out.println("==========================================="); } System.out.println("==========================================="); // } } @After public void destory () { MybatisUtil.closeSession(session); } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
src/test/java/TestDepartmentMapper.java
import cn.java.mapper.DepartmentMapper; import cn.java.pojo.Department; import cn.java.pojo.Instructor; import cn.java.utils.MybatisUtil; import org.apache.ibatis.session.SqlSession; import org.junit.After; import org.junit.Before; import org.junit.Test; import java.util.List; /** * @projectName: week8_ _2 * @package: PACKAGE_NAME * @className: TestDepartmentMapper * @author: GCT * @description: TODO * @date: 2022/10/19 21:53 * @version: 1.0 */ public class TestDepartmentMapper { SqlSession session=null; DepartmentMapper departmentMapper=null; // StudentMapper studentMapper =null; @Before public void init(){ session= MybatisUtil.getSession(); departmentMapper=session.getMapper(DepartmentMapper.class); // studentMapper = session.getMapper(StudentMapper.class); } //1:n 查询每个系里的老师 @Test public void testGetAllDeptAndTeacher() { List<Department> depts = departmentMapper.getAllDeptAndTeacher(); for (Department dept : depts) { System.out.println("系的信息是 " + dept); // System.out.println("-----------------"); System.out.println("该系包含的老师信息是:"); List<Instructor> instructors = dept.getInstructors(); for (Instructor instructor : instructors) { System.out.println(instructor); } System.out.println("-----------------"); } } // 一对多：根据系的名字，查询该系及其包含的老师信息 @Test public void testGetDeptAndTeacherByDName() { Department dept = departmentMapper.getDeptAndTeacherByDName("Comp. Sci."); System.out.println("该系信息是:" + dept); System.out.println("该系包含的老师信息是:"); List<Instructor> instructors = dept.getInstructors(); for (Instructor instructor : instructors) { System.out.println(instructor); } } @After public void destory(){ MybatisUtil.closeSession(session); } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
src/test/java/TestInstructorMapper.java
import cn.java.mapper.DepartmentMapper; import cn.java.mapper.InstructorMapper; import cn.java.pojo.Course; import cn.java.pojo.Department; import cn.java.pojo.Instructor; import cn.java.pojo.Teaches; import cn.java.utils.MybatisUtil; import org.apache.ibatis.session.SqlSession; import org.junit.After; import org.junit.Before; import org.junit.Test; import java.util.List; /** * @projectName: week8_ _2 * @package: PACKAGE_NAME * @className: TestInstructorMapper * @author: GCT * @description: TODO * @date: 2022/10/19 21:53 * @version: 1.0 */ public class TestInstructorMapper { SqlSession session=null; InstructorMapper instructorMapper=null; // StudentMapper studentMapper =null; @Before public void init(){ session= MybatisUtil.getSession(); instructorMapper=session.getMapper(InstructorMapper.class); } //n:1 多对一，查询所有老师及其所属的系的信息 @Test public void testGetAllTeacherAndDept() { List<Instructor> instructors = instructorMapper.getAllTeacherAndDept(); for (Instructor instructor : instructors) { System.out.println("老师的信息是 " + instructor); // System.out.println("-----------------"); System.out.println("老师对应的系信息是:"); Department dept = instructor.getDepartment(); // for (Instructor instructor : instructors) { System.out.println(dept); // } System.out.println("-----------------"); } } //n:1 多对一，查询老师所属的系的信息 @Test public void getTeacherAndDeptByIid(){ Instructor instructor = instructorMapper.getTeacherAndDeptByIid("15151"); System.out.println("老师的信息是："+instructor); Department dept = instructor.getDepartment(); System.out.println("老师所属系的信息是:"+dept); } //多对多 // 查询全部老师（的信息）及其所授课程的信息(教授的课程（教哪些课）及对应课程的信息）； @Test public void getAllTeacherAndCourse() { List<Instructor> instructors = instructorMapper.getAllTeacherAndCourse(); for (Instructor instructor : instructors) { System.out.println("该老师的信息是 " + instructor); System.out.println("================================================"); System.out.println("该教师 "+instructor.getName()+" 教授的课程及其对应信息如下:"); List<Teaches> teachesList = instructor.getTeachesList(); for (Teaches teach : teachesList) { System.out.println(teach); List<Course> courseList = teach.getCourseList(); for (Course course : courseList) { System.out.println("课程"+course.getCourseId()+"的信息为："); System.out.println(course); System.out.println("---------------------------------"); } } System.out.println("==========================================="); System.out.println("==========================================="); } } //多对多 // 根据老师的ID，查询每个老师（的信息）及其所授课程的信息(教授的课程（教哪些课）及对应课程的信息） @Test public void getTeacherAndCourseByTid() { Instructor instructor = instructorMapper.getTeacherAndCourseByTid("10101"); System.out.println("该老师的信息是 " + instructor); System.out.println("================================================"); System.out.println("该教师 "+instructor.getName()+" 教授的课程及其对应信息如下:"); List<Teaches> teachesList = instructor.getTeachesList(); for (Teaches teach : teachesList) { System.out.println(teach); List<Course> courseList = teach.getCourseList(); for (Course course : courseList) { System.out.println("课程"+course.getCourseId()+"的信息为："); System.out.println(course); System.out.println("---------------------------------"); } } System.out.println("==========================================="); System.out.println("==========================================="); } @After public void destory(){ MybatisUtil.closeSession(session); } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
五、项目中用到的数据库表结构
university数据库
course
department
instructor
teaches
myschool数据库
student表
-
相关阅读:
likely和unlikely的用法
geoserver多种数据源图层发布详解
python 基于aiohttp的异步爬虫实战
形态等位点对迭代次数的贡献
酱菜产业：传承美味，点亮生活
Python知识汇总
intellij idea的快速配置详细使用
前端图片压缩上传，减少等待时间！优化用户体检
聊聊消息中心的设计与实现逻辑
Sqoop Hook
- 原文地址：https://blog.csdn.net/GCTTTTTT/article/details/127431051