mybatis整合spring 之 基于接口映射的多对一关系

最新推荐文章于 2021-07-28 16:36:40 发布
最新推荐文章于 2021-07-28 16:36:40 发布
阅读量154 收藏
点赞数
文章标签： java

转载自：http://my.oschina.net/huangcongmin12/blog/83731

mybatis整合spring 之  基于接口映射的多对一关系。

        项目用到俩个表，即student表和school表。表结构如下：

        school表:

                  

         student表:        

  

     

项目结构如下：


     


 1)applicationContext.xml


?
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
<? xml version = "1.0" encoding = "UTF-8" ?>
< beans xmlns = "http://www.springframework.org/schema/beans"
     xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" xmlns:p = "http://www.springframework.org/schema/p"
     xmlns:context = "http://www.springframework.org/schema/context"
     xmlns:aop = "http://www.springframework.org/schema/aop" xmlns:tx = "http://www.springframework.org/schema/tx"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-3.0.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
     
     <!-- 加载JDBC配置文件 -->
     < context:property-placeholder location = "classpath:jdbc.properties" />
     
     <!-- 扫描类包，将标注Spring注解的类自动转化Bean，同时完成Bean的注入 -->
     < context:component-scan base-package = "com.springbatis.dao" />
     < context:component-scan base-package = "com.springbatis.service" />
     
     <!-- 配置数据源 -->
     < bean id = "dataSource" class = "com.mchange.v2.c3p0.ComboPooledDataSource" >
         < property name = "driverClass" >
             < value >${jdbc.driverClassName}</ value >
         </ property >
         < property name = "jdbcUrl" >
             < value >${jdbc.url}</ value >
         </ property >
         < property name = "user" >
             < value >${jdbc.username}</ value >
         </ property >
         < property name = "password" >
             < value >${jdbc.password}</ value >
         </ property >
         < property name = "minPoolSize" >
             < value >8</ value >
         </ property >
         < property name = "maxPoolSize" >
             < value >200</ value >
         </ property >
         < property name = "initialPoolSize" >
             < value >10</ value >
         </ property >
         < property name = "maxIdleTime" >
             < value >60</ value >
         </ property >
         < property name = "acquireIncrement" >
             < value >5</ value >
         </ property >
         < property name = "maxStatements" >
             < value >10</ value >
         </ property >
         < property name = "idleConnectionTestPeriod" >
             < value >60</ value >
         </ property >
         < property name = "acquireRetryAttempts" >
             < value >30</ value >
         </ property >
         < property name = "breakAfterAcquireFailure" >
             < value >true</ value >
         </ property >
         < property name = "testConnectionOnCheckout" >
             < value >false</ value >
         </ property >
     </ bean >
 
     <!-- 创建SqlSessionFactory，同时指定数据源 -->
     < bean id = "sqlSessionFactory" class = "org.mybatis.spring.SqlSessionFactoryBean" >
         <!-- 指定sqlMapConfig总配置文件 -->
         < property name = "configLocation" value = "classpath:mybatis-configuration.xml" />
         < property name = "dataSource" ref = "dataSource" />
     </ bean >
     
     < bean class = "org.mybatis.spring.mapper.MapperScannerConfigurer" >
         < property name = "basePackage" value = "com.springbatis.dao" />
     </ bean >
         
     <!-- 事务管理  -->
     < bean id = "transactionManager" class = "org.springframework.jdbc.datasource.DataSourceTransactionManager" >
         < property name = "dataSource" ref = "dataSource" />
     </ bean >
     
     <!-- 使用注解控制事务 -->
     < tx:annotation-driven />
     
</ beans >


2)mybatis-configuration.xml


?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<? 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 >
     
     <!-- 别名 -->
     < typeAliases >
         < typeAlias alias = "School" type = "com.springbatis.domain.School" />
         < typeAlias alias = "Student" type = "com.springbatis.domain.Student" />
     </ typeAliases >
     
     <!-- ORM映射文件 -->
     < mappers >
         < mapper resource = "com/springbatis/domain/SchoolMapper.xml" />
         < mapper resource = "com/springbatis/domain/StudentMapper.xml" />
     </ mappers >
     
     
</ configuration >


3)School Entity


?
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
package com.springbatis.domain;
 
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
 
@SuppressWarnings ( "serial" )
public class School implements Serializable {
     
     private int id;
     private String schoolNumber;
     private String schoolName;
     private List<Student> students = new ArrayList<Student>();
     
     public School(){
     }
 
     public int getId() {
         return id;
     }
 
     public void setId( int id) {
         this .id = id;
     }
 
