Mybatis手写Mybatis框架实现Mybatis封装的JDBC功能-----Mybatis框架

红太狼 2024-03-24 22:18 155阅读 0赞 
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>org.god.ibatis</groupId>
  8.     <artifactId>godbatis</artifactId>
  9.     <version>1.0</version>
  10.     <packaging>jar</packaging>
  11.     <dependencies>
  12.         <dependency>
  13.             <groupId>org.dom4j</groupId>
  14.             <artifactId>dom4j</artifactId>
  15.             <version>2.1.3</version>
  16.         </dependency>
  17.         <dependency>
  18.             <groupId>jaxen</groupId>
  19.             <artifactId>jaxen</artifactId>
  20.             <version>1.2.0</version>
  21.         </dependency>
  22.         <dependency>
  23.             <groupId>junit</groupId>
  24.             <artifactId>junit</artifactId>
  25.             <version>4.13.2</version>
  26.             <scope>test</scope>
  27.         </dependency>
  28.         <dependency>
  29.             <groupId>mysql</groupId>
  30.             <artifactId>mysql-connector-java</artifactId>
  31.             <version>8.0.30</version>
  32.         </dependency>
  33.     </dependencies>
  34.     <properties>
  35.         <maven.compiler.source>17</maven.compiler.source>
  36.         <maven.compiler.target>17</maven.compiler.target>
  37.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  38.     </properties>
  40. </project>
  42. <?xml version="1.0" encoding="UTF-8"?>
  43. <project xmlns="http://maven.apache.org/POM/4.0.0"
  44.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  45.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  46.     <modelVersion>4.0.0</modelVersion>
  48.     <groupId>org.god.ibatis</groupId>
  49.     <artifactId>godbatis</artifactId>
  50.     <version>1.0</version>
  51.     <packaging>jar</packaging>
  52.     <dependencies>
  53.         <dependency>
  54.             <groupId>org.dom4j</groupId>
  55.             <artifactId>dom4j</artifactId>
  56.             <version>2.1.3</version>
  57.         </dependency>
  58.         <dependency>
  59.             <groupId>jaxen</groupId>
  60.             <artifactId>jaxen</artifactId>
  61.             <version>1.2.0</version>
  62.         </dependency>
  63.         <dependency>
  64.             <groupId>junit</groupId>
  65.             <artifactId>junit</artifactId>
  66.             <version>4.13.2</version>
  67.             <scope>test</scope>
  68.         </dependency>
  69.         <dependency>
  70.             <groupId>mysql</groupId>
  71.             <artifactId>mysql-connector-java</artifactId>
  72.             <version>8.0.30</version>
  73.         </dependency>
  74.     </dependencies>
  75.     <properties>
  76.         <maven.compiler.source>17</maven.compiler.source>
  77.         <maven.compiler.target>17</maven.compiler.target>
  78.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  79.     </properties>
  81. </project>
  83. package org.god.ibatis.core;
  85. public class Const
  86. {
  87.     private Const(){}
  88.     //整个框架的常量类
  89.     public static final String UN_POOLED_DATASOURCE = "UNPOOLED";
  90.     public static final String POOLED_DATASOURCE = "POOLED";
  91.     public static final String JNDI_DATASOURCE = "JNDI";
  92.     public static final String JDBC_TRANSACTION = "JDBC";
  93.     public static final String MANAGED_TRANSACTION = "MANAGED";
  94. }
  96. package org.god.ibatis.core;
  98. public class Const
  99. {
  100.     private Const(){}
  101.     //整个框架的常量类
  102.     public static final String UN_POOLED_DATASOURCE = "UNPOOLED";
  103.     public static final String POOLED_DATASOURCE = "POOLED";
  104.     public static final String JNDI_DATASOURCE = "JNDI";
  105.     public static final String JDBC_TRANSACTION = "JDBC";
  106.     public static final String MANAGED_TRANSACTION = "MANAGED";
  107. }
  109. package org.god.ibatis.core;
  111. import javax.sql.DataSource;
  112. import java.sql.Connection;
  113. import java.sql.SQLException;
  115. public class JdbcTransaction implements Transaction
  116. {
  117.     //Jdbc事务管理器
  118.     //godBatis只实现这个
  119.     //我们控制事务需要调用connection的方法实现
  120.     //需要调用连接对象的方法
  121.     //我们的连接对象是从数据源来的
  122.     //数据源属性必须要有,不然无法做事务的操作
  123.     private DataSource dataSource = null;
  124.     //数据源属性,是获取Connection对象的,所以这个数据源要实现DataSource
  125.     //我们只需要三个实现即可,POOLED,UNPOOLED,JNDI
  126.     public JdbcTransaction(DataSource dataSource, boolean autoCommit) {
  127.         //创建事务管理器对象
  128.         this.dataSource = dataSource;
  129.         this.autoCommit = autoCommit;
  130.     }
  131.     //将connection对外暴露,可以执行SQL语句,必须在同一个事务管理器下,是同一个连接
  132.     @Override
  133.     public Connection getConnection()
  134.     {
  135.         return connection;
  136.     }
  138.     //因为openConnection已经创建对象了,就不会再生成新的连接,就能保证是同一个连接对象了
  139.     private Connection connection;
  140.     @Override
  141.     public void openConnection()
  142.     {
  143.         try
  144.         {
  145.             connection = dataSource.getConnection();
  146.             connection.setAutoCommit(autoCommit);
  147.         }
  148.         catch (SQLException e)
  149.         {
  150.             throw new RuntimeException(e);
  151.         }
  152.     }
  153.     private boolean autoCommit;
  154.     //自动提交的标记,
  155.     @Override
  156.     public void commit()
  157.     {
  158.         try
  159.         {
  160.             connection.commit();
  161.         }
  162.         catch (SQLException e)
  163.         {
  164.             e.printStackTrace();
  165.         }
  166.     }
  168.     @Override
  169.     public void rollback()
  170.     {
  171.         try {
  172.             connection.rollback();
  173.         } catch (SQLException e) {
  174.             e.printStackTrace();
  175.         }
  176.     }
  178.     @Override
  179.     public void close()
  180.     {
  181.         try {
  182.             connection.close();
  183.         } catch (SQLException e) {
  184.             e.printStackTrace();
  185.         }
  186.     }
  187. }
  189. package org.god.ibatis.core;
  191. import javax.sql.DataSource;
  192. import java.sql.Connection;
  193. import java.sql.SQLException;
  195. public class JdbcTransaction implements Transaction
  196. {
  197.     //Jdbc事务管理器
  198.     //godBatis只实现这个
  199.     //我们控制事务需要调用connection的方法实现
  200.     //需要调用连接对象的方法
  201.     //我们的连接对象是从数据源来的
  202.     //数据源属性必须要有,不然无法做事务的操作
  203.     private DataSource dataSource = null;
  204.     //数据源属性,是获取Connection对象的,所以这个数据源要实现DataSource
  205.     //我们只需要三个实现即可,POOLED,UNPOOLED,JNDI
  206.     public JdbcTransaction(DataSource dataSource, boolean autoCommit) {
  207.         //创建事务管理器对象
  208.         this.dataSource = dataSource;
  209.         this.autoCommit = autoCommit;
  210.     }
  211.     //将connection对外暴露,可以执行SQL语句,必须在同一个事务管理器下,是同一个连接
  212.     @Override
  213.     public Connection getConnection()
  214.     {
  215.         return connection;
  216.     }
  218.     //因为openConnection已经创建对象了,就不会再生成新的连接,就能保证是同一个连接对象了
  219.     private Connection connection;
  220.     @Override
  221.     public void openConnection()
  222.     {
  223.         try
  224.         {
  225.             connection = dataSource.getConnection();
  226.             connection.setAutoCommit(autoCommit);
  227.         }
  228.         catch (SQLException e)
  229.         {
  230.             throw new RuntimeException(e);
  231.         }
  232.     }
  233.     private boolean autoCommit;
  234.     //自动提交的标记,
  235.     @Override
  236.     public void commit()
  237.     {
  238.         try
  239.         {
  240.             connection.commit();
  241.         }
  242.         catch (SQLException e)
  243.         {
  244.             e.printStackTrace();
  245.         }
  246.     }
  248.     @Override
  249.     public void rollback()
  250.     {
  251.         try {
  252.             connection.rollback();
  253.         } catch (SQLException e) {
  254.             e.printStackTrace();
  255.         }
  256.     }
  258.     @Override
  259.     public void close()
  260.     {
  261.         try {
  262.             connection.close();
  263.         } catch (SQLException e) {
  264.             e.printStackTrace();
  265.         }
  266.     }
  267. }
  269. package org.god.ibatis.core;
  271. import javax.sql.DataSource;
  272. import java.io.PrintWriter;
  273. import java.sql.Connection;
  274. import java.sql.SQLException;
  275. import java.sql.SQLFeatureNotSupportedException;
  276. import java.util.logging.Logger;
  278. //数据源的实现类JNDI
  279. //使用第三方的数据库连接池获取Connection对象
  280. public class JndiDataSource implements DataSource
  281. {
  282.     @Override
  283.     public Connection getConnection() throws SQLException {
  284.         return null;
  285.     }
  287.     @Override
  288.     public Connection getConnection(String username, String password) throws SQLException {
  289.         return null;
  290.     }
  292.     @Override
  293.     public PrintWriter getLogWriter() throws SQLException {
  294.         return null;
  295.     }
  297.     @Override
  298.     public void setLogWriter(PrintWriter out) throws SQLException {
  300.     }
  302.     @Override
  303.     public void setLoginTimeout(int seconds) throws SQLException {
  305.     }
  307.     @Override
  308.     public int getLoginTimeout() throws SQLException {
  309.         return 0;
  310.     }
  312.     @Override
  313.     public Logger getParentLogger() throws SQLFeatureNotSupportedException {
  314.         return null;
  315.     }
  317.     @Override
  318.     public <T> T unwrap(Class<T> iface) throws SQLException {
  319.         return null;
  320.     }
  322.     @Override
  323.     public boolean isWrapperFor(Class<?> iface) throws SQLException {
  324.         return false;
  325.     }
  326. }
  328. package org.god.ibatis.core;
  330. import javax.sql.DataSource;
  331. import java.io.PrintWriter;
  332. import java.sql.Connection;
  333. import java.sql.SQLException;
  334. import java.sql.SQLFeatureNotSupportedException;
  335. import java.util.logging.Logger;
  337. //数据源的实现类JNDI
  338. //使用第三方的数据库连接池获取Connection对象
  339. public class JndiDataSource implements DataSource
  340. {
  341.     @Override
  342.     public Connection getConnection() throws SQLException {
  343.         return null;
  344.     }
  346.     @Override
  347.     public Connection getConnection(String username, String password) throws SQLException {
  348.         return null;
  349.     }
  351.     @Override
  352.     public PrintWriter getLogWriter() throws SQLException {
  353.         return null;
  354.     }
  356.     @Override
  357.     public void setLogWriter(PrintWriter out) throws SQLException {
  359.     }
  361.     @Override
  362.     public void setLoginTimeout(int seconds) throws SQLException {
  364.     }
  366.     @Override
  367.     public int getLoginTimeout() throws SQLException {
  368.         return 0;
  369.     }
  371.     @Override
  372.     public Logger getParentLogger() throws SQLFeatureNotSupportedException {
  373.         return null;
  374.     }
  376.     @Override
  377.     public <T> T unwrap(Class<T> iface) throws SQLException {
  378.         return null;
  379.     }
  381.     @Override
  382.     public boolean isWrapperFor(Class<?> iface) throws SQLException {
  383.         return false;
  384.     }
  385. }
  387. package org.god.ibatis.core;
  389. import javax.sql.DataSource;
  390. import java.sql.Connection;
  392. public class ManagedTransaction implements Transaction
  393. {
  394.     //godBatis对这个类就不实现了
  395.     private DataSource dataSource;
  397.     @Override
  398.     public void openConnection() {
  400.     }
  402.     @Override
  403.     public void commit() {
  405.     }
  407.     @Override
  408.     public Connection getConnection() {
  409.         return null;
  410.     }
  412.     @Override
  413.     public void rollback() {
  415.     }
  417.     @Override
  418.     public void close() {
  420.     }
  421. }
  423. package org.god.ibatis.core;
  425. import javax.sql.DataSource;
  426. import java.sql.Connection;
  428. public class ManagedTransaction implements Transaction
  429. {
  430.     //godBatis对这个类就不实现了
  431.     private DataSource dataSource;
  433.     @Override
  434.     public void openConnection() {
  436.     }
  438.     @Override
  439.     public void commit() {
  441.     }
  443.     @Override
  444.     public Connection getConnection() {
  445.         return null;
  446.     }
  448.     @Override
  449.     public void rollback() {
  451.     }
  453.     @Override
  454.     public void close() {
  456.     }
  457. }
  459. package org.god.ibatis.core;
  461. public class MappedStatement
  462. {
  463.     //这是一个普通的java类,封装了一个SQL标签
  464.     //一个MappedStatement对象对应一个SQL标签
  465.     //一个sql标签中所有的信息封装到该对象中
  466.     //体现了面向对象编程实现
  467.     //要封装的结果集类型
  468.     //当select语句的时候,会对应一个resultType的值
  469.     public MappedStatement(){}
  470.     private String sql;
  471.     private String resultType;
  473.     @Override
  474.     public String toString() {
  475.         return "MappedStatement{" +
  476.                 "sql='" + sql + '\'' +
  477.                 ", resultType='" + resultType + '\'' +
  478.                 '}';
  479.     }
  481.     public String getSql() {
  482.         return sql;
  483.     }
  485.     public void setSql(String sql) {
  486.         this.sql = sql;
  487.     }
  489.     public String getResultType()
  490.     {
  491.         return resultType;
  492.     }
  494.     public void setResultType(String resultType)
  495.     {
  496.         this.resultType = resultType;
  497.     }
  499.     public MappedStatement(String sql, String resultType)
  500.     {
  501.         this.sql = sql;
  502.         this.resultType = resultType;
  503.     }
  504. }
  506. package org.god.ibatis.core;
  508. public class MappedStatement
  509. {
  510.     //这是一个普通的java类,封装了一个SQL标签
  511.     //一个MappedStatement对象对应一个SQL标签
  512.     //一个sql标签中所有的信息封装到该对象中
  513.     //体现了面向对象编程实现
  514.     //要封装的结果集类型
  515.     //当select语句的时候,会对应一个resultType的值
  516.     public MappedStatement(){}
  517.     private String sql;
  518.     private String resultType;
  520.     @Override
  521.     public String toString() {
  522.         return "MappedStatement{" +
  523.                 "sql='" + sql + '\'' +
  524.                 ", resultType='" + resultType + '\'' +
  525.                 '}';
  526.     }
  528.     public String getSql() {
  529.         return sql;
  530.     }
  532.     public void setSql(String sql) {
  533.         this.sql = sql;
  534.     }
  536.     public String getResultType()
  537.     {
  538.         return resultType;
  539.     }
  541.     public void setResultType(String resultType)
  542.     {
  543.         this.resultType = resultType;
  544.     }
  546.     public MappedStatement(String sql, String resultType)
  547.     {
  548.         this.sql = sql;
  549.         this.resultType = resultType;
  550.     }
  551. }
  553. package org.god.ibatis.core;
  555. import javax.sql.DataSource;
  556. import java.io.PrintWriter;
  557. import java.sql.Connection;
  558. import java.sql.SQLException;
  559. import java.sql.SQLFeatureNotSupportedException;
  560. import java.util.logging.Logger;
  562. //数据源的实现类POOLED
  563. //使用GodBatis内置的数据库连接池获取对象
  564. public class PooledDataSource implements DataSource {
  565.     @Override
  566.     public Connection getConnection() throws SQLException {
  567.         //从数据库连接池中获取connection对象
  568.         //需要自己写一个连接池(自己封装)
  569.         return null;
  570.     }
  572.     @Override
  573.     public Connection getConnection(String username, String password) throws SQLException {
  574.         return null;
  575.     }
  577.     @Override
  578.     public PrintWriter getLogWriter() throws SQLException {
  579.         return null;
  580.     }
  582.     @Override
  583.     public void setLogWriter(PrintWriter out) throws SQLException {
  585.     }
  587.     @Override
  588.     public void setLoginTimeout(int seconds) throws SQLException {
  590.     }
  592.     @Override
  593.     public int getLoginTimeout() throws SQLException {
  594.         return 0;
  595.     }
  597.     @Override
  598.     public Logger getParentLogger() throws SQLFeatureNotSupportedException {
  599.         return null;
  600.     }
  602.     @Override
  603.     public <T> T unwrap(Class<T> iface) throws SQLException {
  604.         return null;
  605.     }
  607.     @Override
  608.     public boolean isWrapperFor(Class<?> iface) throws SQLException {
  609.         return false;
  610.     }
  611. }
  613. package org.god.ibatis.core;
  615. import javax.sql.DataSource;
  616. import java.io.PrintWriter;
  617. import java.sql.Connection;
  618. import java.sql.SQLException;
  619. import java.sql.SQLFeatureNotSupportedException;
  620. import java.util.logging.Logger;
  622. //数据源的实现类POOLED
  623. //使用GodBatis内置的数据库连接池获取对象
  624. public class PooledDataSource implements DataSource {
  625.     @Override
  626.     public Connection getConnection() throws SQLException {
  627.         //从数据库连接池中获取connection对象
  628.         //需要自己写一个连接池(自己封装)
  629.         return null;
  630.     }
  632.     @Override
  633.     public Connection getConnection(String username, String password) throws SQLException {
  634.         return null;
  635.     }
  637.     @Override
  638.     public PrintWriter getLogWriter() throws SQLException {
  639.         return null;
  640.     }
  642.     @Override
  643.     public void setLogWriter(PrintWriter out) throws SQLException {
  645.     }
  647.     @Override
  648.     public void setLoginTimeout(int seconds) throws SQLException {
  650.     }
  652.     @Override
  653.     public int getLoginTimeout() throws SQLException {
  654.         return 0;
  655.     }
  657.     @Override
  658.     public Logger getParentLogger() throws SQLFeatureNotSupportedException {
  659.         return null;
  660.     }
  662.     @Override
  663.     public <T> T unwrap(Class<T> iface) throws SQLException {
  664.         return null;
  665.     }
  667.     @Override
  668.     public boolean isWrapperFor(Class<?> iface) throws SQLException {
  669.         return false;
  670.     }
  671. }
  673. package org.god.ibatis.core;
  675. import java.lang.reflect.Constructor;
  676. import java.lang.reflect.Field;
  677. import java.lang.reflect.Method;
  678. import java.sql.*;
  679. import java.util.HashMap;
  680. import java.util.Iterator;
  681. import java.util.Map;
  683. public class SqlSession
  684. {
  685.     protected SqlSession(SqlSessionFactory sqlSessionFactory)
  686.     {
  687.         this.sqlSessionFactory = sqlSessionFactory;
  688.     }
  689.     private SqlSessionFactory sqlSessionFactory;
  690.     //insert
  691.     public int insert(String sqlId,Object obj)
  692.     {
  693.         PreparedStatement statement = null;
  694.         Connection connection = sqlSessionFactory.getTransaction().getConnection();
  695.         int count = 0;
  696.         try
  697.         {
  698.             //JDBC代码,执行insert语句,完成插入操作
  699.             String oldSql = sqlSessionFactory.getMappedStatements().get(sqlId).getSql();
  700.             String newSql = oldSql.replaceAll("#\\{[a-zA-Z0-9_$]*}","?");
  701.             statement = connection.prepareStatement(newSql);
  702.             //给?传值
  703.             Map transfer = Transfer(oldSql);
  704.             Iterator iterator = transfer.entrySet().iterator();
  705.             while(iterator.hasNext())
  706.             {
  707.                 Map.Entry entry = (Map.Entry)iterator.next();
  708.                 Integer index = (Integer)entry.getKey();
  709.                 String value = (String)entry.getValue();
  710.                 String methodName = "get" + value.toUpperCase().charAt(0) + value.substring(1);
  711.                 Method declaredMethod = obj.getClass().getDeclaredMethod(methodName);
  712.                 Object invoke = declaredMethod.invoke(obj);
  713.                 statement.setString(index,invoke.toString());
  714.             }
  715.             //执行SQL
  716.             count = statement.executeUpdate();
  717.         }
  718.         catch (Exception e)
  719.         {
  720.             e.printStackTrace();
  721.         }
  722.         finally
  723.         {
  724.             if (statement != null)
  725.             {
  726.                 try
  727.                 {
  728.                     statement.close();
  729.                 }
  730.                 catch (SQLException e)
  731.                 {
  732.                     throw new RuntimeException(e);
  733.                 }
  734.             }
  735.         }
  736.         return count;
  737.     }
  738.     public Object SelectOne(String sqlId,Object obj)
  739.     {
  740.         Object o = null;
  741.         if(sqlSessionFactory.getMappedStatements().get(sqlId) != null)
  742.         {
  743.             Connection connection = null;
  744.             PreparedStatement statement = null;
  745.             ResultSet resultSet = null;
  746.             try
  747.             {
  748.                 connection = sqlSessionFactory.getTransaction().getConnection();
  749.                 MappedStatement mappedStatement = sqlSessionFactory.getMappedStatements().get(sqlId);
  750.                 String oldSql = mappedStatement.getSql();
  751.                 String newSql = oldSql.replaceAll("#\\{[a-zA-Z0-9_$]*}","?");
  752.                 statement = connection.prepareStatement(newSql);
  753.                 //给占位符传值
  754.                 Map map = Transfer(oldSql);
  755.                 Iterator iterator = map.entrySet().iterator();
  756.                 while(iterator.hasNext())
  757.                 {
  758.                     Map.Entry entry = (Map.Entry) iterator.next();
  759.                     Integer integer = (Integer)entry.getKey();
  760.                     statement.setString(integer,obj.toString());
  761.                 }
  762.                 //查询返回结果集
  763.                 resultSet = statement.executeQuery();
  764.                 if(resultSet.next())
  765.                 {
  766.                     String resultType = mappedStatement.getResultType();
  767.                     Class<?> aClass = Class.forName(resultType);
  768.                     Constructor<?> declaredConstructor = aClass.getDeclaredConstructor();
  769.                     o = declaredConstructor.newInstance();
  770.                     //赋值
  771.                     ResultSetMetaData metaData = resultSet.getMetaData();
  772.                     int columnCount = metaData.getColumnCount();
  773.                     for (int i = 1; i < columnCount + 1; i++)
  774.                     {
  775.                         String columnName = metaData.getColumnName(i);
  776.                         String value = resultSet.getString(columnName);
  777.                         //直接赋值法
  778. //                        Field declaredField = aClass.getDeclaredField(columnName);
  779. //                        declaredField.setAccessible(true);
  780. //                        declaredField.set(o,value);
  781.                         String MethodName = "set" + columnName.toUpperCase().charAt(0) + columnName.substring(1);
  782.                         Method declaredMethod = aClass.getDeclaredMethod(MethodName,String.class);
  783.                         declaredMethod.invoke(o,value);
  784.                     }
  785.                 }
  786.             }
  787.             catch (Exception e)
  788.             {
  789.                 throw new RuntimeException(e);
  790.             }
  791.             finally
  792.             {
  793.                 if (statement != null)
  794.                 {
  795.                     try
  796.                     {
  797.                         statement.close();
  798.                     }
  799.                     catch (SQLException e)
  800.                     {
  801.                         throw new RuntimeException(e);
  802.                     }
  803.                 }
  804.                 if (resultSet != null)
  805.                 {
  806.                     try
  807.                     {
  808.                         resultSet.close();
  809.                     }
  810.                     catch(SQLException e)
  811.                     {
  812.                         throw new RuntimeException(e);
  813.                     }
  814.                 }
  815.             }
  816.         }
  817.         return o;
  818.     }
  819.     public Map Transfer(String oldSql) throws Exception
  820.     {
  821.         Map<Integer,String> map = new HashMap<>();
  822.         int fromIndex = 0;
  823.         int index = 1;
  824.         while(true)
  825.         {
  826.             int starIndex = oldSql.indexOf("#",fromIndex);
  827.             if(starIndex < 0)
  828.             {
  829.                 break;
  830.             }
  831.             int endIndex = oldSql.indexOf("}",fromIndex);
  832.             String value = oldSql.substring(starIndex + 2,endIndex).trim();
  833.             map.put(index,value);
  834.             fromIndex = endIndex + 1;
  835.             index++;
  836.         }
  837.         return map;
  838.     }
  839.     public void commit()
  840.     {
  841.         sqlSessionFactory.getTransaction().commit();
  842.     }
  843.     public void rollback()
  844.     {
  845.         sqlSessionFactory.getTransaction().rollback();
  846.     }
  847.     public void close()
  848.     {
  849.         sqlSessionFactory.getTransaction().close();
  850.     }
  851. }
  853. package org.god.ibatis.core;
  855. import java.lang.reflect.Constructor;
  856. import java.lang.reflect.Field;
  857. import java.lang.reflect.Method;
  858. import java.sql.*;
  859. import java.util.HashMap;
  860. import java.util.Iterator;
  861. import java.util.Map;
  863. public class SqlSession
  864. {
  865.     protected SqlSession(SqlSessionFactory sqlSessionFactory)
  866.     {
  867.         this.sqlSessionFactory = sqlSessionFactory;
  868.     }
  869.     private SqlSessionFactory sqlSessionFactory;
  870.     //insert
  871.     public int insert(String sqlId,Object obj)
  872.     {
  873.         PreparedStatement statement = null;
  874.         Connection connection = sqlSessionFactory.getTransaction().getConnection();
  875.         int count = 0;
  876.         try
  877.         {
  878.             //JDBC代码,执行insert语句,完成插入操作
  879.             String oldSql = sqlSessionFactory.getMappedStatements().get(sqlId).getSql();
  880.             String newSql = oldSql.replaceAll("#\\{[a-zA-Z0-9_$]*}","?");
  881.             statement = connection.prepareStatement(newSql);
  882.             //给?传值
  883.             Map transfer = Transfer(oldSql);
  884.             Iterator iterator = transfer.entrySet().iterator();
  885.             while(iterator.hasNext())
  886.             {
  887.                 Map.Entry entry = (Map.Entry)iterator.next();
  888.                 Integer index = (Integer)entry.getKey();
  889.                 String value = (String)entry.getValue();
  890.                 String methodName = "get" + value.toUpperCase().charAt(0) + value.substring(1);
  891.                 Method declaredMethod = obj.getClass().getDeclaredMethod(methodName);
  892.                 Object invoke = declaredMethod.invoke(obj);
  893.                 statement.setString(index,invoke.toString());
  894.             }
  895.             //执行SQL
  896.             count = statement.executeUpdate();
  897.         }
  898.         catch (Exception e)
  899.         {
  900.             e.printStackTrace();
  901.         }
  902.         finally
  903.         {
  904.             if (statement != null)
  905.             {
  906.                 try
  907.                 {
  908.                     statement.close();
  909.                 }
  910.                 catch (SQLException e)
  911.                 {
  912.                     throw new RuntimeException(e);
  913.                 }
  914.             }
  915.         }
  916.         return count;
  917.     }
  918.     public Object SelectOne(String sqlId,Object obj)
  919.     {
  920.         Object o = null;
  921.         if(sqlSessionFactory.getMappedStatements().get(sqlId) != null)
  922.         {
  923.             Connection connection = null;
  924.             PreparedStatement statement = null;
  925.             ResultSet resultSet = null;
  926.             try
  927.             {
  928.                 connection = sqlSessionFactory.getTransaction().getConnection();
  929.                 MappedStatement mappedStatement = sqlSessionFactory.getMappedStatements().get(sqlId);
  930.                 String oldSql = mappedStatement.getSql();
  931.                 String newSql = oldSql.replaceAll("#\\{[a-zA-Z0-9_$]*}","?");
  932.                 statement = connection.prepareStatement(newSql);
  933.                 //给占位符传值
  934.                 Map map = Transfer(oldSql);
  935.                 Iterator iterator = map.entrySet().iterator();
  936.                 while(iterator.hasNext())
  937.                 {
  938.                     Map.Entry entry = (Map.Entry) iterator.next();
  939.                     Integer integer = (Integer)entry.getKey();
  940.                     statement.setString(integer,obj.toString());
  941.                 }
  942.                 //查询返回结果集
  943.                 resultSet = statement.executeQuery();
  944.                 if(resultSet.next())
  945.                 {
  946.                     String resultType = mappedStatement.getResultType();
  947.                     Class<?> aClass = Class.forName(resultType);
  948.                     Constructor<?> declaredConstructor = aClass.getDeclaredConstructor();
  949.                     o = declaredConstructor.newInstance();
  950.                     //赋值
  951.                     ResultSetMetaData metaData = resultSet.getMetaData();
  952.                     int columnCount = metaData.getColumnCount();
  953.                     for (int i = 1; i < columnCount + 1; i++)
  954.                     {
  955.                         String columnName = metaData.getColumnName(i);
  956.                         String value = resultSet.getString(columnName);
  957.                         //直接赋值法
  958. //                        Field declaredField = aClass.getDeclaredField(columnName);
  959. //                        declaredField.setAccessible(true);
  960. //                        declaredField.set(o,value);
  961.                         String MethodName = "set" + columnName.toUpperCase().charAt(0) + columnName.substring(1);
  962.                         Method declaredMethod = aClass.getDeclaredMethod(MethodName,String.class);
  963.                         declaredMethod.invoke(o,value);
  964.                     }
  965.                 }
  966.             }
  967.             catch (Exception e)
  968.             {
  969.                 throw new RuntimeException(e);
  970.             }
  971.             finally
  972.             {
  973.                 if (statement != null)
  974.                 {
  975.                     try
  976.                     {
  977.                         statement.close();
  978.                     }
  979.                     catch (SQLException e)
  980.                     {
  981.                         throw new RuntimeException(e);
  982.                     }
  983.                 }
  984.                 if (resultSet != null)
  985.                 {
  986.                     try
  987.                     {
  988.                         resultSet.close();
  989.                     }
  990.                     catch(SQLException e)
  991.                     {
  992.                         throw new RuntimeException(e);
  993.                     }
  994.                 }
  995.             }
  996.         }
  997.         return o;
  998.     }
  999.     public Map Transfer(String oldSql) throws Exception
  1000.     {
  1001.         Map<Integer,String> map = new HashMap<>();
  1002.         int fromIndex = 0;
  1003.         int index = 1;
  1004.         while(true)
  1005.         {
  1006.             int starIndex = oldSql.indexOf("#",fromIndex);
  1007.             if(starIndex < 0)
  1008.             {
  1009.                 break;
  1010.             }
  1011.             int endIndex = oldSql.indexOf("}",fromIndex);
  1012.             String value = oldSql.substring(starIndex + 2,endIndex).trim();
  1013.             map.put(index,value);
  1014.             fromIndex = endIndex + 1;
  1015.             index++;
  1016.         }
  1017.         return map;
  1018.     }
  1019.     public void commit()
  1020.     {
  1021.         sqlSessionFactory.getTransaction().commit();
  1022.     }
  1023.     public void rollback()
  1024.     {
  1025.         sqlSessionFactory.getTransaction().rollback();
  1026.     }
  1027.     public void close()
  1028.     {
  1029.         sqlSessionFactory.getTransaction().close();
  1030.     }
  1031. }
  1033. package org.god.ibatis.core;
  1035. import java.util.Map;
  1037. public class SqlSessionFactory
  1038. {
  1039.     //一个数据库对应一个SqlSessionFactory对象
  1040.     //通过这个对象可以开启会话,建立与数据库的连接
  1041.     //一个SqlSessionFactory对象可以开启多个SqlSession会话
  1042.     //所以这个事务管理器应该是一个接口,面向接口编程
  1043.     protected SqlSessionFactory(){}
  1044.     public SqlSession openSession()
  1045.     {
  1046.         //开启会话的前提就是开启连接
  1047.         transaction.openConnection();
  1048.         //创建SqlSession对象
  1049.         SqlSession sqlSession = new SqlSession(this);
  1050.         return sqlSession;
  1051.     }
  1053.     protected SqlSessionFactory(Transaction transaction, Map<String, MappedStatement> mappedStatements) {
  1054.         this.transaction = transaction;
  1055.         this.mappedStatements = mappedStatements;
  1056.     }
  1058.     public Transaction getTransaction() {
  1059.         return transaction;
  1060.     }
  1062.     public void setTransaction(Transaction transaction) {
  1063.         this.transaction = transaction;
  1064.     }
  1066.     public Map<String, MappedStatement> getMappedStatements() {
  1067.         return mappedStatements;
  1068.     }
  1070.     public void setMappedStatements(Map<String, MappedStatement> mappedStatements) {
  1071.         this.mappedStatements = mappedStatements;
  1072.     }
  1074.     //事务管理器属性
  1075.     private Transaction transaction;
  1076.     //存放sql对象的map集合,key是SqlId,Value是对应的SQL标签对象
  1077.     private Map<String,MappedStatement> mappedStatements;
  1078. }
  1080. package org.god.ibatis.core;
  1082. import java.util.Map;
  1084. public class SqlSessionFactory
  1085. {
  1086.     //一个数据库对应一个SqlSessionFactory对象
  1087.     //通过这个对象可以开启会话,建立与数据库的连接
  1088.     //一个SqlSessionFactory对象可以开启多个SqlSession会话
  1089.     //所以这个事务管理器应该是一个接口,面向接口编程
  1090.     protected SqlSessionFactory(){}
  1091.     public SqlSession openSession()
  1092.     {
  1093.         //开启会话的前提就是开启连接
  1094.         transaction.openConnection();
  1095.         //创建SqlSession对象
  1096.         SqlSession sqlSession = new SqlSession(this);
  1097.         return sqlSession;
  1098.     }
  1100.     protected SqlSessionFactory(Transaction transaction, Map<String, MappedStatement> mappedStatements) {
  1101.         this.transaction = transaction;
  1102.         this.mappedStatements = mappedStatements;
  1103.     }
  1105.     public Transaction getTransaction() {
  1106.         return transaction;
  1107.     }
  1109.     public void setTransaction(Transaction transaction) {
  1110.         this.transaction = transaction;
  1111.     }
  1113.     public Map<String, MappedStatement> getMappedStatements() {
  1114.         return mappedStatements;
  1115.     }
  1117.     public void setMappedStatements(Map<String, MappedStatement> mappedStatements) {
  1118.         this.mappedStatements = mappedStatements;
  1119.     }
  1121.     //事务管理器属性
  1122.     private Transaction transaction;
  1123.     //存放sql对象的map集合,key是SqlId,Value是对应的SQL标签对象
  1124.     private Map<String,MappedStatement> mappedStatements;
  1125. }
  1127. package org.god.ibatis.core;
  1129. import org.dom4j.Document;
  1130. import org.dom4j.DocumentException;
  1131. import org.dom4j.Element;
  1132. import org.dom4j.Node;
  1133. import org.dom4j.io.SAXReader;
  1134. import org.god.ibatis.utils.Resources;
  1136. import javax.sql.DataSource;
  1137. import java.io.InputStream;
  1138. import java.util.ArrayList;
  1139. import java.util.HashMap;
  1140. import java.util.List;
  1141. import java.util.Map;
  1143. public class SqlSessionFactoryBuilder
  1144. {
  1145.     //通过godBatis-config文件,创建SqlSessionFactory对象
  1146.     public SqlSessionFactoryBuilder(){}
  1147.     public SqlSessionFactory build(InputStream is)
  1148.     {
  1149.         //解析godBatis-config文件创建SqlSessionFactory对象
  1150.         //build操作的核心就是要解析XML文件
  1151.         //解析完成要构建SqlSessionFactory对象
  1152.         //解析GodBatis-config文件
  1153.         SAXReader reader = new SAXReader();
  1154.         Document document = null;
  1155.         SqlSessionFactory sqlSessionFactory = null;
  1156.         try
  1157.         {
  1158.             document = reader.read(is);
  1159.             Element rootElement = (Element)document.selectSingleNode("/configuration/environments");
  1160.             String defaultId = rootElement.attributeValue("default");
  1161.             Element environment = (Element) document.selectSingleNode("/configuration/environments/environment[@id='" + defaultId +"']");
  1162.             Element transactionManagerEle = environment.element("transactionManager");
  1163.             Element dataSourceEle = environment.element("dataSource");
  1164.             DataSource dataSource = getDataSource(dataSourceEle);
  1165.             //获取事务管理器
  1166.             Transaction transaction = getTransaction(transactionManagerEle,dataSource);
  1167.             //获取MappedStatements
  1168.             List<Node> mappers = document.selectNodes("//mapper");
  1169.             List<String> mapperList = new ArrayList<>();
  1170.             mappers.forEach(node ->
  1171.             {
  1172.                 Element mapper = (Element)node;
  1173.                 String resource = mapper.attributeValue("resource");
  1174.                 mapperList.add(resource);
  1175.             });
  1176.             //获取整个文件中所有的mapper标签
  1177.             Map<String,MappedStatement> mappedStatements = getMappedStatements(mapperList);
  1178.             sqlSessionFactory = new SqlSessionFactory(transaction,mappedStatements);
  1179.         }
  1180.         catch (Exception e)
  1181.         {
  1182.             e.printStackTrace();
  1183.         }
  1184.         return sqlSessionFactory;
  1185.     }
  1187.     private Map<String, MappedStatement> getMappedStatements(List<String> mapperList)
  1188.     {
  1189.         Map<String,MappedStatement> map = new HashMap<>();
  1190.         mapperList.forEach(resource ->
  1191.         {
  1192.             SAXReader reader = new SAXReader();
  1193.             InputStream ip = Resources.getResourceAsStream(resource);
  1194.             Document document = null;
  1195.             try
  1196.             {
  1197.                 document = reader.read(ip);
  1198.             }
  1199.             catch (DocumentException e)
  1200.             {
  1201.                 throw new RuntimeException(e);
  1202.             }
  1203.             Element mapper = document.getRootElement();
  1204.             String namespace = mapper.attributeValue("namespace");
  1205.             List<Element> elements = mapper.elements();
  1206.             elements.forEach(element ->
  1207.             {
  1208.                 MappedStatement mappedStatement = new MappedStatement();
  1209.                 String resultType = element.attributeValue("resultType");
  1210.                 String id = element.attributeValue("id");
  1211.                 if(resultType != null)
  1212.                 {
  1213.                     mappedStatement.setResultType(resultType);
  1214.                 }
  1215.                 else
  1216.                 {
  1217.                     mappedStatement.setResultType("null");
  1218.                 }
  1219.                 String sql = element.getTextTrim();
  1220.                 mappedStatement.setSql(sql);
  1221.                 String sqlId = namespace + "." + id;
  1222.                 map.put(sqlId,mappedStatement);
  1223.             });
  1224.         });
  1225.         return map;
  1226.     }
  1228.     private Transaction getTransaction(Element transactionManagerEle,DataSource dataSource)
  1229.     {
  1230.         //获取事务管理器对象
  1231.         String type = transactionManagerEle.attributeValue("type").trim().toUpperCase();
  1232.         Transaction transaction = null;
  1233.         if(Const.JDBC_TRANSACTION.equals(type))
  1234.         {
  1235.             //默认是开启事务的,将来需要手动提交的
  1236.             transaction = new JdbcTransaction(dataSource,false);
  1237.         }
  1238.         if(Const.MANAGED_TRANSACTION.equals(type))
  1239.         {
  1240.             transaction = new ManagedTransaction();
  1241.         }
  1242.         return transaction;
  1243.     }
  1245.     private DataSource getDataSource(Element dataSourceEle) 
  1246.     {
  1247.         //获取数据源对象
  1248.         String type = dataSourceEle.attributeValue("type").trim().toUpperCase();
  1249.         DataSource dataSource = null;
  1250.         List<Element> elements = dataSourceEle.elements();
  1251.         Map<String,String> map = new HashMap<>();
  1252.         elements.forEach(element -> 
  1253.         {
  1254.             String name = element.attributeValue("name");
  1255.             String value = element.attributeValue("value");
  1256.             map.put(name,value);
  1257.         });
  1258.         String driver = map.get("driver");
  1259.         String url = map.get("url");
  1260.         String username = map.get("username");
  1261.         String password = map.get("password");
  1262.         if(Const.UN_POOLED_DATASOURCE.equals(type))
  1263.         {
  1264.             dataSource = new UnPooledDataSource(driver,url,username,password);
  1265.         }
  1266.         else if(Const.POOLED_DATASOURCE.equals(type))
  1267.         {
  1268.             dataSource = new PooledDataSource();
  1269.         }
  1270.         else if(Const.JNDI_DATASOURCE.equals(type))
  1271.         {
  1272.             dataSource = new JndiDataSource();
  1273.         }
  1274.         return dataSource;
  1275.     }
  1276. }
  1278. package org.god.ibatis.core;
  1280. import org.dom4j.Document;
  1281. import org.dom4j.DocumentException;
  1282. import org.dom4j.Element;
  1283. import org.dom4j.Node;
  1284. import org.dom4j.io.SAXReader;
  1285. import org.god.ibatis.utils.Resources;
  1287. import javax.sql.DataSource;
  1288. import java.io.InputStream;
  1289. import java.util.ArrayList;
  1290. import java.util.HashMap;
  1291. import java.util.List;
  1292. import java.util.Map;
  1294. public class SqlSessionFactoryBuilder
  1295. {
  1296.     //通过godBatis-config文件,创建SqlSessionFactory对象
  1297.     public SqlSessionFactoryBuilder(){}
  1298.     public SqlSessionFactory build(InputStream is)
  1299.     {
  1300.         //解析godBatis-config文件创建SqlSessionFactory对象
  1301.         //build操作的核心就是要解析XML文件
  1302.         //解析完成要构建SqlSessionFactory对象
  1303.         //解析GodBatis-config文件
  1304.         SAXReader reader = new SAXReader();
  1305.         Document document = null;
  1306.         SqlSessionFactory sqlSessionFactory = null;
  1307.         try
  1308.         {
  1309.             document = reader.read(is);
  1310.             Element rootElement = (Element)document.selectSingleNode("/configuration/environments");
  1311.             String defaultId = rootElement.attributeValue("default");
  1312.             Element environment = (Element) document.selectSingleNode("/configuration/environments/environment[@id='" + defaultId +"']");
  1313.             Element transactionManagerEle = environment.element("transactionManager");
  1314.             Element dataSourceEle = environment.element("dataSource");
  1315.             DataSource dataSource = getDataSource(dataSourceEle);
  1316.             //获取事务管理器
  1317.             Transaction transaction = getTransaction(transactionManagerEle,dataSource);
  1318.             //获取MappedStatements
  1319.             List<Node> mappers = document.selectNodes("//mapper");
  1320.             List<String> mapperList = new ArrayList<>();
  1321.             mappers.forEach(node ->
  1322.             {
  1323.                 Element mapper = (Element)node;
  1324.                 String resource = mapper.attributeValue("resource");
  1325.                 mapperList.add(resource);
  1326.             });
  1327.             //获取整个文件中所有的mapper标签
  1328.             Map<String,MappedStatement> mappedStatements = getMappedStatements(mapperList);
  1329.             sqlSessionFactory = new SqlSessionFactory(transaction,mappedStatements);
  1330.         }
  1331.         catch (Exception e)
  1332.         {
  1333.             e.printStackTrace();
  1334.         }
  1335.         return sqlSessionFactory;
  1336.     }
  1338.     private Map<String, MappedStatement> getMappedStatements(List<String> mapperList)
  1339.     {
  1340.         Map<String,MappedStatement> map = new HashMap<>();
  1341.         mapperList.forEach(resource ->
  1342.         {
  1343.             SAXReader reader = new SAXReader();
  1344.             InputStream ip = Resources.getResourceAsStream(resource);
  1345.             Document document = null;
  1346.             try
  1347.             {
  1348.                 document = reader.read(ip);
  1349.             }
  1350.             catch (DocumentException e)
  1351.             {
  1352.                 throw new RuntimeException(e);
  1353.             }
  1354.             Element mapper = document.getRootElement();
  1355.             String namespace = mapper.attributeValue("namespace");
  1356.             List<Element> elements = mapper.elements();
  1357.             elements.forEach(element ->
  1358.             {
  1359.                 MappedStatement mappedStatement = new MappedStatement();
  1360.                 String resultType = element.attributeValue("resultType");
  1361.                 String id = element.attributeValue("id");
  1362.                 if(resultType != null)
  1363.                 {
  1364.                     mappedStatement.setResultType(resultType);
  1365.                 }
  1366.                 else
  1367.                 {
  1368.                     mappedStatement.setResultType("null");
  1369.                 }
  1370.                 String sql = element.getTextTrim();
  1371.                 mappedStatement.setSql(sql);
  1372.                 String sqlId = namespace + "." + id;
  1373.                 map.put(sqlId,mappedStatement);
  1374.             });
  1375.         });
  1376.         return map;
  1377.     }
  1379.     private Transaction getTransaction(Element transactionManagerEle,DataSource dataSource)
  1380.     {
  1381.         //获取事务管理器对象
  1382.         String type = transactionManagerEle.attributeValue("type").trim().toUpperCase();
  1383.         Transaction transaction = null;
  1384.         if(Const.JDBC_TRANSACTION.equals(type))
  1385.         {
  1386.             //默认是开启事务的,将来需要手动提交的
  1387.             transaction = new JdbcTransaction(dataSource,false);
  1388.         }
  1389.         if(Const.MANAGED_TRANSACTION.equals(type))
  1390.         {
  1391.             transaction = new ManagedTransaction();
  1392.         }
  1393.         return transaction;
  1394.     }
  1396.     private DataSource getDataSource(Element dataSourceEle) 
  1397.     {
  1398.         //获取数据源对象
  1399.         String type = dataSourceEle.attributeValue("type").trim().toUpperCase();
  1400.         DataSource dataSource = null;
  1401.         List<Element> elements = dataSourceEle.elements();
  1402.         Map<String,String> map = new HashMap<>();
  1403.         elements.forEach(element -> 
  1404.         {
  1405.             String name = element.attributeValue("name");
  1406.             String value = element.attributeValue("value");
  1407.             map.put(name,value);
  1408.         });
  1409.         String driver = map.get("driver");
  1410.         String url = map.get("url");
  1411.         String username = map.get("username");
  1412.         String password = map.get("password");
  1413.         if(Const.UN_POOLED_DATASOURCE.equals(type))
  1414.         {
  1415.             dataSource = new UnPooledDataSource(driver,url,username,password);
  1416.         }
  1417.         else if(Const.POOLED_DATASOURCE.equals(type))
  1418.         {
  1419.             dataSource = new PooledDataSource();
  1420.         }
  1421.         else if(Const.JNDI_DATASOURCE.equals(type))
  1422.         {
  1423.             dataSource = new JndiDataSource();
  1424.         }
  1425.         return dataSource;
  1426.     }
  1428. package org.god.ibatis.core;
  1430. import java.sql.Connection;
  1432. public interface Transaction
  1433. {
  1434.     //事务管理器接口
  1435.     //所有的事务管理都应该遵循此规范
  1436.     //JDBC和MANAGED事务管理器都应该实现这个接口
  1437.     //Transaction事务管理器通过事务方法
  1438.     //提交事务,回滚事务,关闭事务
  1439.     void openConnection();
  1440.     //真正的开启数据库连接
  1441.     void commit();
  1442.     //获取数据库连接对象的方法
  1443.     Connection getConnection();
  1444.     void rollback();
  1445.     void close();
  1446. }
  1448. package org.god.ibatis.core;
  1450. import java.sql.Connection;
  1452. public interface Transaction
  1453. {
  1454.     //事务管理器接口
  1455.     //所有的事务管理都应该遵循此规范
  1456.     //JDBC和MANAGED事务管理器都应该实现这个接口
  1457.     //Transaction事务管理器通过事务方法
  1458.     //提交事务,回滚事务,关闭事务
  1459.     void openConnection();
  1460.     //真正的开启数据库连接
  1461.     void commit();
  1462.     //获取数据库连接对象的方法
  1463.     Connection getConnection();
  1464.     void rollback();
  1465.     void close();
  1466. }
  1468. package org.god.ibatis.core;
  1470. import javax.sql.DataSource;
  1471. import java.io.PrintWriter;
  1472. import java.sql.Connection;
  1473. import java.sql.DriverManager;
  1474. import java.sql.SQLException;
  1475. import java.sql.SQLFeatureNotSupportedException;
  1476. import java.util.logging.Logger;
  1478. //数据源的实现类UNPOOLED
  1479. //不使用连接池,每一次都新建Connection对象
  1480. public class UnPooledDataSource implements DataSource {
  1481.     //数据库驱动,值从配置文件中来
  1482.     private String url;
  1483.     private String username;
  1484.     private String password;
  1485.     public UnPooledDataSource() {}
  1486.     public UnPooledDataSource(String driver, String url, String username, String password) {
  1487.         //直接注册驱动
  1488.         try
  1489.         {
  1490.             Class.forName(driver);
  1491.         }
  1492.         catch (ClassNotFoundException e)
  1493.         {
  1494.             throw new RuntimeException(e);
  1495.         }
  1496.         //创建一个数据源对象
  1497.         this.url = url;
  1498.         this.username = username;
  1499.         this.password = password;
  1500.     }
  1502.     @Override
  1503.     public Connection getConnection() throws SQLException
  1504.     {
  1505.         Connection connection = DriverManager.getConnection(url, username, password);
  1506.         return connection;
  1507.     }
  1509.     @Override
  1510.     public Connection getConnection(String username, String password) throws SQLException
  1511.     {
  1512.         Connection connection = DriverManager.getConnection(url, username, password);
  1513.         return null;
  1514.     }
  1516.     @Override
  1517.     public PrintWriter getLogWriter() throws SQLException {
  1518.         return null;
  1519.     }
  1521.     @Override
  1522.     public void setLogWriter(PrintWriter out) throws SQLException {
  1524.     }
  1526.     @Override
  1527.     public void setLoginTimeout(int seconds) throws SQLException {
  1529.     }
  1531.     @Override
  1532.     public int getLoginTimeout() throws SQLException {
  1533.         return 0;
  1534.     }
  1536.     @Override
  1537.     public Logger getParentLogger() throws SQLFeatureNotSupportedException {
  1538.         return null;
  1539.     }
  1541.     @Override
  1542.     public <T> T unwrap(Class<T> iface) throws SQLException {
  1543.         return null;
  1544.     }
  1546.     @Override
  1547.     public boolean isWrapperFor(Class<?> iface) throws SQLException {
  1548.         return false;
  1549.     }
  1550. }
  1552. package org.god.ibatis.core;
  1554. import javax.sql.DataSource;
  1555. import java.io.PrintWriter;
  1556. import java.sql.Connection;
  1557. import java.sql.DriverManager;
  1558. import java.sql.SQLException;
  1559. import java.sql.SQLFeatureNotSupportedException;
  1560. import java.util.logging.Logger;
  1562. //数据源的实现类UNPOOLED
  1563. //不使用连接池,每一次都新建Connection对象
  1564. public class UnPooledDataSource implements DataSource {
  1565.     //数据库驱动,值从配置文件中来
  1566.     private String url;
  1567.     private String username;
  1568.     private String password;
  1569.     public UnPooledDataSource() {}
  1570.     public UnPooledDataSource(String driver, String url, String username, String password) {
  1571.         //直接注册驱动
  1572.         try
  1573.         {
  1574.             Class.forName(driver);
  1575.         }
  1576.         catch (ClassNotFoundException e)
  1577.         {
  1578.             throw new RuntimeException(e);
  1579.         }
  1580.         //创建一个数据源对象
  1581.         this.url = url;
  1582.         this.username = username;
  1583.         this.password = password;
  1584.     }
  1586.     @Override
  1587.     public Connection getConnection() throws SQLException
  1588.     {
  1589.         Connection connection = DriverManager.getConnection(url, username, password);
  1590.         return connection;
  1591.     }
  1593.     @Override
  1594.     public Connection getConnection(String username, String password) throws SQLException
  1595.     {
  1596.         Connection connection = DriverManager.getConnection(url, username, password);
  1597.         return null;
  1598.     }
  1600.     @Override
  1601.     public PrintWriter getLogWriter() throws SQLException {
  1602.         return null;
  1603.     }
  1605.     @Override
  1606.     public void setLogWriter(PrintWriter out) throws SQLException {
  1608.     }
  1610.     @Override
  1611.     public void setLoginTimeout(int seconds) throws SQLException {
  1613.     }
  1615.     @Override
  1616.     public int getLoginTimeout() throws SQLException {
  1617.         return 0;
  1618.     }
  1620.     @Override
  1621.     public Logger getParentLogger() throws SQLFeatureNotSupportedException {
  1622.         return null;
  1623.     }
  1625.     @Override
  1626.     public <T> T unwrap(Class<T> iface) throws SQLException {
  1627.         return null;
  1628.     }
  1630.     @Override
  1631.     public boolean isWrapperFor(Class<?> iface) throws SQLException {
  1632.         return false;
  1633.     }
  1634. }
  1636. package org.god.ibatis.utils;
  1638. import java.io.InputStream;
  1640. public class Resources
  1641. {
  1642.     //godBatis提供的资源工具类,完成类路径中资源的加载
  1643.     private Resources(){}
  1644.     //工具类的构造方法都是私有化的,因为方法都是静态的
  1645.     //为了避免new对象,所以构造方法私有化
  1646.     public static InputStream getResourceAsStream(String resource)
  1647.     {
  1648.         //从类路径下加载资源
  1649.         //从类路径中获取资源作为一个输入流
  1650.         return ClassLoader.getSystemClassLoader().getResourceAsStream(resource);
  1651.     }
  1652. }
  1654. package org.god.ibatis.utils;
  1656. import java.io.InputStream;
  1658. public class Resources
  1659. {
  1660.     //godBatis提供的资源工具类,完成类路径中资源的加载
  1661.     private Resources(){}
  1662.     //工具类的构造方法都是私有化的,因为方法都是静态的
  1663.     //为了避免new对象,所以构造方法私有化
  1664.     public static InputStream getResourceAsStream(String resource)
  1665.     {
  1666.         //从类路径下加载资源
  1667.         //从类路径中获取资源作为一个输入流
  1668.         return ClassLoader.getSystemClassLoader().getResourceAsStream(resource);
  1669.     }
  1670. }

发表评论

表情：
评论列表 （有 0 条评论，155人围观）

还没有评论，来说两句吧...

相关阅读