关于Mybatis中表中字段名和POJO中字段名不同的解决方法

项目结构：

POJO中：

package com.domain;

/**
 * @author mzy
 * 定义orders表对应的实体类
 */
public class Order {
    /**
     * 
    CREATE TABLE orders(
        order_id INT PRIMARY KEY AUTO_INCREMENT,
        order_no VARCHAR(20), 
        order_price FLOAT
    );
     */
    
    //Order实体类中属性名和orders表中的字段名是不一样的
    private int id;                //id===>order_id
    private String orderNo;        //orderNo===>order_no
    private float price;        //price===>order_price

    public int getId() {
        return id;
    }

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

    public String getOrderNo() {
        return orderNo;
    }

    public void setOrderNo(String orderNo) {
        this.orderNo = orderNo;
    }

    public float getPrice() {
        return price;
    }

    public void setPrice(float price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Order [id=" + id + ", orderNo=" + orderNo + ", price=" + price+ "]";
    }
}

sqlMapConfig.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 resource="jdbc.properties"/>
	<typeAliases>
<!-- 		<typeAlias type="com.itheima.mybatis.pojo.User" alias="User"/> -->
		<!-- <package name="com.itheima.mybatis.pojo"/> -->
	</typeAliases>
	
	<!-- 和spring整合后 environments配置将废除    -->
	<environments default="development">
		<environment id="development">
			<!-- 使用jdbc事务管理 -->
			<transactionManager type="JDBC" />
			<!-- 数据库连接池 -->
			<dataSource type="POOLED">
				<property name="driver" value="${jdbc.driver}" />
				<property name="url" value="${jdbc.url}" />
				<property name="username" value="${jdbc.username}" />
				<property name="password" value="${jdbc.password}" />
			</dataSource>
		</environment>
	</environments>
	
	<mappers>        
<!-- 
其实mapper放在哪里都无所谓，最后都是通过，sqlMapConfig.xml
通过mappers给include进来的。
mapper匹配单个，package可以匹配多个
匹配整个包下面的。
 -->	
<!-- 		<mapper resource="sqlmap/User.xml" class="" url=""/> -->
<!-- 		<mapper resource="sqlmap/User.xml" class="" url=""/> -->
<!-- 		<mapper class="com.itheima.mybatis.mapper.UserMapper"/> -->
<!-- 		<mapper url="" /> -->
<!-- <package name="com.itheima.mybatis.mapper"/>
		直接扫描整个包下面！
 -->        
        <mapper resource="com/mapper/orderMapper.xml"/>
	</mappers>
</configuration>

OrderMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 最开始mapper的namespace只是用来区分名字的，比如当sqlMapConfig.xml中有多个mapper
的时候，其中难免会有一些重复的sql语句：被select标签包裹的sql语句。

我们使用的xml映射文件，可以写在一个任意的位置，但是这样执行的话很不方便，
需要通过MyBatis手动的从classpath下添加mapper的路径，解析里面的语句。

所以这里引入了动态mapper的概念(替代原始的dao层)，只要给出dao层的抽象类。
保证四大原则：
	接口名 ==  mapper 的xml文件的文件名
	方法中返回值类型一致
	方法中入参类型一致
	命名空间namespace绑定的是这个接口就可以了
	
那么在sqlMapConfig.xml中配置的mappers就可以直接来使用package

<package name="com.itheima.mybatis.mapper"/>
来映射整个mapper包，动态mapper的方法极大的改善了原始dao开发中的弊端。
 -->
