闭关修炼180天--手写持久层框架（mybatis简易版）

2022-09-27 11:15:33

闭关修炼180天--手写持久层框架（mybatis简易版）

抛砖引玉

首先先看一段传统的JDBC编码的代码实现：

//传统的JDBC实现

public static void main(String[] args) {

    Connection connection = null;

    PreparedStatement preparedStatement = null;

    ResultSet resultSet = null;

    try {

        //加载数据库驱动

        Class.forName("com.mysql.jdbc.Driver");

        //通过驱动管理类获取数据库管理

        connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8","root","root");

        //定义sql语句

        String sql = "select * from user where username = ?";

        //获取预处理对象statement

        preparedStatement  = connection.prepareStatement(sql);

        //设置参数，第一个参数为sql语句中的参数的序号(从1开始)，第二个参数为设置的参数值

        preparedStatement.setString(1,"tom");

        //像数据库发出sql执行查询，查询出结果集

        resultSet = preparedStatement.executeQuery();

        while (resultSet.next()){

            int id = resultSet.getInt("id");

            String username = resultSet.getString("username");

            String password = resultSet.getString("password");

            //将查询出的结果集封装进实体中

            User user = new User();

            user.setId(id);

            user.setUsername(username);

            user.setPassword(password);

        }

    } catch (Exception e) {

        e.printStackTrace();

    }finally {

        //释放资源

        try {

            connection.close();

        } catch (SQLException e) {

            e.printStackTrace();

        }

    }

}

通过以上传统的JDBC操作数据库的代码可以发现，我们能总结出来以下几条问题：

每执行一次sql都要建立一次数据库连接，数据库连接创建、释放频繁造成系统资源浪费，从而影响系统性能。
Sql编写在了代码中存在硬编码问题，实际上工作中sql变化是比较大的，每次都要修改代码，sql语句不易维护。
使用preparedStatement向占有位符号传参数存在硬编码，因为sql语句的where条件不一定，可能多也可能少，修改sql还要修改代码，系统不易维护。
对结果集解析存在硬编码(查询列名)，sql变化导致解析代码变化，系统不易维护，如果能将数据库记录自动封装成pojo对象解析比较方便。

针对以上的几条JDBC问题，我们可以大致的延伸出以下几点的解决思路：

使用数据库连接池初始化连接资源。
将sql语句写在xml文件中，在代码中剥离出来单独维护。
使用反射内省等技术，完成数据库的表字段和实体的属性的自动映射。

深入剖析

本次完成持久层框架的自定义编写便是从以上几个方面入手，来解决传统的JDBC存在的问题，在编写之前，我们首先要明白，框架属于开发的一个半成品，是我们在开发过程中可以直接拿来用的东西，我们在自定义编写时，什么代码是框架中所有的，什么代码属于使用端（一般开发人员）提供的，这点要想明白。经分析，大体划分如下：

使用端

提供核心配置文件：
- sqlMapConfig.xml文件，配置数据源等信息，同时引入Mapper.xml。
- Mapper.xml文件，配置sql语句等信息。

框架端