     public String getSchoolNumber() {
         return schoolNumber;
     }
 
     public void setSchoolNumber(String schoolNumber) {
         this .schoolNumber = schoolNumber;
     }
 
     public String getSchoolName() {
         return schoolName;
     }
 
     public void setSchoolName(String schoolName) {
         this .schoolName = schoolName;
     }
 
     public List<Student> getStudents() {
         return students;
     }
 
     public void setStudents(List<Student> students) {
         this .students = students;
     }  
 
}


4)Student Entity


?
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
package com.springbatis.domain;
 
import java.io.Serializable;
 
@SuppressWarnings ( "serial" )
public class Student implements Serializable {
     
     private int id;
     private String studentNumber;
     private String studentName;
     private String sex;
     private School school;
     
     public Student(){
     }
 
     public int getId() {
         return id;
     }
 
     public void setId( int id) {
         this .id = id;
     }
 
     public String getStudentNumber() {
         return studentNumber;
     }
 
     public void setStudentNumber(String studentNumber) {
         this .studentNumber = studentNumber;
     }
 
     public String getStudentName() {
         return studentName;
     }
 
     public void setStudentName(String studentName) {
         this .studentName = studentName;
     }
 
     public String getSex() {
         return sex;
     }
 
     public void setSex(String sex) {
         this .sex = sex;
     }
 
     public School getSchool() {
         return school;
     }
 
     public void setSchool(School school) {
         this .school = school;
     }
     
}


5)SchoolMapper.xml


?
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
<? xml version = "1.0" encoding = "UTF-8" ?>
<! DOCTYPE mapper    
PUBLIC "-//ibatis.apache.org//DTD Mapper 3.0//EN"    
"http://ibatis.apache.org/dtd/ibatis-3-mapper.dtd">    
    
< mapper namespace = "com.springbatis.dao.SchoolMybatisDao" >
 
     <!-- 一对多映射 -->
     < resultMap id = "schoolResult" type = "School" >
         < id property = "id" column = "school_id" />
         < result property = "schoolNumber" column = "school_number" />
         < result property = "schoolName" column = "school_name" />
         < collection property = "students" ofType = "Student" >
             < id property = "id" column = "student_id" />
             < result property = "studentNumber" column = "student_number" />
             < result property = "studentName" column = "student_name" />
             < result property = "sex" column = "student_sex" />
         </ collection >
     </ resultMap >
     
     < select id = "loadSchoolWithStudent" parameterType = "int" resultMap = "schoolResult" >
         select
             sch.id                  as  school_id,
             sch.schoolNumber        as  school_number,
             sch.schoolName          as  school_name,
             stu.id                  as  student_id,
             stu.studentNumber       as  student_number,
             stu.studentName         as  student_name,
             stu.sex                 as  student_sex
         from  school sch
         left outer join student stu on sch.id=stu.school_id
         where sch.id=#{school_id}
     </ select >
     
</ mapper > 


6)StudentMapper.xml


?
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
<? xml version = "1.0" encoding = "UTF-8" ?>
<! DOCTYPE mapper    
PUBLIC "-//ibatis.apache.org//DTD Mapper 3.0//EN"    
"http://ibatis.apache.org/dtd/ibatis-3-mapper.dtd">    
 
< mapper namespace = "com.springbatis.dao.StudentMybatisDao" >
     
     <!-- 多对一映射 -->
     < resultMap id = "studentResult" type = "Student" >
         < id property = "id" column = "student_id" />
         < result property = "studentNumber" column = "student_number" />
         < result property = "studentName" column = "student_name" />
         < result property = "sex" column = "student_sex" />
         < association property = "school" javaType = "School" >
             < id property = "id" column = "school_id" />
             < result property = "schoolNumber" column = "school_number" />
             < result property = "schoolName" column = "school_name" />
        </ association >
     </ resultMap >
     
     < select id = "loadStudentWithSchool" parameterType = "int" resultMap = "studentResult" >
         select
             stu.id                  as  student_id,
             stu.studentNumber       as  student_number,
             stu.studentName         as  student_name,
             stu.sex                 as  student_sex,
             sch.id                  as  school_id,
             sch.schoolNumber        as  school_number,
             sch.schoolName          as  school_name
         from student stu
         left outer join school sch on sch.id=stu.school_id
         where stu.id=#{student_id}
     </ select >
     
</ mapper >


7)SchoolMybatisDao Interface


?
1
2
3
4
5
6
7
8
9
10
11
12
package com.springbatis.dao;
 
import org.springframework.stereotype.Repository;
 
import com.springbatis.domain.School;
 
