ORM核心思想在于通过建立MODEL与数据库的映射来简化大量重复的工作量. 对于简单增删改查操作来说, 通过MODEL自动转换为SQL语句并执行可以节省很多工作量. 但是对于复杂的系统来说, 需要各种各样的复杂操作, 并且SQL也需要经过高度优化, 因此通过MODEL自动执行SQL并不可行.

Mybatis中通过所谓的半自动化解决了这一问题. 即手动书写SQL, 自动完成映射. 本章将实现一个简易的Mybatis.

设计思路

Mapper文件是Mybatis中非常重要的组件, 所有的SQL操作及映射方式都在Mapper文件中. 在程序(或项目)启动时加载所有的Mapper文件, 解析其中的SQL节点并保存. 当执行某项操作时从Mapper中找到对应的SQL, 完成参数映射后执行并返回执行结果.

组件与接口

在了解了基本的设计思路后, 下面开始对ORM框架中的组件及接口进行设计.

MappedStatement

SQL节点信息类, 负责保存Mapper中的SQL节点信息. 加载Mapper文件时, 将Mapper中的每个SQL节点进行解析并保存至MappedStatement中.

// SQL节点信息类
public class MappedStatement {

    // SQL节点ID
    private String id;

    // SQL语句
    private String sql;

    // SQL节点类型(select, insert, update, delete)
    private String statementType;

    // 返回值类型(类型为select时需要)
    private String resultType;

    // SQL中需要被映射复制的参数集合
    private List<String> parameters;

    // 实例化时必须传入SQL_ID
    public MappedStatement(String id) {
        this.id = id;
    }

    // Getter & Setter
    // ...

}

Configuration

全局配置类, 保存SQL节点信息及其他配置信息.

// 全局配置(保存SQL节点信息及其他配置)
public class Configuration {

    // 保存所有的SQL节点信息. k: SQL节点ID, v: SQL节点对象
    private Map<String, MappedStatement> mappedStatements = new HashMap<String, MappedStatement>();

    // 根据SQL节点ID获取SQL节点信息
    public MappedStatement getMappedStatement(String id) {
        return this.mappedStatements.get(id);
    }

    // 添加SQL节点
    public MappedStatement addMappedStatement(MappedStatement s) {
        return this.mappedStatements.put(s.getId(), s);
    }

}

SqlSession

SQL会话组件,封装了数据库操作. 对外提供增删改查的接口供使用者调用.

// SQL会话(提供SQL基本操作)
public class SqlSession {

    // 全局配置
    private Configuration config;

    // 实例化时必须传入全局配置
    public SqlSession(Configuration config) {
        this.config = config;
    }

    /**
     * 查询单条数据(查询结果必须为一条记录)
     * 
     * @param sqlId SQL节点ID
     * @return 查询结果对应的MODEL(resultType指定的类)
     */
    public <T> T selectOne(String sqlId) {
        return selectOne(sqlId, null);
    }

    /**
     * 查询单条数据(查询结果必须为一条记录)
     * 
     * @param sqlId SQL节点ID
     * @param args  执行SQL所需参数
     * @return 查询结果对应的MODEL(resultType指定的类)
     */
    public <T> T selectOne(String sqlId, Object args) {
        List<T> list = selectList(sqlId, null);
        if (list.size() > 1) {
            throw new RuntimeException("count 1111");
        }
        if (list.size() == 1) {
            return list.get(0);
        }
        return null;
    }

    /**
     * 查询多条数据
     * 
     * @param sqlId SQL节点ID
     * @return 查询结果对应的MODEL(resultType指定的类)集合
     */
    public <T> List<T> selectList(String sqlId) {
        return selectList(sqlId, null);
    }

    /**
     * 查询多条数据
     * 
     * @param sqlId SQL节点ID
     * @param args  执行SQL所需参数
     * @return 查询结果对应的MODEL(resultType指定的类)集合
     */
    public <T> List<T> selectList(String sqlId, Object args) {
        // TODO
        return null;
    }

    /**
     * 插入数据
     * 
     * @param sqlId SQL节点ID
     * @return 成功被插入的数据条数
     */
    public int insert(String sqlId) {
        return insert(sqlId, null);
    }

    /**
     * 插入数据
     * 
     * @param sqlId SQL节点ID
     * @param args  执行SQL所需参数
     * @return 成功被插入的数据条数
     */
    public int insert(String sqlId, Object args) {
        return update(sqlId, args);
    }