读取配置文件，将配置文件加载成字节输入流存放在内存中，准备好两个javaBean用来存储以后解析配置文件出来的数据。
- Configuration:存放数据源信息dataBase、Map<String,MappedStatement>、key为唯一标识：namespace+id，value是sql相关信息实体。
- MappedStatement:存放sql相关信息，包含id,sql语句，入参类型，返回值类型等。
解析配置文件，创建SqlSessionFactoryBuild类，提供build(InputStream in)方法，用于构建SqlSessionFactory。
- 使用dom4j技术解析xml配置文件，将解析出来的数据存放到javaBean中。
- 创建SqlSessionFactory的实现类DefaultSqlSessionFactory
生产会话对象。在SqlSessionFactory中提供openSession()方法，用于生产SqlSession。
创建SqlSession接口及其实现类，用于封装crud方法。
- selectList(String statementId,Object... param) 查询全部
- selectOne(String statementId,Object... param) 查询单个
执行实际的JDBC操作。创建Executor接口及其实现类SimpleExecutor，提供query(Configuration configuration, MappedStatement mappedStatement, Object... params）方法，完成实际的与数据库交互的工作。
- 从连接池中获取连接
- 处理sql语句
- 设置参数
- 封装结果集

涉及到的设计模式

构建者模式
工厂模式
代理模式

代码实现

这里只贴出核心代码，全部代码请看我的码云：https://gitee.com/zang-chuanlei/FrameMyBatis.git

在这里需要创建两个项目：FrameMyBatistest和FrameMyBatis，其中FrameMyBatis_test代表的是使用端，FrameMyBatis代表的是框架端，项目结构如下：

1.在FrameMyBatis_test下面的resources目录下添加两个配置文件sqlMapConfig.xml和UserMapper.xml

<configuration>

    <dataSource>

        <property name="dataDriver" value="com.mysql.jdbc.Driver"></property>

        <property name="dataUrl" value="jdbc:mysql:///mybatis"></property>

        <property name="username" value="root"></property>

        <property name="password" value="root"></property>

    </dataSource>

    <!--加载UserMapper.xml配置文件-->

    <mapper resource="UserMapper.xml"></mapper>

</configuration>

<mapper namespace="com.zae.dao.UserDao">

    <select id="findAll" resultType="com.zae.entity.User">

        select * from users

    </select>

    <select id="findOne" resultType="com.zae.entity.User" paramterType="com.zae.entity.User">

        select * from users where id=#{id} and username=#{username}

    </select>

</mapper>

2.给FrameMyBatis引入一些需要的坐标

<dependencies>

        <dependency>

            <groupId>mysql</groupId>

            <artifactId>mysql-connector-java</artifactId>

            <version>5.1.17</version>

        </dependency>

        <dependency>

            <groupId>c3p0</groupId>

            <artifactId>c3p0</artifactId>

            <version>0.9.1.2</version>

        </dependency>

        <dependency>

            <groupId>log4j</groupId>

            <artifactId>log4j</artifactId>

            <version>1.2.12</version>

        </dependency>

        <dependency>

            <groupId>junit</groupId>

            <artifactId>junit</artifactId>

            <version>4.10</version>

        </dependency>

        <dependency>

            <groupId>dom4j</groupId>

            <artifactId>dom4j</artifactId>

            <version>1.6.1</version>

        </dependency>

        <dependency>

            <groupId>jaxen</groupId>

            <artifactId>jaxen</artifactId>

            <version>1.1.6</version>

        </dependency>

    </dependencies>

3.在FrameMyBatis下创建Resources类，用于加载字节输入流。

import java.io.InputStream;

public class Resources {

    /**

     * 根据xml路径将xml文件加载成字节流，存放在内存中

     * @param path

     * @return

     */

    public static InputStream getInputStreamByXml(String path){

        InputStream resourceAsStream = Resources.class.getClassLoader().getResourceAsStream(path);

        return resourceAsStream;

    }

}

4.创建两个bean，Configuration和MappedStatement

import javax.sql.DataSource;

import java.util.HashMap;

import java.util.Map;

/**

 * javaBean之一：用来装sqlMapConfig.xml文件的内容

 */

public class Configuration {

    /**

     * 存储数据源连接信息

     */

    private DataSource dataSource;

    /**

     * 存储加载进来的mapper.xml里面的数据

     * key = statementId = namespace+"."+id

     * value = mapperStatement

     */

    private Map<String,MapperStatement> mapperStatementMap = new HashMap<String, MapperStatement>();

    public DataSource getDataSource() {

        return dataSource;

    }

    public void setDataSource(DataSource dataSource) {

        this.dataSource = dataSource;

    }

    public Map<String, MapperStatement> getMapperStatementMap() {

        return mapperStatementMap;

    }

    public void setMapperStatementMap(Map<String, MapperStatement> mapperStatementMap) {

        this.mapperStatementMap = mapperStatementMap;

    }

}

/**

 * javaBean-2用来装载mapper.xml的数据

 * 一条sql语句信息封装在一个MapperStatement对象中

 */

public class MapperStatement {

    private String id;

    private String resultType;

    private String paramterType;

    private String sql;

    public String getId() {

        return id;

    }

    public void setId(String id) {

        this.id = id;

    }

    public String getResultType() {

        return resultType;

    }

    public void setResultType(String resultType) {

        this.resultType = resultType;

    }

    public String getParamterType() {

        return paramterType;

    }

    public void setParamterType(String paramterType) {

        this.paramterType = paramterType;

    }

    public String getSql() {

        return sql;

    }

    public void setSql(String sql) {

        this.sql = sql;

    }

}

5.创建SqlSessionFactoryBuild

import com.zae.config.XmlConfigBuilder;

import com.zae.pojo.Configuration;

import java.io.InputStream;

public class SqlSessionFactoryBuilder {

    /**

     * 构建SqlSessionFactory工厂

     * @param inputStream

     * @return

     */

    public SqlSessionFactory build(InputStream inputStream) throws Exception{

        //完成xml文件的解析

        XmlConfigBuilder xmlConfigBuilder = new XmlConfigBuilder();

        Configuration configuration = xmlConfigBuilder.parasConfig(inputStream);

        DefaultSqlSessionFactory defaultSqlSessionFactory = new DefaultSqlSessionFactory(configuration);

        return defaultSqlSessionFactory;

    }

}

6.创建解析XML文件的两个专属类XmlConfigBuilder和XmlMapperBuilder

import com.mchange.v2.c3p0.ComboPooledDataSource;

import com.zae.io.Resources;

import com.zae.pojo.Configuration;

import org.dom4j.Document;

import org.dom4j.Element;

import org.dom4j.io.SAXReader;

import java.io.InputStream;

import java.util.List;

import java.util.Properties;

/**

 * 解析sqlMapConfig.xml文件存放在javaBean中

 */

public class XmlConfigBuilder {

    private Configuration  configuration;

    public XmlConfigBuilder(){

        this.configuration = new Configuration();

    }

    /**

     * 解析sqlMapConfig.xml文件

     * @param inputStream

     * @return

     */

    public Configuration parasConfig(InputStream inputStream) throws Exception{

        SAXReader saxReader = new SAXReader();

        Document document = saxReader.read(inputStream);

        //获取根标签里面的内容

        Element rootElement = document.getRootElement();

        //获取所有的property标签里面的内容

        List<Element> list = rootElement.selectNodes("//property");

        //将数据库连接信息读取到properties文件中

        Properties properties = new Properties();

        for (Element element : list) {

            //获取子标签里面的属性

            String name = element.attributeValue("name");

            String value = element.attributeValue("value");

            properties.setProperty(name,value);

        }

        //创建数据库连接池

        ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();

        comboPooledDataSource.setDriverClass(properties.getProperty("dataDriver"));

        comboPooledDataSource.setJdbcUrl(properties.getProperty("dataUrl"));

        comboPooledDataSource.setUser(properties.getProperty("username"));

        comboPooledDataSource.setPassword(properties.getProperty("password"));

        //给configuration里面的数据源属性赋值

        configuration.setDataSource(comboPooledDataSource);

        //解析xl文件的数据

        List<Element> mapperList = rootElement.selectNodes("//mapper");

        for (Element element : mapperList) {

            //获取到mapper.xml文件的路径

            String resource = element.attributeValue("resource");

            //获取mapper文件的输入流

            InputStream mapperInputStream = Resources.getInputStreamByXml(resource);

            XmlMapperBuilder xmlMapperBuilder = new XmlMapperBuilder(configuration);

            xmlMapperBuilder.parasMapper(mapperInputStream);

        }

        return configuration;

    }

}

import com.zae.pojo.Configuration;

import com.zae.pojo.MapperStatement;

import org.dom4j.Document;

import org.dom4j.Element;

import org.dom4j.io.SAXReader;

import java.io.InputStream;

import java.util.List;

/**

 * 解析mapper.xml数据存放到javaBean中

 */

public class XmlMapperBuilder {

    private Configuration configuration;

    public XmlMapperBuilder(Configuration configuration){

        this.configuration = configuration;

    }

    public void parasMapper(InputStream mapperInputStream) throws Exception {

        SAXReader saxReader = new SAXReader();

        Document document = saxReader.read(mapperInputStream);

        //获取根标签的数据-mapper

        Element rootElement = document.getRootElement();

        //获取命名空间

        String namespace = rootElement.attributeValue("namespace");

        //获取所有的select标签的内容

        List<Element> elementList = rootElement.selectNodes("//select");

        for (Element element : elementList) {

            String id = element.attributeValue("id");

            String resultType = element.attributeValue("resultType");

            String paramterType = element.attributeValue("paramterType");

            String sql = element.getTextTrim();

            MapperStatement mapperStatement = new MapperStatement();

            mapperStatement.setId(id);

            mapperStatement.setResultType(resultType);

            mapperStatement.setParamterType(paramterType);

            mapperStatement.setSql(sql);

            String key = namespace+"."+id;

            configuration.getMapperStatementMap().put(key,mapperStatement);

        }

    }

}

7.创建sqlSessionFactory接口及DefaultSqlSessionFactory 实现类

public interface SqlSessionFactory {

    SqlSession openSqlSession();

}

import com.zae.pojo.Configuration;

public class DefaultSqlSessionFactory implements SqlSessionFactory {

    private Configuration configuration;

    public DefaultSqlSessionFactory(Configuration configuration){

        this.configuration = configuration;

    }

    public SqlSession openSqlSession() {

        return new DefaultSqlSession(configuration);

    }

}

8.创建sqlSession 接口及DefaultSqlSession 实现类

import java.util.List;

public interface SqlSession {

    <E> List<E> findAll(String statementId,Object ... params) throws Exception;

    <T> T findOne(String statement,Object ...params)throws Exception;

    <T> T getMapper(Class<?> mapperClass);

}

import com.zae.pojo.Configuration;

import com.zae.pojo.MapperStatement;

import java.lang.reflect.*;

import java.util.List;

import java.util.Map;

public class DefaultSqlSession implements SqlSession {

    private Configuration configuration;

    public DefaultSqlSession(Configuration configuration){

        this.configuration = configuration;

    }

    public <E> List<E> findAll(String statementId, Object... params) throws Exception{

        Map<String, MapperStatement> statementMap = configuration.getMapperStatementMap();

        MapperStatement mapperStatement = statementMap.get(statementId);

        Executor executor = new SimpleExecutor();

        List<Object> execute = executor.execute(configuration,mapperStatement,params);

        return (List<E>) execute;

    }

    public <T> T findOne(String statement, Object... params) throws Exception{

        List<Object> objectList = findAll(statement, params);

        if(objectList.size() == 1){

            return (T) objectList.get(0);

        }else{

            throw new RuntimeException("返回参数不唯一或者为空");

        }

    }

    public <T> T getMapper(Class<?> aclass) {

        Object object = Proxy.newProxyInstance(DefaultSqlSession.class.getClassLoader(), new Class[]{aclass}, new InvocationHandler() {

            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                //获取执行方法名

                String methodName = method.getName();

                //获取全限类名

                String className = method.getDeclaringClass().getName();

                //statementId

                String statementId = className+"."+methodName;

                //参数泛型化

                Type type = method.getGenericReturnType();

                if(type instanceof ParameterizedType){

                    //存在泛型，则调用findAll

                    List<Object> all = findAll(statementId, args);

                    return all;

                }

                return findOne(statementId,args);

            }

        });

        return (T) object;

    }

}