@Repository
public interface SchoolMybatisDao {
     
     School loadSchoolWithStudent( int school_id);
     
}


8)StudentMybatisDao Interface


?
1
2
3
4
5
6
7
8
9
10
11
12
package com.springbatis.dao;
 
import org.springframework.stereotype.Repository;
 
import com.springbatis.domain.Student;
 
@Repository
public interface StudentMybatisDao {
 
     Student loadStudentWithSchool( int student_id);
     
}


9)SchoolService Interface


?
1
2
3
4
5
6
7
8
9
10
11
12
package com.springbatis.service;
 
import org.springframework.stereotype.Repository;
 
import com.springbatis.domain.School;
 
@Repository
public interface SchoolService {
     
     public School loadSchoolWithStudent( int school_id);
     
}


10)StudentServiec Interface


?
1
2
3
4
5
6
7
8
9
package com.springbatis.service;
 
import com.springbatis.domain.Student;
 
public interface StudentService {
     
     public Student loadStudentWithSchool( int student_id);
     
}


11)SchoolService Implement


?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.springbatis.service.implement;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import com.springbatis.dao.SchoolMybatisDao;
import com.springbatis.domain.School;
import com.springbatis.service.SchoolService;
 
@Service
@Transactional
public class SchoolServiceImpl implements SchoolService {
     
     @Autowired
     private SchoolMybatisDao schoolDao;
 
     @Override
     public School loadSchoolWithStudent( int school_id) {
         return schoolDao.loadSchoolWithStudent(school_id);
     }
 
}


12)StudentService Implement


?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.springbatis.service.implement;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import com.springbatis.dao.StudentMybatisDao;
import com.springbatis.domain.Student;
import com.springbatis.service.StudentService;
 
@Service
@Transactional
public class StudentServiceImpl implements StudentService {
 
     @Autowired
     private StudentMybatisDao studentDao;
     
     @Override
     public Student loadStudentWithSchool( int student_id) {
         return studentDao.loadStudentWithSchool(student_id);
     }
 
}

13)test/StudentServiceTest

?
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
package com.springbatis.service;
 
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
import com.springbatis.domain.Student;
 
@RunWith (SpringJUnit4ClassRunner. class )
@ContextConfiguration (locations= "/applicationContext.xml" )
public class StudentServiceTest {
     
     @Autowired
     private StudentService studentService;
     
     @Test
     public void testLoadStudentWithSchool(){
         Student stu = studentService.loadStudentWithSchool( 2 );
         if (stu!= null ){
             System.out.println( "=====》studentId:" +stu.getId()+ "   studentNumber:" +stu.getStudentNumber()+ "  studentName:" +stu.getStudentName()+ "   sex:" +stu.getSex());
             System.out.println( "=====》schoolId:" +stu.getSchool().getId()+ "  schoolNumber:" +stu.getSchool().getSchoolNumber()+ "  schoolName:" +stu.getSchool().getSchoolName());
         }
         else {
             System.out.println( "id不存在！！" );
         }
     }
}


14)test/SchoolServiceTest   


?
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
package com.springbatis.service;
 
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
import com.springbatis.domain.School;
import com.springbatis.domain.Student;
 
@RunWith (SpringJUnit4ClassRunner. class )
@ContextConfiguration (locations= "/applicationContext.xml" )
public class SchoolServiceTest {
     
     @Autowired
     private SchoolService schoolService;
     
     @Test
     public void testLoadSchoolWithStudent(){
         School school = schoolService.loadSchoolWithStudent( 1 );
         if (school!= null ){
             System.out.println( "=====》schoolId:" +school.getId()+ "  schoolNumber:" +school.getSchoolNumber()+ "  schoolName:" +school.getSchoolName());
             if (school.getStudents().size()> 0 ){
                 for (Student stu : school.getStudents()){
                     System.out.println( "=====》studentId:" +stu.getId()+ "   studentNumber:" +stu.getStudentNumber()+ "  studentName:" +stu.getStudentName()+ "   sex:" +stu.getSex());
                 }
             } else {
                 System.out.println( "无学生！" );
             }
         }
         else {
             System.out.println( "id不存在！！" );
         }
     }
     
}


15)     执行testLoadSchoolWithStudent()

输出：

?

 