    /**
     * 删除数据
     * 
     * @param sqlId SQL节点ID
     * @return 成功被删除的数据条数
     */
    public int delete(String sqlId) {
        return delete(sqlId, null);
    }

    /**
     * 删除数据
     * 
     * @param sqlId SQL节点ID
     * @param args  执行SQL所需参数
     * @return 成功被删除的数据条数
     */
    public int delete(String sqlId, Object args) {
        return update(sqlId, args);
    }

    /**
     * 更新数据
     * 
     * @param sqlId SQL节点ID
     * @return 成功被更新的数据条数
     */
    public int update(String sqlId) {
        return update(sqlId, null);
    }

    /**
     * 更新数据
     * 
     * @param sqlId SQL节点ID
     * @param args  执行SQL所需参数
     * @return 成功被更新的数据条数
     */
    public int update(String sqlId, Object args) {
        // TODO
        return 0;
    }

}

insert, delete本质上是update,无需单独实现.
根据主键查询只返回一条记录, 提供selectOne方法便于用户直接对MODEL操作(无需从集合获取在转换)

SqlSessionFactory SQL会话工厂类. 负责创建SQL会话.

// SQL会话工厂类(负责创建SQL会话)
public class SqlSessionFactory {

    // 全局配置
    private Configuration config;

    // 实例化时必须传入全局配置
    public SqlSessionFactory(Configuration config) {
        this.config = config;
    }

    // 获取SQL会话
    public SqlSession getSession() {
        return new SqlSession(config);
    }

}

SqlSessionFactoryBean

框架初始化入口, 负责解析Mapper文件并创建SQL会话工厂.

// 框架初始化入口(负责解析Mapper文件并创建SQL会话工厂)
public class SqlSessionFactoryBean {

    private static final Pattern PARAMETER_PATTERN = Pattern.compile("#\\{(.+?)\\}");

    // 全局配置
    private Configuration config = new Configuration();

    // Mapper文件路径
    private String mapperLocation;
    
    // 默认构造器
    public SqlSessionFactoryBean() {
    }

    // 通过Mapper文件路径实例化
    public SqlSessionFactoryBean(String mapperLocation) {
        this.setMapperLocation(mapperLocation);
    }
    // 设置Mapper文件
    public void setMapperLocation(String mapperLocation) {
        this.mapperLocation = mapperLocation;
    }

    // 构建SQL会话工厂
    public SqlSessionFactory build() {
        // TODO
        // 加载Mapper
        return new SqlSessionFactory(config);
    }

}

使用流程

程序(或项目)启动时, 实例化SqlSessionFactoryBean, 设置Mapper所在路径, 调用build方法构建SqlSessionFactory
SqlSessionFactoryBean在build时根据Mapper路径加载并解析Mapper, 将Mapper下的每个SQL节点封装成MappedStatement对象. 并保存在全局配置Configuration中.
数据访问层(DAO)对数据库进行操作时, 通过SqlSessionFactory获取SqlSession, 调用其对应的方法并传入SQL ID.
SqlSession中根据SQL ID在全局配置Configuration中找到对应的SQL节点信息对象MappedStatement.
将传入的参数按照MappedStatement中SQL的参数规则进行参数映射后生成可执行的SQL.
执行SQL后将执行结果返回. 如果是select操作, 将查询结果封装成指定对象后返回

代码实现

SqlSessionFactoryBean作为框架的初始化入口, 在build方法中加载配置文件, 解析Mapper并构建SQL会话工厂.

// 构建SQL会话工厂
public SqlSessionFactory build() {

    if (this.mapperLocation == null) {
        throw new RuntimeException("请设置Mapper文件所在路径");
    }

    // 获取Mapper文件
    List<File> mappers = getMapperFiles();

    // 加载所有Mapper并解析
    for (File mapper : mappers) {
        parseStatement(mapper);
    }

    // 返回SQL会话工厂
    return new SqlSessionFactory(config);

}

