自定义MyBatis

2021-08-22 22:35:54 阅读：183 来源： 互联网

标签：xml String 自定义 user MyBatis new configuration public

一. 原生 JDBC

1. 原生JDBC使用

public static void main(String[] args) {
    Connection conn = null;
    PreparedStatement preparedStatement = null;
    ResultSet resultSet = null;
    User user = new User();
    List<User> userList = new ArrayList<User>();
    try {
        // 1、加载数据库驱动
        Class.forName("com.mysql.jdbc.Driver");
        // 2、创建数据库连接
        conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8",
                "root","root");
        // 3、定义 SQL 语句
        String sql = "select * from user where username = ?";
        // 4、获取预处理statement
        preparedStatement = conn.prepareStatement(sql);
        // 5、设置参数，第⼀个参数为sql语句中参数的序号(从1开始)，第⼆个参数为设置的参数值
        preparedStatement.setString(1,"zhangsan");
        // 6、向数据库发出sql执⾏查询，查询出结果集
        resultSet = preparedStatement.executeQuery();
        // 7、遍历查询结果
        while (resultSet.next()){
            // 8、封装对象
            user.setId(resultSet.getInt("id"));
            user.setUsername(resultSet.getString("username"));
            userList.add(user);
        }
        for (User user1 : userList) {
            System.out.println(user1.toString());
        }
    }catch (Exception e){
        e.printStackTrace();
    }finally {
        try {
            if (resultSet != null){
                resultSet.close();
            }
            if (preparedStatement != null){
                preparedStatement.close();
            }
            if (conn != null){
                conn.close();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

2. 原生JDBC问题及解决

数据库配置信息存在硬编码问题：可以使用配置文件

频繁创建、释放数据库连接：可以使用连接池

SQL 语句、设置参数、获取结果集参数均存在硬编码问题：可以使用配置文件

返回结果需要手动封装结果集，较为繁琐：可以使用反射、内省解决

二. 自定义持久层框架设计

1. 使用端

SqlMapConfig.xml：存放数据库配置信息和 mapper.xml 的全路径：数据库驱动、数据库连接URL、账户、密码
mapper.xml：存放SQL 配置信息：SQL 语句，参数类型，返回值类型

2. 自定义持久层框架

加载配置文件：根据配置文件的路径，加载配置文件成字节输入流，存储在内存中
- 创建 Resource 类：使用方法 InputStream getResourceAsStream(String path)
创建两个JavaBean（容器对象）：存放的就是对配置文件解析出来的内容
- Configuration：核心配置类，存放 SqlMapConfig.xml 解析出来的内容
- MappedStatement：映射配置类，存放 mapper.xml 解析出来的内容
解析配置文件：dom4J
- 创建类：SqlSessionFactoryBuilder，方法 build(InputStream in)
- 使用 dom4j 解析配置文件，将解析出来的内容封装到容器对象中
- 创建 SqlSessionFactory 对象；生产 SqlSession 会话对象（工厂模式）
创建 SqlSessionFactory 接口及实现类 DefaultSqlSessionFactory
- openSession() 生产 SqlSession
创建 SqlSession 接口及实现类 DefaultSqlSession ，定义对数据库的 CURD 操作
- selectList()、selectOne()、update()、delete()
创建 Executor 接口及实现类 SimpleExecutor
- query()：执行的就是 JDBC 代码

三. 自定义框架实现使用端

1. 使用端项目目录

在这里插入图片描述

2. 数据库表结构

在这里插入图片描述

3. 新建使用端工程

新建Maven工程，命名为 IPersistence_test

pom.xml 文件中导入自定义框架持久层框架的依赖

<dependencies>
    <dependency>
        <groupId>com.mfc</groupId>
        <artifactId>IPersistence</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
</dependencies>

编写实体类，用于封装数据

public class User {
    private int id;
    private String username;
    // set、get、toString 方法省略。。。
}

编写 SqlMapConfig.xml，存放数据库配置信息和 mapper.xml 的全路径：数据库驱动、数据库连接URL、账户、密码

<configuration>
    <!-- 数据库连接信息 -->
    <dataSource>
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
    </dataSource>
    <!-- 引入SQL 配置信息 -->
    <mapper resource="UserMapper.xml"></mapper>
</configuration>

编写 mapper.xml，存放SQL 配置信息：SQL 语句，参数类型，返回值类型

<mapper namespace="user">
    <select id="selectList" resultType="com.mfc.entity.User" paramterType="com.mfc.entity.User">
        select * from user
    </select>
    <select id="selectOne" resultType="com.mfc.entity.User" paramterType="com.mfc.entity.User">
        select * from user where id=#{id} and username=#{username}
    </select>
</mapper>

测试代码

public class Test {
    public static void main(String[] args) throws Exception {
        InputStream inputStream = Resource.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        User user = new User();
        user.setId(1);
        user.setUsername("zhangsan");
        User user1 = sqlSession.selectOne("user.selectOne",user);
        System.out.println(user1);

        List<User> list = sqlSession.selectList("user.selectList");
        for (User user2 : list) {
            System.out.println(user2);
        }
        sqlSession.close();
    }
}

测试效果

四. 自定义框架实现

1. 自定义框架目录

在这里插入图片描述

2. 新建Maven工程

新建Module，命名为 IPersistence

2.1 pom 依赖

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
    <java.version>1.8</java.version>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
</properties>
<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>

2.2 创建 Resource 类

Resource 类加载配置文件，根据配置文件的路径，加载配置文件成字节输入流，存储在内存中

public class Resource {
    public static InputStream getResourceAsStream(String path){
        InputStream inputStream = Resource.class.getClassLoader().getResourceAsStream(path);
        return inputStream;
    }
}

2.3 创建两个JavaBean

存放的就是对配置文件解析出来的内容

Configuration：核心配置类，封装 SqlMapConfig.xml 解析出来的内容（数据库配置信息、mapper配置信息）

public class Configuration {
    private DataSource dataSource;  // 封装数据库连接
    private Map<String,MappedStatement> mappedStatementMap = new HashMap<>();
    // set、get方法省略。。。
}

MappedStatement：映射配置类，封装 mapper.xml 解析出来的内容

/**
<select id="selectList" resultType="com.mfc.entity.User" paramterType="com.mfc.entity.User">
     select * from user
</select>
* */
public class MappedStatement {
    // Id 值
    private String id;
    // SQL 语句
    private String sql;
    // 返回数据类型
    private Class<?> resultType;
    // 传入参数类型
    private Class<?> paramterType;
    // set、get方法省略。。。
}

2.4 解析配置文件

创建类：SqlSessionFactoryBuilder，编写方法 build(InputStream in)，将封装好的 Configuration.java 的对象传递下去。创建 SqlSessionFactory 对象；生产 SqlSession 会话对象（工厂模式）

public class SqlSessionFactoryBuilder {
    public SqlSessionFactory build(InputStream inputStream) throws Exception{
        // 读取并封装配置信息
        XmlConfigurationParse xmlConfigurationParse = new XmlConfigurationParse();
        Configuration configuration = xmlConfigurationParse.parseConfiguration(inputStream);
        // 创建 SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new DefaultSqlSessionFactory(configuration);
        return sqlSessionFactory;
    }
}

使用 dom4j 解析配置文件，将解析出来的内容封装到容器对象中

创建 XmlConfigurationParse，根据 Resource 读取的配置文件字节流解析配置文件SqlMapConfig.xml 和 Mapper.xml ,并将读取到的配置信息封装到 Configuration.java 的对象中

public class XmlConfigurationParse {

    public Configuration parseConfiguration(InputStream inputStream) throws Exception{
        Configuration configuration = new Configuration();

        // 获取 SqlMapConfig.xml 文档
        Document document = new SAXReader().read(inputStream);
        // 获取 SqlMapConfig.xml 文档中的根标签<configuration>
        Element rootElement = document.getRootElement();
        // 获取根标签下的所有 <property> 标签
        List<Element> propertyElementList = rootElement.selectNodes("//property");
        Properties properties = new Properties();
        // 遍历 <property> 标签中的 name 和 value 属性，并获取他们的值，存放在properties集合中
        for (Element propertyElement : propertyElementList) {
            String name = propertyElement.attributeValue("name");
            String value = propertyElement.attributeValue("value");
            properties.setProperty(name,value);
        }
        // 使用从 <property> 读取到的值（数据库连接信息）创建数据库连接池（这里用 C3P0）
        ComboPooledDataSource pool = new ComboPooledDataSource();
        pool.setDriverClass(properties.getProperty("driverClass"));
        pool.setJdbcUrl(properties.getProperty("url"));
        pool.setUser(properties.getProperty("user"));
        pool.setPassword(properties.getProperty("password"));
        // 将数据库连接池封装进 configuration
        configuration.setDataSource(pool);

        // 获取 SqlMapConfig.xml 文档中的根标签下的所有<mapper>标签
        List<Element> mapperElementList = rootElement.selectNodes("//mapper");
        // 遍历所有 <mapper> 标签，并解析 <mapper> 标签引入的 mapper.xml文件，然后封装到configuration
        for (Element mapperElement : mapperElementList) {
            String mapperPath = mapperElement.attributeValue("resource");
            InputStream mapperInputStream = Resource.getResourceAsStream(mapperPath);
            XmlMappedStatementParse xmlMappedStatementParse = new XmlMappedStatementParse(configuration);
            xmlMappedStatementParse.parseMapper(mapperInputStream);
        }
        return configuration;
    }
}

创建 XmlMappedStatementParse，解析 Mapper.xml ,并将读取到的配置信息封装到 Configuration.java 的对象中

public class XmlMappedStatementParse {

    private Configuration configuration;
    public XmlMappedStatementParse(Configuration configuration){
        this.configuration = configuration;
    }
    public void parseMapper(InputStream inputStream) throws Exception{
        Document document = new SAXReader().read(inputStream);
        Element rootElement = document.getRootElement();
        String namespace = rootElement.attributeValue("namespace");
        List<Element> selectElementList = rootElement.selectNodes("//select");
        for (Element selectElement : selectElementList) {
            String id = selectElement.attributeValue("id");
            String sql = selectElement.getTextTrim();
            String resultTypeStr = selectElement.attributeValue("resultType");
            String paramterTypeStr = selectElement.attributeValue("paramterType");
            Class<?> resultType = getClassType(resultTypeStr);
            Class<?> paramterType = getClassType(paramterTypeStr);
            MappedStatement mappedStatement = new MappedStatement();
            mappedStatement.setSql(sql);
            mappedStatement.setId(id);
            mappedStatement.setResultType(resultType);
            mappedStatement.setParamterType(paramterType);
            // 使用 namespace.statementId 作为 唯一标识，区分Mapper.xml中的多个CRUD标签
            String key = namespace + "." + id;
            configuration.getMappedStatementMap().put(key,mappedStatement);
        }
    }
    private Class<?> getClassType(String name) throws Exception{
        return Class.forName(name);
    }
}

2.5 创建 SqlSessionFactory

创建SqlSessionFactory 接口及实现类 DefaultSqlSessionFactory

SqlSessionFactory 接口：

public interface SqlSessionFactory {
    public SqlSession openSession();
}

DefaultSqlSessionFactory 实现类：

DefaultSqlSessionFactory 类实现 SqlSessionFactory 接口，使用 openSession() 生产 SqlSession 。将封装好的 Configuration.java 的对象传递下去（传递给 SqlSession）

public class DefaultSqlSessionFactory implements SqlSessionFactory {
    private Configuration configuration;
    public DefaultSqlSessionFactory(Configuration configuration){
        this.configuration = configuration;
    }
    @Override
    public SqlSession openSession() {
        SqlSession sqlSession = new DefaultSqlSession(configuration);
        return sqlSession;
    }
}

2.6 创建 SqlSession

创建 SqlSession 接口及实现类 DefaultSqlSession ，定义对数据库的 CURD 操作：selectList()、selectOne()、update()、delete()。这里 SqlSession 并不是真正干活的类，我们再创建 Executor 去获取数据库连接、执行SQL、封装返回结果

SqlSession 接口：

public interface SqlSession {    public <E> List<E> selectList(String statementId,Object... params);    public <T> T selectOne(String statementId,Object... params);    public void close() throws SQLException; //关闭数据库连接}

DefaultSqlSession 实现类：

public class DefaultSqlSession implements SqlSession {
    private Configuration configuration;
    private Executor executor = new SimpleExecutor();
    public DefaultSqlSession(Configuration configuration){
        this.configuration = configuration;
    }
    @Override
    public <E> List<E> selectList(String statementId, Object... params) {
        List<E> list = executor.query(configuration,statementId,params);
        return list;
    }
    @Override
    public <T> T selectOne(String statementId, Object... params) {
        List<Object> list = selectList(statementId, params);
        if (list.size() == 1){
            return (T) list.get(0);
        }else{
            throw new RuntimeException("查询结果为空或者查询出多条结果");
        }
    }
    @Override
    public void close() throws SQLException {
        executor.close();
    }
}

2.7 创建 Executor 接口

创建 Executor 接口及实现类 SimpleExecutor，query()：执行的就是 JDBC 代码。其中 TokenHandler 接口、ParameterMappingTokenHandler 类、GenericTokenParser 类都是直接从 MyBatis 源码中 copy 出来的。

Executor 接口：

public interface Executor {
    public <E> List<E> query(Configuration configuration, String statementId, Object[] params);
    public void close() throws SQLException;
}

SimpleExecutor 类实现 Executor 接口:

public class SimpleExecutor implements Executor {
    private Connection connection = null;
    @Override
    public <E> List<E> query(Configuration configuration,
                             String statementId, Object[] params){
        List<Object> returnList = new ArrayList<>();
        try {
            // 获取数据库连接
            connection = configuration.getDataSource().getConnection();
            // 获取 MappedStatement 对象
            MappedStatement mappedStatement = configuration.getMappedStatementMap().get(statementId);
            // 获取 sql
            String sql = mappedStatement.getSql();
            // 解析 SQL（将Sql中的 #{id} 替换成 ？，将#{id}中的id封装起来）
            BoundSql boundSql = getBoundSql(sql);
            // 获取预处理对象 preparedStatement
            PreparedStatement preparedStatement = connection.prepareStatement(boundSql.getSqlText());
            // 获取 sql 中的参数
            List<ParameterMapping> parameter = boundSql.getParameterMappings();
            // 入参类型
            Class<?> parameterType = mappedStatement.getParamterType();
            // 给预处理语句赋值
            for (int i = 0; i < parameter.size(); i++) {
                // 通过反射获取参数属性
                Field field = parameterType.getDeclaredField(parameter.get(i).getContent());
                // 暴力修改
                field.setAccessible(true);
                // field.get(params[0])：方法返回指定对象上由此Field表示的字段的值
                Object object = field.get(params[0]);
                // 给解析后的 SQL 预处理对象 preparedStatement 的占位符赋值
                preparedStatement.setObject(i+1,object);
            }
            // 获取返回结果
            ResultSet resultSet = preparedStatement.executeQuery();
            // 返回类型
            Class<?> resultType = mappedStatement.getResultType();
            // 封装返回结果集
            while (resultSet.next()){
                // 获取返回数据的元数据，ResultSetMetaData中可以获取到ResultSet中列的名称和类型信息
                ResultSetMetaData metaData = resultSet.getMetaData();
                // 每条数据有几列
                int cloumnCount = metaData.getColumnCount();
                // 获取一个返回值的对象
                Object o = resultType.newInstance();
                for (int i = 0;i < cloumnCount; i++){
                    // 获取返回数据的属性名
                    String cloumnName = metaData.getColumnName(i + 1);
                    // 根据返回数据的列名获取这一列对应的值，属性值
                    Object cloumnValue = resultSet.getObject(cloumnName);
                    // 创建属性描述器，为属性生成读写方法
                    PropertyDescriptor propertyDescriptor = new PropertyDescriptor(cloumnName,resultType);
                    // 获取用于写入属性值的方法
                    Method method = propertyDescriptor.getWriteMethod();
                    // 执行用于写入属性值的方法，将属性值赋给返回值对象中的 cloumnName 属性
                    method.invoke(o,cloumnValue);
                }
                returnList.add(o);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return (List<E>) returnList;
    }

    @Override
    public void close() throws SQLException {
        // 关闭数据库连接
        connection.close();
    }

    private BoundSql getBoundSql(String sql){
        /*
        * 标记处理类：主要是配合通用标记解析器GenericTokenParser类完成对配置文件等的
        * 解析工作，其中 TokenHandler 主要完成处理
        * */
        ParameterMappingTokenHandler parameterMappingTokenHandler = new ParameterMappingTokenHandler();
        /*
        * GenericTokenParser:通用的标记解析器，完成了代码片段中占位符的解析，然后再根据给定的标记处理器（TokenHandler）来进行表达式的处理
        * 三个参数：
        *   openToken：开始标记
        *   closeToken：结束标记
        *   handler：标记处理器
        * */
        GenericTokenParser genericTokenParser = new GenericTokenParser("#{","}",parameterMappingTokenHandler);
        String sqlText = genericTokenParser.parse(sql);
        List<ParameterMapping> parameterMappings = parameterMappingTokenHandler.getParameterMappings();
        BoundSql boundSql = new BoundSql(sqlText,parameterMappings);
        return boundSql;
    }
}

SimpleExecutor 中使用的 BoundSql 对象，此对象封装解析后的 SQL 和解析出来的参数

public class BoundSql {
    // 解析后的 SQL
    private String sqlText;
    // 解析出来的参数
    private List<ParameterMapping> parameterMappings;

    public BoundSql(String sqlText, List<ParameterMapping> parameterMappings) {
        this.sqlText = sqlText;
        this.parameterMappings = parameterMappings;
    }
    // set、get方法省略。。。
}

ParameterMapping ，用于封装解析出来的参数名称，每一个 ParameterMapping 对象对应一个参数名称

public class ParameterMapping {
    private String content;

    public ParameterMapping(String content) {
        this.content = content;
    }
    // set、get 方法省略
}

SimpleExecutor 中使用的 ParameterMappingTokenHandler：标记处理类，主要是配合通用标记解析器GenericTokenParser类完成对配置文件等的解析工作，其中 TokenHandler 主要完成处理

TokenHandler 接口：

public interface TokenHandler {
  String handleToken(String content);
}

ParameterMappingTokenHandler 实现 TokenHandler 接口:

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

SimpleExecutor 中使用的 GenericTokenParser：通用的标记解析器，完成了代码片段中占位符的解析，然后再根据给定的标记处理器（TokenHandler）来进行表达式的处理。GenericTokenParser 的构造器有三个参数（openToken：开始标记；closeToken：结束标记；handler：标记处理器）

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

五. 自定义框架优化

1. 自定义框架的问题

通过上面的自定义框架，解决了 JDBC 操作数据库带来的一些问题，例如频繁创建释放数据库连接，硬编码，手动封装返回结果集等问题。但是继续分析上面完成的自定义框架，还存在以下问题：

每一次调用 SqlSession 的方法时，都需要读取配置文件，获取 SqlSessionFactoryBuilder、SqlSessionFactory、SqlSession。如果在 Dao 层的每一个持久化方法中都写以下模板代码，导致代码重复、臃肿。这一部分可以在使用端进行优化，将其封装成一个静态方法：
```
InputStream inputStream = Resource.getResourceAsStream("SqlMapConfig.xml");
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
```

在上面使用端中还是存在硬编码，在调用 SqlSession 的方法时，参数 statementId 还是写死的（硬编码）。这一部分可以使用代理模式来进行优化

public class Test {
    public static void main(String[] args) throws Exception {
        InputStream inputStream = Resource.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        User user = new User();
        user.setId(1);
        user.setUsername("zhangsan");
        User user1 = sqlSession.selectOne("user.selectOne",user);
        System.out.println(user1);

        List<User> list = sqlSession.selectList("user.selectList");
        for (User user2 : list) {
            System.out.println(user2);
        }
        sqlSession.close();
    }
}

2. 解决自定义框架问题

2.1 自定义框架

在自定义持久层框架的项目中使用代理模式优化硬编码问题

在 SqlSession 接口中添加方法：

public <T> T getMapper(Class<?> clazz);

在 DefaultSqlSession 中添加方法的实现:

public <T> T getMapper(Class<?> clazz) {
    Object obj = Proxy.newProxyInstance(DefaultSqlSession.class.getClassLoader(), new Class[]{clazz}, new InvocationHandler() {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            String methodName = method.getName();
            String className = clazz.getName();
            String key = className + "." + methodName;
            Type type = method.getGenericReturnType();
            // 判断参数是否泛型化
            if (type instanceof ParameterizedType){
                return selectList(key,args);
            }else{
                return selectOne(key,args);
            }
        }
    });
    return (T) obj;
}

2.2 在使用端修改并测试

此时需要编写一个 Dao 层的接口，无需实现类：

public interface UserDao {
    public List<User> selectList(User user);
    public User selectOne(User user);
}

mapper.xml 中 mapper 标签的 namespace 需要修改成 Dao 层接口的全限定名

<mapper namespace="com.mfc.dao.UserDao">
    <select id="selectList" resultType="com.mfc.entity.User" paramterType="com.mfc.entity.User">
        select * from user
    </select>
    <select id="selectOne" resultType="com.mfc.entity.User" paramterType="com.mfc.entity.User">
        select * from user where id=#{id} and username=#{username}
    </select>
</mapper>

测试

public static void main(String[] args) throws Exception {
    InputStream inputStream = Resource.getResourceAsStream("SqlMapConfig.xml");
    SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
    SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
    SqlSession sqlSession = sqlSessionFactory.openSession();
    User user = new User();
    user.setId(1);
    user.setUsername("zhangsan");
    UserDao userDao = sqlSession.getMapper(UserDao.class);
    User userMapper = userDao.selectOne(user);
    System.out.println(userMapper);
    sqlSession.close();
}

3. 代理模式解析

在这里插入图片描述

标签：xml,String,自定义,user,MyBatis,new,configuration,public
来源： https://www.cnblogs.com/fanchengmeng/p/15173871.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

自定义MyBatis

一. 原生 JDBC

1. 原生JDBC使用

2. 原生JDBC问题及解决

二. 自定义持久层框架设计

1. 使用端

2. 自定义持久层框架

三. 自定义框架实现使用端

1. 使用端项目目录

2. 数据库表结构

3. 新建使用端工程

四. 自定义框架实现

1. 自定义框架目录

2. 新建Maven工程

2.1 pom 依赖

2.2 创建 Resource 类

2.3 创建两个JavaBean

2.4 解析配置文件

2.5 创建 SqlSessionFactory

2.6 创建 SqlSession

2.7 创建 Executor 接口

五. 自定义框架优化

1. 自定义框架的问题

2. 解决自定义框架问题

2.1 自定义框架

2.2 在使用端修改并测试

3. 代理模式解析