9.创建Executor接口及SimpleExecutor实现类，创建BoundSql实体，引入工具类。

import com.zae.pojo.Configuration;

import com.zae.pojo.MapperStatement;

import java.util.List;

public interface Executor {

    /**

     * jdbc处理方法

     * @param configuration

     * @param mapperStatement

     * @param params

     * @param <E>

     * @return

     */

   <E> List<E> execute(Configuration configuration, MapperStatement mapperStatement, Object ...params) throws Exception;

}

import com.zae.pojo.BorundSql;

import com.zae.pojo.Configuration;

import com.zae.pojo.MapperStatement;

import com.zae.utils.GenericTokenParser;

import com.zae.utils.ParameterMapping;

import com.zae.utils.ParameterMappingTokenHandler;

import java.beans.PropertyDescriptor;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.util.ArrayList;

import java.util.List;

public class SimpleExecutor implements Executor {

    public <E> List<E> execute(Configuration configuration, MapperStatement mapperStatement, Object... params) throws Exception{

        //1.获取连接对象

        Connection connection = configuration.getDataSource().getConnection();

        //2.处理sql语句

        String sql = mapperStatement.getSql();

        BorundSql borundSql = dealSql(sql);

        String sqlNow = borundSql.getSql();

        List<ParameterMapping> mappingList = borundSql.getParameterMappingList();

        //3.获取预处理对象

        PreparedStatement preparedStatement = connection.prepareStatement(sqlNow);

        //4.设置参数

        Class<?> classByType = getClassByType(mapperStatement.getParamterType());

        for(int i = 0;i<mappingList.size();i++){

            String content = mappingList.get(i).getContent();

            //根据属性名获取该属性信息

            Field declaredField = classByType.getDeclaredField(content);

            //设置暴力访问

            declaredField.setAccessible(true);

            //获取参数里面的值

            Object value = declaredField.get(params[0]);

            //设置参数

            preparedStatement.setObject(i+1,value);

        }

        //5.处理返回结果集

        ResultSet resultSet = preparedStatement.executeQuery();

        Class<?> resultClass = getClassByType(mapperStatement.getResultType());

        List resultList = new ArrayList();

        while (resultSet.next()){

            //生成该类的实例对象

            Object object = resultClass.newInstance();

            ResultSetMetaData metaData = resultSet.getMetaData();

            for(int i = 1;i<=metaData.getColumnCount();i++){

                //获取列的名称

                String columnName = metaData.getColumnName(i);

                //根据列的名称获取内容

                Object value = resultSet.getObject(columnName);

                //使用反射或内省，完成字段和数据库的映射

                PropertyDescriptor propertyDescriptor = new PropertyDescriptor(columnName,resultClass);

                //获取写入方法

                Method writeMethod = propertyDescriptor.getWriteMethod();

                //调用invoke方法，将数据写入实体

                writeMethod.invoke(object,value);

            }

            resultList.add(object);

        }

        return resultList;

    }