1
2
3
4
==》schoolId: 1   schoolNumber: 100001  schoolName:清华大学
=====》studentId: 1   studentNumber: 1007300220  studentName:露西   sex:女
=====》studentId: 2   studentNumber: 1007300222  studentName:杰克   sex:男
=====》studentId: 4   studentNumber: 1007300225  studentName:露露   sex:女
weixin_33701294
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
MyBatis Spring整合配置映射接口类与映射xml文件
qq_28919279的博客
07-07 794
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:jee="http://www.springframework.org/schema/jee" xmlns:context="http://www.springframework
Spring+SpringMVC+Mybatis框架整合例子(SSM) 下载
07-21
Mybatis则是一个轻量级的持久层框架，它解决了JDBC的繁琐代码问题，提供了更方便的SQL映射和对象关系映射。Mybatis允许开发者直接编写SQL，提高了查询效率和灵活性，同时通过XML或注解方式配置和映射原生信息，将...
Mybatis（基于接口映射） + Spring 练习实战
骚年时光的专栏
10-08 5038
关于Mybatis的Demo如下，直接重点，一边贴代码，一遍讲解
spring-mybatis——MapperFactoryBean 之映射接口
热门推荐
赶路人儿
09-03 1万+
为了代替手工使用 SqlSessionDaoSupport 或 SqlSessionTemplate 编写数据访问对象(DAO)的代码,MyBatis-Spring 提供了一个动态代理的实现——MapperFactoryBean。这个类可以让你直接注入数据映射器接口到你的 service 层bean 中。当使用映射器时,你仅仅如调用你的 DAO 一样调用它们就可以了,但是你不需要编写任何 DA
mybatis_spring.zip_mybatis整合spring的包
09-23
1. **MyBatis-Spring 框架**：MyBatis-Spring 是一个连接 MyBatis 和 Spring 的桥梁，它提供了一组 Spring Bean 定义，使得 MyBatis 可以无缝集成到 Spring 应用中。这个 jar 包 `mybatis_spring.jar` 就包含了这些...
Mybatis整合Spring模拟代码
最新发布
06-04
总结起来，Mybatis与Spring的整合主要是通过Spring的IoC容器管理Mybatis的SqlSessionFactory和Mapper接口，简化了数据库操作的配置，提高了代码的可维护性。在实际项目中，这种整合方式被广泛应用，提供了高效且灵活...
mybatis整合Spring
03-15
MyBatis和Spring的整合是Java开发中常见的一种技术组合，它...以上就是关于"MyBatis整合Spring"的知识点详解，希望对您有所帮助。通过这种整合，开发者能够更好地利用两者的优点，构建出高效、可维护的Java企业级应用。
详解Java的MyBatis框架与Spring框架整合中的映射器注入
09-02
映射器注入是这种整合的关键部分，它允许我们直接在Spring管理的Service层注入MyBatis的映射器，从而避免了手动创建DAO层的繁琐工作。下面将详细解释如何实现MyBatis和Spring的整合，以及映射器注入的工作原理。 ...
mybatis整合spring 之 基于接口映射的多对一关系
weixin_34356138的博客
10-18 78
2019独角兽企业重金招聘Python工程师标准>>> ...
springboot + mybatis 多数据源配置 数据库与实体类映射（驼峰命名法）
wzbjsz的博客
07-17 4884
在自己配置的config中 添加： Configuration configuration = new Configuration(); configuration.setMapUnderscoreToCamelCase(true);  factoryBean.setConfiguration(configuration); 由于在此方法中 加了注解@Configuration 而此注解的 在...
【框架整合】--- Spring与MyBatis
qq_46489900的博客
07-28 104
Spring与MyBatis整合前言依赖准备整合注解方式整合XML文件方式整合事务注解方式管理事务XML方式管理事务关于纯事务和纯XML纯注解纯XML方式 前言 本章将Mybatis与Spring整合分为了： 整合 事务 两个方面，只是简单的列举了一些例子作为说明，创建本章的目的是备忘。更多技术内幕请参阅：MyBatis-Spring 官方文档 依赖准备 Spring核心依赖 <!--spring核心--> <dependency> <group
框架设计--第十章 MyBatis与Spring的整合--习题答案
三桥君
02-21 1万+
说明：框架设计（Spring）其他章节的习题答案也在此专栏 一、 填空题 在MyBatis+Spring的项目中，事务是由【 Spring】来管理的。 MyBatis-Spring团队提供了一种自动扫描的形式来配置MyBatis中的映射器——采用【MapperScannerConfigurer 】类。 【 MapperFactoryBean】是MyBatis-Spring团队提供的一个用于根...
Mybatis-Spring整合与高级结果映射实战
高级结果映射是Mybatis的核心特性之一，它包括一对一、一对多、多对多的映射。这使得Mybatis能够处理复杂的数据关联查询。 1. **一对一映射**：当两个实体间存在一对一关系时，如订单和用户信息，可以通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值