mybatis的简单模拟

拼搏现实的明天。 2022-05-13 01:22 210阅读 0赞

我们首先来观察 mybatis-config.xml，里面需要配置一个数据源，那么我们准备一个数据源的实体类。

mybatis-config.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>
      <environments default="development">
        <environment id="development">
          <transactionManager type="JDBC"/>
          
          <dataSource type="POOLED">
            <property name="driver" value="oracle.jdbc.driver.OracleDriver"/>
            <property name="url" value="jdbc:oracle:thin:@127.0.0.1:1521:orcl"/>
            <property name="username" value="scott"/>
            <property name="password" value="123456"/>
          </dataSource>
        </environment>
      </environments>
      <mappers>
        <mapper resource="com/me/mybatis/DeptMapper.xml"/>
      </mappers>
    </configuration>

数据源的实体类：

![70][]

对于mapper的映射文件，我们也可以提取成一个实体类，我们观察mapper.xml发现，我们可以从中把 sql语句、参数类型、返回值类型、是否为更新的sql语句  组成一个实体类。

DeptMapper.xml:

<?xml version="1.0" encoding="UTF-8" ?>
    
    <mapper namespace="com.me.bean.DeptMapper">
     <insert id="addDept" parameterType="com.me.bean.DeptBean">
       insert into dept values(#{deptno},#{dname},#{loc}) 
     </insert>
     
      <insert id="addDept1" parameterType="map">
       insert into dept values(#{deptno},#{dname},#{loc}) 
     </insert>
     
      <select id="findAll" resultType="com.me.bean.DeptBean">
        select deptno,dname,loc from dept 
      </select>
    </mapper>

mapper实体类：

![70 1][]

我们查询oracle中的dept表作为测试，创建一个dept的实体类

![70 2][]

接下来具体实现。

先看看解析mybatis-config.xml的MyBatisConfig.java。使用dom4j解析xml。这个类主要解析了 数据源信息、mapper映射路径信息。

public class MyBatisConfig {
    	private DataSource dataSource;  //数据源实体
    	private List<String> mappers=new ArrayList<String>(); //保存mapper映射文件
    	public MyBatisConfig(String config) {
    		try {
    			readXml(config);
    		} catch (DocumentException e) {
    			e.printStackTrace();
    		}
    	}
    	/**
    	 * 解析mybatis-config.xml
    	 * @param config //文件路径
    	 * @throws DocumentException
    	 */
    	private void readXml(String config) throws DocumentException {
    		SAXReader reader = new SAXReader();
    		Document doc = reader.read(this.getClass().getClassLoader().getResourceAsStream(config));
    		
    		XPath xPath = doc.createXPath("//dataSource/property"); //解析mybatis-config.xml下的property所有节点
    		List<Element> properties = xPath.selectNodes(doc);
    		
    		dataSource=new DataSource();//创建一个数据源实体
    		String pname=null;
    		for (Element e1:properties) { //获取所有的property节点信息，保存到数据源实体类中
    			pname=e1.attributeValue("name");
    			switch (pname) {
    			case "driver":
    				dataSource.setDriver(e1.attributeValue("value"));
    				break;
    			case "url":
    				dataSource.setUrl(e1.attributeValue("value"));
    				break;
    			case "username":
    				dataSource.setUsername(e1.attributeValue("value"));
    				break;
    			case "password":
    				dataSource.setPassword(e1.attributeValue("value"));
    				break;
    			
    			default:
    				break;
    			}
    		}
    		
    		//System.out.println(dataSource);
    		//开始获取mybatis-config.xml中的<mappers>节点，即映射文件
    		xPath = doc.createXPath("//mappers/mapper");
    		List<Element> list = xPath.selectNodes(doc);
    		for (Element el:list) {
    			mappers.add(el.attributeValue("resource")); //保存到一个集合中
    		}
    		//到这里我们已经解析完了mybatis-config.xml
    		//System.out.println(mappers); 
    	}
    	
    	public DataSource getDataSource() {
    		return dataSource;
    	}
    	
    	public List<String> getMappers() {
    		return mappers;
    	}
    	
    	public static void main(String[] args) {
    		MyBatisConfig myBatisConfig = new MyBatisConfig("mybatis-config.xml");
    	}
    }

模拟SqlSessionFactory的SqlSessionFactory.java。这个类解析了mapper映射文件，并将解析出来的信息保存到实体类MapperInfo中。

public class SqlSessionFactory {
    
    	private MyBatisConfig config;  //mybatis-config.xml的解析结果
    	private Map<String, MapperInfo> mapperInfos =new HashMap<String, MapperInfo>();//mapper映射文件的解析结果
    
    	public  SqlSessionFactory(String configXml) {
    		config=new MyBatisConfig(configXml);  //解析mybatis-config.xml
    		try {
    			parseXml(); //解析mapper映射文件
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    
    	/**
    	 * 解析mapper映射文件
    	 * @throws DocumentException
    	 */
    	private void parseXml() throws DocumentException {
    		List<String> mappers = config.getMappers(); //获取映射文件路径
    		if (mappers!=null && !mappers.isEmpty()) {
    			SAXReader reader = new SAXReader();
    			Document doc= null;
    			XPath xPath = null;
    			List<Element> ops=null;
    
    			String opname=null;
    			MapperInfo mapperInfo=null;
    
    			//循环解析所有映射文件
    			for (String mapper:mappers) {
    				doc = reader.read(this.getClass().getClassLoader().getResourceAsStream(mapper));
    				xPath=doc.createXPath("//mapper/*"); //获取DeptMapper.xml下mapper下的所有节点
    				ops=xPath.selectNodes(doc);
    
    				for (Element el:ops) {
    					mapperInfo=new MapperInfo(); //创建一个mapper实体类
    					opname=el.getName();
    					//如果是select节点，说明不是更新语句
    					if (opname.equals("select")) { 
    						mapperInfo.setUpdate(false);
    					}
    					//将各项信息填入新创建的mapper实体类
    					mapperInfo.setParameterType(el.attributeValue("parameterType"));
    					mapperInfo.setResultType(el.attributeValue("resultType"));
    					mapperInfo.setSql(el.getTextTrim());
    
    					//保存结果到一个集合中
    					mapperInfos.put(el.attributeValue("id"), mapperInfo);
    				}
    			}
    		}
    	}
    
    	public MyBatisConfig getConfig() {
    		return config;
    	}
    
    	public Map<String, MapperInfo> getMapperInfos() {
    		return mapperInfos;
    	}
    }

最后就是比较难实现的SqlSession。这个类反射机制用的比较多，代码有详细注释。

public class SqlSession {
    
    	private SqlSessionFactory factory; //SqlSessionFactory
    	private DBHelper db;
    
    	public SqlSession(SqlSessionFactory factory){
    		this.factory=factory;
    		db=new DBHelper(factory.getConfig().getDataSource()); //用已经解析好的数据源实体类去初始化DBhelper
    	}
    
    	/**
    	 * 查询
    	 * @param sqlId mapper映射文件下的节点id
    	 * @param params 参数
    	 * @return
    	 */
    	public <T> List<T> selectList(String sqlId,Object ... params) {
    		String sql;//要执行的sql语句
    		Class C;  //反射的对象
    		try {
    			MapperInfo mapperInfo=factory.getMapperInfos().get(sqlId);//获取该sqlId节点下的所有信息
    			if (mapperInfo==null) {
    				return null;
    			}
    
    			sql=mapperInfo.getSql(); //获取sql语句
    			if (mapperInfo.isUpdate()) {
    				return null;
    			}
    
    			String className = mapperInfo.getResultType();//获取返回值类型
    			C=Class.forName(className); //反射得到该返回值类型的class
    			return db.findObject(sql, C,params); //调用dbhelper按对象查询
    
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return null;
    	}
    	/**
    	 * 更新情况（update，insert,delete）
    	 * @param sqlId
    	 * @param obj
    	 * @return
    	 */
    	public int update(String sqlId,Object obj) {
    		int result=0; //执行结果
    
    		MapperInfo mapperInfo = factory.getMapperInfos().get(sqlId);
    		if (mapperInfo==null) {
    			return 0;
    		}
    
    		String sql=mapperInfo.getSql();
    		String className = mapperInfo.getParameterType();
    
    		Pattern pattern = Pattern.compile("[#][{]\\w+}"); //正则表达式 。将#{xxxx}变成#{?}
    		Matcher matcher = pattern.matcher(sql);
    
    		ArrayList<String> colNames = new ArrayList<String>();
    		while (matcher.find()) {
    			colNames.add(matcher.group().replaceAll("[#{}]*", ""));
    		}
    		sql=matcher.replaceAll("?");
    		//如果参数类型为map
    		if ("map".equals(className)) {
    			Map<String, Object> map = (Map<String, Object>) obj;
    			List<Object> params=new ArrayList<Object>(); //参数集合
    			for (String colName:colNames) {
    				params.add(map.get(colName));
    			}
    			return db.update(sql, params);//使用DBhelper查询
    		}
    		if ("String".equals(className)) {
    			return -1;
    		}
    
    		//参数类型为对象时
    		try {
    			Class c =Class.forName(className); //反射得到class
    			Method[] methods=c.getDeclaredMethods();  //获取该类中的声明方法
    			List<Method> getMethods = new ArrayList<Method>();  //保存该对象的get方法
    			for (Method md:methods) {
    				if (md.getName().startsWith("get")) { 
    					getMethods.add(md); //如果方法为get方法，保存
    				}
    			}
    			List<Object> params=new ArrayList<Object>();//参数集合
    			String mname;
    			for (String colName:colNames) { 
    				for(Method md:getMethods){
    					mname="get"+colName.substring(0,1).toUpperCase()+colName.substring(1);//转换为getXxx的形式,例如getdeptno转换为getDeptno
    					if (mname.equals(md.getName())) { //用get方法或的参数
    						params.add(md.invoke(obj));  //反向执行
    					}
    				}
    			}
    			return db.update(sql, params); //返回执行结果
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return result;
    	}
    }

测试类：

public class _Main {
    
    	@Test
    	public void test() {
    		SqlSessionFactory sqFactory = new SqlSessionFactory("mybatis-config.xml");
    		//System.out.println(sqFactory.getMapperInfos());
    		SqlSession session = new SqlSession(sqFactory);
    		List<Object> dept = session.selectList("findAll");
    		System.out.println(dept);
    	}
    	@Test
    	public void test2() {
    		SqlSessionFactory sqFactory = new SqlSessionFactory("mybatis-config.xml");
    		SqlSession session = new SqlSession(sqFactory);
    		int result=session.update("addDept", new DeptBean(88,"hah","666"));
    		System.out.println(result);
    		
    	}
    	
    	@Test
    	public void test3() {
    		SqlSessionFactory sqFactory = new SqlSessionFactory("mybatis-config.xml");
    		SqlSession session = new SqlSession(sqFactory);
    		Map<String, Object> map = new HashMap<String, Object>();
    		map.put("deptno", 99);
    		map.put("dname", "呵呵");
    		map.put("loc", "888");
    		int result=session.update("addDept1", map);
    		System.out.println(result);
    	}
    }

DBHelper部分代码;

public class DBHelper {
    	private DataSource dataSource;
    	public  DBHelper(DataSource dataSource) {
    		this.dataSource=dataSource;
    		try {
    			Class.forName(dataSource.getDriver());
    		} catch (ClassNotFoundException e) {
    			e.printStackTrace();
    		}
    	}
    	
    	/**
    	 * 获取连接
    	 * @return
    	 */
    	public Connection getConnection() {
    		Connection con = null;
    		try {
    			con = DriverManager.getConnection(dataSource.getUrl(),dataSource.getUsername(),dataSource.getPassword());
    		    //Context context = new InitialContext();
    		    //DataSource ds = (DataSource) context.lookup("java:comp/env/mysql");
    		  //  con = ds.getConnection();
    		} catch (SQLException e) {
    			e.printStackTrace();
    		}
    		return con;
    	}
    }

![70 3][]

[70]: /images/20220513/c09f1725e38540b59525db48fac132e8.png
[70 1]: /images/20220513/6a4779eb0d7b454aa63b864daaf98161.png
[70 2]: /images/20220513/adf5f39a33f344ad852119e9ce664bca.png
[70 3]: /images/20220513/5ed639eaa5d144bc833592f58df343f9.png