    /**

     * 处理sql，将sql中的#{}处理成?,并把#{}里面的字段保存下来

     * @param sourceSql

     * @return

     */

    private BorundSql dealSql(String sourceSql){

        ParameterMappingTokenHandler parameterMappingTokenHandler = new ParameterMappingTokenHandler();

        GenericTokenParser genericTokenParser = new GenericTokenParser("#{","}",parameterMappingTokenHandler);

        String targetSql = genericTokenParser.parse(sourceSql);

        List<ParameterMapping> parameterMappings = parameterMappingTokenHandler.getParameterMappings();

        BorundSql borundSql = new BorundSql();

        borundSql.setSql(targetSql);

        borundSql.setParameterMappingList(parameterMappings);

        return borundSql;

    }

    /**

     * 根据类的全路径获取类对象

     * @param path

     * @return

     */

    private Class<?> getClassByType(String path) throws ClassNotFoundException {

        if(path!=null){

            Class<?> aClass = Class.forName(path);

            return aClass;

        }else{

            return null;

        }

    }

}

import com.zae.utils.ParameterMapping;

import java.util.List;

public class BorundSql {

    private String sql;

    private List<ParameterMapping> parameterMappingList;

    public String getSql() {

        return sql;

    }

    public void setSql(String sql) {

        this.sql = sql;

    }