Mapper文件配置路径支持通配符(*), 例: /m/*_mapper.xml为Mapper文件位于classpath下的m文件内,并且以_mapper.xml结尾. 在加载Mapper文件时需要对通配符进行处理.

// 根据Mapper所在路径获取所有Mapper文件
private List<File> getMapperFiles() {

    List<File> mappers = new ArrayList<File>();

    String mapperDir; // Mapper文件目录
    String mapperName; // Mapper文件名称

    // 根据配置的Mapper路径分别获取文件目录及文件名称
    // 是否含有文件分隔符
    int lastPos = this.mapperLocation.lastIndexOf("/");
    // 含有文件分隔符
    if (lastPos > -1) {
        mapperDir = this.mapperLocation.substring(0, lastPos);
        mapperName = this.mapperLocation.substring(lastPos + 1);
    }
    // 无文件分隔符
    // 配置路径为Mapper文件名
    else {
        mapperDir = "";
        mapperName = this.mapperLocation;
    }

    // 获取Mapper目录下所有文件
    String classpath = ClassLoader.getSystemResource("").getPath();
    File[] allMappers = new File(classpath, mapperDir).listFiles();

    // *为通配符,将*转换为正则表达式通配符进行匹配
    // *_mapper.xml -> .+?_mapper.xml
    Pattern pattern = Pattern.compile(mapperName.replaceAll("\\*", ".+?"));

    // 遍历Mapper目录下所有文件
    for (File f : allMappers) {
        // 文件是否和指定的Mapper名称一致
        if (pattern.matcher(f.getName()).matches()) {
            mappers.add(f);
        }
    }

    return mappers;
}

解析Mapper文件中的所有SQL节点并保存. Mapper文件格式如下:

<mapper>
	
	<select id="selectGoods" resultType="com.atd681.xc.ssm.orm.test.Goods">
		select id, goods_name goodsName, category, price from t_orm_goods
	</select>
	
	<update id="updateGoods">
		UPDATE t_orm_goods 
		   SET goods_name = #{goodsName}, price = #{price}
		 WHERE id = #{id}
	</update>
	
</mapper>

将每个SQL节点封装至MappedStatement对象中. 并统一保存至全局配置中.

// 解析Mapper文件
@SuppressWarnings("unchecked")
private void parseStatement(File mapper) {

    Document doc = null;
    // 使用JDom解析XML
    try {
        doc = new SAXBuilder().build(mapper);
    } catch (Exception e) {
        throw new RuntimeException("加载配置文件错误", e);
    }

    // Mapper下所有SQL节点
    List<Element> statementList = doc.getRootElement().getChildren();

    // 遍历Mapper下所有SQL节点
    for (Element statement : statementList) {

        // SQL节点ID
        String sqlId = statement.getAttributeValue("id");

        // SQL节点必须设置ID属性
        if (sqlId == null) {
            throw new RuntimeException("SQL节点需要设置id属性");
        }
        // SQL节点的ID不能重复
        if (config.getMappedStatement(sqlId) != null) {
            throw new RuntimeException("SQL节点id已经存在");
        }

        // 解析SQL节点
        MappedStatement ms = new MappedStatement(sqlId);

        ms.setSql(statement.getTextTrim());
        ms.setStatementType(statement.getName());
        ms.setResultType(statement.getAttributeValue("resultType"));

        // 解析SQL中的参数
        parseSqlAndParameters(ms);

        // 将SQL节点信息添加至全局配置中
        config.addMappedStatement(ms);

    }

}

SQL中如果含有需要被替换的参数时, 需要对SQL进行处理. 保存参数名称并将其替换成?, 以便使用JDBC执行时可以使用PrepareStatement进行赋值.

// 解析SQL中的参数
private void parseSqlAndParameters(MappedStatement ms) {

    List<String> parameters = new ArrayList<String>();
    StringBuffer sql = new StringBuffer();

    // 匹配SQL中的#{}
    Matcher m = PARAMETER_PATTERN.matcher(ms.getSql());

    // 将匹配到的#{}中的参数名称保存, 并替换为?
    // where u_name=#{UName} and u_age=#{UAge} -> where u_name=? and u_age=?
    // 执行SQL时在传入的参数中找到UName对第一个?赋值,UAge对第二个?赋值
    while (m.find()) {
        parameters.add(m.group(1));
        m.appendReplacement(sql, "?");
    }
    m.appendTail(sql);

    ms.setSql(sql.toString());
    ms.setParameters(parameters);

}

至此, Mapper文件已经解析完成. SQL会话工厂也已经创建完成. 在DAO中可以获取SQL会话并调用对应的数据库操作方法执行.

执行SQL时, 根据对SQL中的参数进行赋值后执行. 在解析Mapper时已经将SQL中的参数替换为?并且保存了参数的名称. 赋值时只需要依次将通过参数名称获取对应的参数值并且通过JDBC赋值到SQL中即可.

// 对参数进行赋值
private void setParameters(PreparedStatement ps, MappedStatement ms, Object args) throws Exception {
    if (args == null) {
        return;
    }
    List<String> parameters = ms.getParameters();
    if (parameters == null) {
        return;
    }
    // 依次根据参数名称从对应的MODEL中获取参数值替换SQL中的?
    for (int i = 0; i < parameters.size(); i++) {
        Object value = BeanUtil.getValue(args, parameters.get(i));
        ps.setObject(i + 1, value);
    }

}

DAO调用SQL会话的方法传入的参数支持以下几种类型

只有一个参数, 可以传入字符串
多个参数可以通过Map传入
多个参数可以通过Javabean传入

在根据SQL参数名称获取对应值时需要对三种情况分别进行解析.

// Bean工具类
public class BeanUtil {

    // 从对象中获取执行属性的值
    @SuppressWarnings("rawtypes")
    public static Object getValue(Object bean, String name) throws Exception {
        // 字符串
        if (bean instanceof String) {
            return bean;
        }
        // Map
        if (bean instanceof Map) {
            return ((Map) bean).get(name);

        }
        // Javabean调用属性的Getter方法获取
        Class<?> clazz = bean.getClass();
        Method getter = clazz.getDeclaredMethod(getGetter(name), new Class<?>[] {});
        return getter.invoke(bean, new Object[] {});
    }

    // 获取Getter方法名. userName -> getUserName
    public static String getGetter(String name) {
        return "get" + capitalize(name);
    }

    // 获取Setter方法名. userName -> setUserName
    public static String getSetter(String name) {
        return "set" + capitalize(name);
    }

    // 首字母大写. userName -> UserName
    private static String capitalize(String name) {
        return name.substring(0, 1).toUpperCase() + name.substring(1);
    }

}

对于insert,update,delete三种操作来说,最终在JDBC中的执行方式一致.

/**
 * 更新数据
 * 
 * @param sqlId SQL节点ID
 * @param args  执行SQL所需参数
 * @return 成功被更新的数据条数
 */
