Mybatis1-自定义持久层框架

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");
            // 封装User
            user.setId(id);
            user.setUsername(username);
        }
        System.out.println(user);
    }
} catch(Exception e){
    e.printStackTrace();
} finally{
    // 释放资源
    if (resultSet != null) {
        try {
            resultSet.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    if (preparedStatement != null) {
        try {
            preparedStatement.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    if (connection != null) {
        try {
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

 如上一个jdbc的写法，存在两个缺点:

硬编码：不管是sql语句，还是参数，还是取值，都是硬编码，不好维护。

链接频繁创建和释放：每次访问都会创建新的链接，用完后释放，造成系统资源浪费。

 解决办法：

可以通过连接池管理链接。

可以用xml文件，将sql等信息配置，通过反射等技术实现动态映射。

 1、定义全局配置文件sqlMapConfig.xml来存放数据源信息；  定义Mapper.xml来动态配置sql语句，比如，定义UserMapper.xml操作User。

sqlMapConfig.xml：

 UserMapper.xml:

    
        select * from user where id = #{id} and username =#{username}
    
    
        select * from user
    
 
 
User实体：
 
 
 
public class User {

    private Integer id;
    private String username;


    public Integer getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + ''' +
                '}';
    }
}
 
 
 
 
 
持久层框架项目B 
 在业务项目A中配置了xml文件，持久层框架要做的事，就是将配置文件通过流的方式读取， 并创建javaBean，才能传递使用。具体流程：
 
导入相关依赖：
 
 
 

    UTF-8
    UTF-8
    1.8
    1.8
    1.8



 
 

    
        mysql
        mysql-connector-java
        5.1.17
    
    
    
        c3p0
        c3p0
        0.9.1.2
    
    
        log4j
        log4j
        1.2.12
    
    
        junit
        junit
        4.10
    
    
    
        dom4j
        dom4j
        1.6.1
    
    
    
        jaxen
        jaxen
        1.1.6
    

 
 
创建MappedStatement类对应mapper.xml中的每个sql标签：
 
 
 
public class MappedStatement {

    //id标识
    private String id;
    //返回值类型
    private String resultType;
    //参数值类型
    private String paramterType;
    //sql语句
    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;
    }
}
 
 
 
创建Configuration类对应sqlMapConfig.xml，封装数据源信息
 
 
 
 
 
public class Configuration {

    private DataSource dataSource;

    
    Map mappedStatementMap = new HashMap<>();

    public DataSource getDataSource() {
        return dataSource;
    }

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    public Map getMappedStatementMap() {
        return mappedStatementMap;
    }

    public void setMappedStatementMap(Map mappedStatementMap) {
        this.mappedStatementMap = mappedStatementMap;
    }
}
 
 
如上，使用DataSource封装xml中的数据库信息，另外，在mapper.xml中有多个select标签，所以这里用map封装到一起传递，后续可以选择具体的某一个来填充业务参数。
 
 
有了承载xml的java类后，就需要通过流，读取到对应的javaBean中。
 
定义Resource类，读取配置文件为流：
 
 
 
import java.io.InputStream;

public class Resources {
    // 根据配置文件的路径，将配置文件加载成字节输入流，存储在内存中
    public static InputStream getResourceAsSteam(String path){
        InputStream resourceAsStream = Resources.class.getClassLoader().getResourceAsStream(path);
        return  resourceAsStream;
    }
} 
 
 
定义XMLConfigBuilder类，将流中的信息读取到Configuration中
 
 
 
public class XMLConfigBuilder {

    private Configuration configuration;

    public XMLConfigBuilder() {
        this.configuration = new Configuration();
    }

    
    public Configuration parseConfig(InputStream inputStream) throws DocumentException, PropertyVetoException {

        Document document = new SAXReader().read(inputStream);
        //
        Element rootElement = document.getRootElement();
        List list = rootElement.selectNodes("//property");
        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("driverClass"));
        comboPooledDataSource.setJdbcUrl(properties.getProperty("jdbcUrl"));
        comboPooledDataSource.setUser(properties.getProperty("username"));
        comboPooledDataSource.setPassword(properties.getProperty("password"));

        configuration.setDataSource(comboPooledDataSource);

        //mapper.xml解析: 拿到路径--字节输入流---dom4j进行解析
        List mapperList = rootElement.selectNodes("//mapper");

        for (Element element : mapperList) {
            String mapperPath = element.attributeValue("resource");
            InputStream resourceAsSteam = Resources.getResourceAsSteam(mapperPath);
            XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(configuration);
            xmlMapperBuilder.parse(resourceAsSteam);

        }
        return configuration;
    }
}
 
 
 定义XMLMapperBuilder，将mapper.xml的流信息读取到MappedStatement，并设置到Configuration的map属性中
 
 
 
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.InputStream;
import java.util.List;

public class XMLMapperBuilder {

    private Configuration configuration;

    public XMLMapperBuilder(Configuration configuration) {
        this.configuration =configuration;
    }

    public void parse(InputStream inputStream) throws DocumentException {

        Document document = new SAXReader().read(inputStream);
        Element rootElement = document.getRootElement();

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

        List list = rootElement.selectNodes("//select");
        for (Element element : list) {
            String id = element.attributeValue("id");
            String resultType = element.attributeValue("resultType");
            String paramterType = element.attributeValue("paramterType");
            String sqlText = element.getTextTrim();
            MappedStatement mappedStatement = new MappedStatement();
            mappedStatement.setId(id);
            mappedStatement.setResultType(resultType);
            mappedStatement.setParamterType(paramterType);
            mappedStatement.setSql(sqlText);
            String key = namespace+"."+id;
            configuration.getMappedStatementMap().put(key,mappedStatement);
        }
    }
}
 
 
 上面的两个类，可以把xml中的配置读取到Configuration中，在哪里调用的呢？
 
首先创建一个SqlSessionFactoryBuilder，该类的作用是一个建造者，通过它调用读取配置，得到Configuration后，再创建出一个SqlSessionFactory工厂类，使用该工厂去创建SqlSession，在此过程中依次传递Configuration。
 
最终在SqlSession中，执行查询。
 
SqlSessionFactoryBuilder：
 
 
 
public class SqlSessionFactoryBuilder {
    public SqlSessionFactory build(InputStream in) throws DocumentException, PropertyVetoException {
        // 第一：使用dom4j解析配置文件，将解析出来的内容封装到Configuration中
        XMLConfigBuilder xmlConfigBuilder = new XMLConfigBuilder();
        Configuration configuration = xmlConfigBuilder.parseConfig(in);

        // 第二：创建sqlSessionFactory对象：工厂类：生产sqlSession:会话对象
        DefaultSqlSessionFactory defaultSqlSessionFactory = new DefaultSqlSessionFactory(configuration);

        return defaultSqlSessionFactory;
    }
}
 
 
SqlSessionFactory及实现类：
 
 
  
  
public interface SqlSessionFactory {
    public SqlSession openSession();
}
 
  
 
 
 
public class DefaultSqlSessionFactory implements SqlSessionFactory {
    private Configuration configuration;
    public DefaultSqlSessionFactory(Configuration configuration) {
        this.configuration = configuration;
    }

    @Override
    public SqlSession openSession() {
        return new DefaultSqlSession(configuration);
    }
}
 
 
 SqlSession及实现类：
 
 
 
public interface SqlSession {

    //查询所有
    public  List selectList(String statementid,Object... params) throws Exception;
    //根据条件查询单个
    public  T selectOne(String statementid,Object... params) throws Exception;
}
 
 
 
 
import java.lang.reflect.*;
import java.util.List;

public class DefaultSqlSession implements SqlSession {

    private Configuration configuration;

    public DefaultSqlSession(Configuration configuration) {
        this.configuration = configuration;
    }

    @Override
    public  List selectList(String statementid, Object... params) throws Exception {

        //将要去完成对simpleExecutor里的query方法的调用
        SimpleExecutor simpleExecutor = new SimpleExecutor();
        MappedStatement mappedStatement = configuration.getMappedStatementMap().get(statementid);
        List