    public List<ParameterMapping> getParameterMappingList() {

        return parameterMappingList;

    }

    public void setParameterMappingList(List<ParameterMapping> parameterMappingList) {

        this.parameterMappingList = parameterMappingList;

    }

}

工具类如下：

public class GenericTokenParser {

  private final String openToken; //开始标记

  private final String closeToken; //结束标记

  private final TokenHandler handler; //标记处理器

  public GenericTokenParser(String openToken, String closeToken, TokenHandler handler) {

    this.openToken = openToken;

    this.closeToken = closeToken;

    this.handler = handler;

  }

  /**

   * 解析${}和#{}

   * @param text

   * @return

   * 该方法主要实现了配置文件、脚本等片段中占位符的解析、处理工作，并返回最终需要的数据。

   * 其中，解析工作由该方法完成，处理工作是由处理器handler的handleToken()方法来实现

   */

  public String parse(String text) {

    // 验证参数问题，如果是null，就返回空字符串。

    if (text == null || text.isEmpty()) {

      return "";

    }

    // 下面继续验证是否包含开始标签，如果不包含，默认不是占位符，直接原样返回即可，否则继续执行。

    int start = text.indexOf(openToken, 0);

    if (start == -1) {

      return text;

    }

   // 把text转成字符数组src，并且定义默认偏移量offset=0、存储最终需要返回字符串的变量builder，

    // text变量中占位符对应的变量名expression。判断start是否大于-1(即text中是否存在openToken)，如果存在就执行下面代码

    char[] src = text.toCharArray();

    int offset = 0;

    final StringBuilder builder = new StringBuilder();

    StringBuilder expression = null;

    while (start > -1) {

     // 判断如果开始标记前如果有转义字符，就不作为openToken进行处理，否则继续处理

      if (start > 0 && src[start - 1] == '\\') {

        builder.append(src, offset, start - offset - 1).append(openToken);

        offset = start + openToken.length();

      } else {

        //重置expression变量，避免空指针或者老数据干扰。

        if (expression == null) {

          expression = new StringBuilder();

        } else {

          expression.setLength(0);

        }

        builder.append(src, offset, start - offset);

        offset = start + openToken.length();

        int end = text.indexOf(closeToken, offset);

        while (end > -1) {////存在结束标记时

          if (end > offset && src[end - 1] == '\\') {//如果结束标记前面有转义字符时

            // this close token is escaped. remove the backslash and continue.

            expression.append(src, offset, end - offset - 1).append(closeToken);

            offset = end + closeToken.length();

            end = text.indexOf(closeToken, offset);

          } else {//不存在转义字符，即需要作为参数进行处理

            expression.append(src, offset, end - offset);

            offset = end + closeToken.length();

            break;

          }

        }

        if (end == -1) {

          // close token was not found.

          builder.append(src, start, src.length - start);

          offset = src.length;

        } else {

          //首先根据参数的key（即expression）进行参数处理，返回?作为占位符

          builder.append(handler.handleToken(expression.toString()));

          offset = end + closeToken.length();

        }

      }

      start = text.indexOf(openToken, offset);

    }

    if (offset < src.length) {

      builder.append(src, offset, src.length - offset);

    }

    return builder.toString();

  }

}