public int update(String sqlId, Object args) {

    MappedStatement ms = config.getMappedStatement(sqlId);

    Connection conn = null;
    PreparedStatement ps = null;

    try {
        conn = getConnection();
        ps = getPreparedStatement(conn, ms);
        setParameters(ps, ms, args);
        return ps.executeUpdate();

    } catch (Exception e) {
        throw new RuntimeException("", e);
    } finally {
        close(ps, conn);
    }

}

对于select操作来说, 需要将查询结果封装至指定对象中.

/**
 * 查询多条数据
 * 
 * @param sqlId SQL节点ID
 * @param args  执行SQL所需参数
 * @return 查询结果对应的MODEL(resultType指定的类)集合
 */
public <T> List<T> selectList(String sqlId, Object args) {

    MappedStatement ms = config.getMappedStatement(sqlId);

    Connection conn = null;
    PreparedStatement ps = null;
    ResultSet rs = null;

    try {
        conn = getConnection();
        ps = getPreparedStatement(conn, ms);
        setParameters(ps, ms, args);
        rs = ps.executeQuery();
        
        // 查询结果封装至指定对象中
        return handleResultSet(rs, ms);

    } catch (Exception e) {
        throw new RuntimeException("", e);
    } finally {
        close(rs, ps, conn);
    }

}

查询结果映射的类为SQL节点中resultType属性定义的类. 查询结果的字段名和类中的属性名一致才自动赋值. 如果不一致可以在SQL中加入别名使其与类中属性名一致. 例: select u_name uName from ...

