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

最新推荐文章于 2024-07-26 12:28:02 发布
最新推荐文章于 2024-07-26 12:28:02 发布
阅读量78 收藏
点赞数
文章标签： java python
原文链接：https://my.oschina.net/huangcongmin12/blog/83731
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

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

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

        school表:

                  

         student表:        

  

     

项目结构如下：


     


 1)applicationContext.xml 


<?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 


<?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 


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 


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 


<?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 


<?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 


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 


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 


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 


package com.springbatis.service;

import com.springbatis.domain.Student;

public interface StudentService {
	
	public Student loadStudentWithSchool(int student_id);
	
}


11)SchoolService Implement 


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 


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


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()

输出： 

==》schoolId: 1   schoolNumber:100001  schoolName:清华大学
=====》studentId:1   studentNumber:1007300220  studentName:露西   sex:女
=====》studentId:2   studentNumber:1007300222  studentName:杰克   sex:男
=====》studentId:4   studentNumber:1007300225  studentName:露露   sex:女





    

转载于:https://my.oschina.net/huangcongmin12/blog/83731

weixin_34356138
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【Spring】— MyBatis与Spring的整合
衍生星球的博客
06-15 1407
在MyBatis+Spring的项目中，虽然使用传统的DAO开发方式可以实现所需功能，但是采用这种方式在实现类中会出现大量的重复代码，在方法中也需要指定映射文件中执行语句的id，并且不能保证编写时id的正确性（运行时才能知道）。执行上述方法后，控制台的输出结果如图所示。Spring框架所需要准备的JAR包共10个，其中包括4个核心模块JAR、AOP开发使用的JAR、JDBC和事务的JAR（其中核心容器依赖的commons-logging的JAR在MyBatis框架的lib包中已经包含）。
Spring+SpringMVC+Mybatis框架整合例子(SSM) 下载
07-21
Mybatis则是一个轻量级的持久层框架，它解决了JDBC的繁琐代码问题，提供了更方便的SQL映射和对象关系映射。Mybatis允许开发者直接编写SQL，提高了查询效率和灵活性，同时通过XML或注解方式配置和映射原生信息，将...
mybatis整合spring 之 基于接口映射的多对一关系
weixin_33701294的博客
08-13 154
转载自：http://my.oschina.net/huangcongmin12/blog/83731 mybatis整合spring 之  基于接口映射的多对一关系。         项目用到俩个表，即student表和school表。表结构如下：         school表:                             student表:            ...
MyBatis Spring整合配置映射接口类与映射xml文件
海涛的博客
08-20 6万+
Spring整合MyBatis使用到了mybatis-spring，在配置mybatis映射
【MyBatis】多个接口参数的用法
习惯成自然
07-26 407
当接口参数只有一个的时候，我们可以这样写： TUser selectByPrimaryKey(Long id); 当接口参数超过一个的时候，我们可以这样写： TUser selectByPrimaryKey(@Param(&quot;id&quot;) Long id,@Param(&quot;name&quot;) String name); @Param注解的值需要与Mapper中的参数值对应。如：@Param(&quot;ids...
MyBatis 基础总结
男儿当自强
08-18 721
MyBatis是一种支持sql语句和存储过程的实现ORM的框架，是对JDBC的封装，是一种优秀的持久层框架。
Spring——Spring整合MyBatis
★★光亭★★
03-13 2万+
Spring——Spring整合MyBatis
Spring boot Mybatis 整合（完整版）
热门推荐
LuisChen的博客
08-16 56万+
对Mybatis注解方式有兴趣的，可以查看我的另一篇：Spring boot Mybatis 整合（注解版） 注解方式更加简洁简单，极大程度的提高了开发速度。如果大家需要使用更高的版本比如springboot2.0，请参照我最新的博客springboot2.0 Mybatis 整合 (springboot2.0版本) 更多干货 Spring Boot快速入门 Spring B...
MyBatis详解：spring和mybatis整合
2401_84153193的博客
05-03 1106
毕竟工作也这么久了 ，除了途虎一轮，也七七八八面试了不少大厂，像阿里、饿了么、美团、滴滴这些面试过程就不一一写在这篇文章上了。我会整理一份详细的面试过程及大家想知道的一些问题细节毕竟工作也这么久了 ，除了途虎一轮，也七七八八面试了不少大厂，像阿里、饿了么、美团、滴滴这些面试过程就不一一写在这篇文章上了。我会整理一份详细的面试过程及大家想知道的一些问题细节。
SpringBoot整合Mybatis之Mapper接口和映射文件
weixin_51725434的博客
12-21 2914
SpringBoot整合Mybatis之Mapper接口和映射文件
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 - 一对多/多对一映射
weixin_46030002的博客
10-28 2582
Mybatis 一对多（collection关联查询） 和 多对一 （级联，association关联查询，association分布查询）映射
golang 接口
m0_70982551的博客
07-24 933
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
最新发布
a1058926697的博客
07-26 505
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 624
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Mybatis-Spring整合与高级结果映射实战
高级结果映射是Mybatis的核心特性之一，它包括一对一、一对多、多对多的映射。这使得Mybatis能够处理复杂的数据关联查询。 1. **一对一映射**：当两个实体间存在一对一关系时，如订单和用户信息，可以通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值