public class ParameterMapping {

    private String content;

    public ParameterMapping(String content) {

        this.content = content;

    }

    public String getContent() {

        return content;

    }

    public void setContent(String content) {

        this.content = content;

    }

}

import java.util.ArrayList;

import java.util.List;

public class ParameterMappingTokenHandler implements TokenHandler {

    private List<ParameterMapping> parameterMappings = new ArrayList<ParameterMapping>();

    // context是参数名称 #{id} #{username}

    public String handleToken(String content) {

        parameterMappings.add(buildParameterMapping(content));

        return "?";

    }

    private ParameterMapping buildParameterMapping(String content) {

        ParameterMapping parameterMapping = new ParameterMapping(content);

        return parameterMapping;

    }

    public List<ParameterMapping> getParameterMappings() {

        return parameterMappings;

    }

    public void setParameterMappings(List<ParameterMapping> parameterMappings) {

        this.parameterMappings = parameterMappings;

    }

}

public interface TokenHandler {

  String handleToken(String content);

}

10.在FrameMyBatis_test项目的pom文件中引入FrameMyBatis的坐标，在准备好的FrameMyBatis_test下编写测试类FrameTest

import com.zae.dao.UserDao;

import com.zae.entity.User;

import com.zae.io.Resources;

import com.zae.session.SqlSession;

import com.zae.session.SqlSessionFactory;

import com.zae.session.SqlSessionFactoryBuilder;

import org.junit.Before;

import org.junit.Test;

import java.io.InputStream;

import java.util.List;

public class FrameTest {

    private SqlSession sqlSession;

    private UserDao userDao;

    @Before

    public void test1() throws Exception{

        //获取字节输入流

        InputStream inputStream = Resources.getInputStreamByXml("sqlMapConfig.xml");

        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        sqlSession = sqlSessionFactory.openSqlSession();

        userDao = sqlSession.getMapper(UserDao.class);

    }

    /**

     * 全查

     * @throws Exception

     */

    @Test

    public void test2()throws Exception{

        List<User> all = sqlSession.findAll("com.zae.dao.UserDao.findAll");

        for (User user : all) {

            System.out.println(user);

        }

    }

    /**

     * 单条

     * @throws Exception

     */

    @Test

    public void test3() throws Exception{

        User user = new User();

        user.setId("1");

        user.setUsername("sss");

        User one = sqlSession.findOne("user.findOne", user);

        System.out.println(one);

    }

    /**

     * 代理对象查询

     * @throws Exception

     */

    @Test

    public void test4() throws Exception{

        List<User> userList = userDao.findAll(null);

        for (User user : userList) {

            System.out.println(user);

        }

    }

}

我是帝莘，期待与你的技术交流和思想碰撞。

码农公寓

闭关修炼180天--手写持久层框架（mybatis简易版）

抛砖引玉

通过以上传统的JDBC操作数据库的代码可以发现，我们能总结出来以下几条问题：

针对以上的几条JDBC问题，我们可以大致的延伸出以下几点的解决思路：

深入剖析

使用端

框架端

涉及到的设计模式

代码实现

相关文章