<mapper namespace="com.mapper.orderMapper">
	<!-- 当表中字段，与我们实际的pojo不相同的时候；
	我们一般使用resultMap的方式来进行字段映射：
	property表示新取的名字，
	column表示在表中的真实名字，这样就能映射上了。
	
	映射的作用是，在查出值之后，将一类有关联的值
	保存在POJO对象中，如果名称不对应，Mybatis就
	不会帮我们自动赋值到我们的javaBean中去：
	
	
	 -->
	<resultMap type="com.domain.Order" id="orderResultMap">
		<!-- 用id属性来映射主键字段 -->
		<id property="id" column="order_id"/>
		<!-- 用result属性来映射非主键字段 -->
		<result property="orderNo" column="order_no"/>
		<result property="price" column="order_price"/>
	</resultMap>
	
	<!-- 
        根据id查询得到一个order对象，使用这个查询是查询不到我们想要的结果的，
        这主要是因为实体类的属性名和数据库的字段名对应不上的原因，因此无法查询出对应的记录；
        
   	字段映射做好之后，是一个resultMap，其中type必须存放被映射的POJO的全类名。
   	id为这个resultMap的名字，在具体的select中再引入我需要的resultMap：resultMap="orderResultMap"
   	这样就可以做到映射了，然后Mybatis就会帮我们自动把值封装进我们的javaBean中去。
   	
   	当然在查询比较少的时候，还有一种方式，在查出来的时候，给字段取别名，这种方式在查询比较少的时候我比较喜欢！
     -->
    <select id="getOrderById" parameterType="int" 
        resultType="com.domain.Order">
        select * from orders where order_id=#{id}
    </select>
    
     <!-- 
        根据id查询得到一个order对象，使用这个查询是可以正常查询到我们想要的结果的，
        这是因为我们将查询的字段名都起一个和实体类属性名相同的别名，这样实体类的属性名和查询结果中的字段名就可以一一对应上
     -->
    <select id="selectOrder" parameterType="int" 
        resultType="com.domain.Order">
        select order_id id, order_no orderNo,order_price price from orders where order_id=#{id}
    </select>
    
     <!-- 
    根据id查询得到一个order对象，使用这个查询是可以正常查询到我们想要的结果的，
    这是因为我们通过<resultMap>映射实体类属性名和表的字段名一一对应关系 -->
    <select id="selectOrderResultMap" parameterType="int" resultMap="orderResultMap">
        select * from orders where order_id=#{id}
    </select>
</mapper>

jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test?characterEncoding=utf-8
jdbc.username=root
jdbc.password=82750100

Mybatisutil.java

package com.uitl;

import java.io.IOException;
import java.io.InputStream;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class MyBatisUtil {
	public static SqlSessionFactory sqlSessionFactory = null;
	
	static {
		String resource = "sqlMapConfig.xml";
		// 首先要加载核心配置文件：从classpath下开始找。
		InputStream in;
		try {
			in = Resources.getResourceAsStream(resource);
			
			sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
		} catch (IOException e) {
			throw new RuntimeException(e.getMessage());
		}	
	}
	
	public static SqlSession getSqlSession() {
		
		return sqlSessionFactory.openSession();
	}
}

TestOrder.java Junit4测试：

package com.test;

import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import com.domain.Order;
import com.uitl.MyBatisUtil;

public class TestOrder {
    
    @Test
    public void testGetOrderById(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();

        String statement = "com.mapper.orderMapper.getOrderById";//映射sql的标识字符串
        //执行查询操作，将查询结果自动封装成Order对象返回
        Order order = sqlSession.selectOne(statement,1);//查询orders表中id为1的记录
        //使用SqlSession执行完SQL之后需要关闭SqlSession
        sqlSession.close();
        System.out.println(order);//打印结果：null，也就是没有查询出相应的记录
    }
    
    @Test
    public void testGetOrderById2(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();

        String statement = "com.mapper.orderMapper.selectOrder";//映射sql的标识字符串
        //执行查询操作，将查询结果自动封装成Order对象返回
        Order order = sqlSession.selectOne(statement,1);//查询orders表中id为1的记录
        //使用SqlSession执行完SQL之后需要关闭SqlSession
        sqlSession.close();
        System.out.println(order);//打印结果：Order [id=1, orderNo=aaaa, price=23.0]
    }
    
    @Test
    public void testGetOrderById3(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();

        String statement = "com.mapper.orderMapper.selectOrderResultMap";//映射sql的标识字符串
        //执行查询操作，将查询结果自动封装成Order对象返回
        Order order = sqlSession.selectOne(statement,1);//查询orders表中id为1的记录
        //使用SqlSession执行完SQL之后需要关闭SqlSession
        sqlSession.close();
        System.out.println(order);//打印结果：Order [id=1, orderNo=aaaa, price=23.0]
    }
}