// 将查询结果集封装至对象中
@SuppressWarnings("unchecked")
private <T> List<T> handleResultSet(ResultSet rs, MappedStatement ms) throws Exception {

    List<T> list = new ArrayList<T>();

    // ResultSetMetaData对象保存查询到的数据库相关信息.
    ResultSetMetaData metaData = rs.getMetaData();

    while (rs.next()) {
        // 通过Java反射实例化对应的Javabean, 类型为SQL配置文件中的resultType
        // 如果不设置resultType,则无法知道返回值的类型.所以resultType必须要设置.
        Class<?> classObj = (Class<?>) Class.forName(ms.getResultType());
        T t = (T) classObj.newInstance();

        // 将每个字段的值映射到对应的对象中
        int count = metaData.getColumnCount();
        for (int i = 1; i <= count; i++) {

            // 取得字段对象Javabean中的属性名称
            String ormName = metaData.getColumnLabel(i);
            // 通过属性名称,用Java反射取得Javabean中set方法.
            // Javabean的定义为:所有属性为私有(private),提供共有(public)的get和set方法对其进行操作
            // set方法为设置该属性的方法.set方法格式为set+属性名(首字母大写),例属性为userName,set方法为setUserName()
            Class<?> filedType = classObj.getDeclaredField(ormName).getType();
            Method setter = classObj.getMethod(BeanUtil.getSetter(ormName), filedType);
            
            // 根据数据库字段的类型执行相应的set方法即可将字段值设置到属性中
            setter.invoke(t, getColumnValue(rs, i));

        }

        list.add(t);
    }

    return list;

}

// 根据数据库字段类型获取其在Java中对应类型的值
private Object getColumnValue(ResultSet rs, int index) throws Exception {

    int columnType = rs.getMetaData().getColumnType(index);

    if (columnType == Types.BIGINT) {
        return rs.getLong(index);
    } else if (columnType == Types.INTEGER) {
        return rs.getInt(index);
    } else if (columnType == Types.VARCHAR) {
        return rs.getString(index);
    } else if (columnType == Types.DATE || columnType == Types.TIME || columnType == Types.TIMESTAMP) {
        return rs.getDate(index);
    } else if (columnType == Types.DOUBLE) {
        return rs.getDouble(index);
    }

    return null;
}

测试

用户MODEL

// 用户MODEL
public class User {

    // id
    private Long id;

    // 用户名
    private String uname;

    // 用户年龄
    private Integer uage;

    // 用户地址
    private String uaddr;

    // 备注
    private String remark;

    public User() {
    }

    // 通过用户信息构造用户
    public User(Long id, String uname, Integer uage, String uaddr, String remark) {
        this.id = id;
        this.uname = uname;
        this.uage = uage;
        this.uaddr = uaddr;
        this.remark = remark;
    }
    
    // Getter & Setter
    // ...

}

用户DAO接口

// 用户DAO接口
public interface UserDAO {

    // 创建用户
    int insertUser(User user);

    // 更新用户
    int updateUser(User user);

    // 查询用户
    List<User> selectUser();

}

用户DAO实现类

// 用户DAO
public class UserDAOImpl extends BaseDAO implements UserDAO {

    // SQL会话工厂在父类中
    public UserDAOImpl(SqlSessionFactory sf) {
        super(sf);
    }

    // 添加用户
    public int insertUser(User user) {
        return getSqlSession().update("insertUser", user);
    }

    // 更新用户
    public int updateUser(User user) {
        return getSqlSession().update("updateUser", user);
    }

    // 查询用户
    public List<User> selectUser() {
        return getSqlSession().selectList("selectUser");
    }

}

为便于DAO操作, 所有DAO继承BaseDAO, 其中BaseDAO负责保存SQL会话工厂并提供获取SQL会话的方法.


// DAO基类
public class BaseDAO {

    // SQL会话工厂
    private SqlSessionFactory sf;

    // 通过SQL会话工厂实例化
    public BaseDAO(SqlSessionFactory sf) {
        this.sf = sf;
    }

    // 获取SQL会话
    protected SqlSession getSqlSession() {
        return sf.getSession();
    }

}

新建测试类, 设置Mapper位置并初始化ORM框架, 执行DAO的操作输出结果.

public class TestImpl {

    public static void main(String[] args) {

        // 创建SQL会话工厂
        SqlSessionFactory sf = new SqlSessionFactoryBean("*_mapper.xml").build();

        // 实例化DAO
        UserDAO userDAO = new UserDAOImpl(sf);

        // 调用DAO中方法
        int count = userDAO.insertUser(new User(1L, "zhangsan", 20, "sssss", "ok"));
        List<User> userList = userDAO.selectUser();

        // 输出查询结果
        System.out.println(count);

        for (User u : userList) {
            System.out.println("| " + u.getId() + " | " + u.getUname() + " | ");
        }

    }

}