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

已于 2023-08-27 16:32:16 修改
阅读量158 收藏
点赞数 1
分类专栏： # Mybatis框架 JAVA 文章标签： 后端 mybatis maven xml java 开发语言 架构
于 2023-08-27 16:22:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75960169/article/details/132524631
版权 
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.god.ibatis</groupId>
    <artifactId>godbatis</artifactId>
    <version>1.0</version>
    <packaging>jar</packaging>
    <dependencies>
        <dependency>
            <groupId>org.dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>2.1.3</version>
        </dependency>
        <dependency>
            <groupId>jaxen</groupId>
            <artifactId>jaxen</artifactId>
            <version>1.2.0</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.30</version>
        </dependency>
    </dependencies>
    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

</project>
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.god.ibatis</groupId>
    <artifactId>godbatis</artifactId>
    <version>1.0</version>
    <packaging>jar</packaging>
    <dependencies>
        <dependency>
            <groupId>org.dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>2.1.3</version>
        </dependency>
        <dependency>
            <groupId>jaxen</groupId>
            <artifactId>jaxen</artifactId>
            <version>1.2.0</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.30</version>
        </dependency>
    </dependencies>
    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

</project>
package org.god.ibatis.core;

public class Const
{
    private Const(){}
    //整个框架的常量类
    public static final String UN_POOLED_DATASOURCE = "UNPOOLED";
    public static final String POOLED_DATASOURCE = "POOLED";
    public static final String JNDI_DATASOURCE = "JNDI";
    public static final String JDBC_TRANSACTION = "JDBC";
    public static final String MANAGED_TRANSACTION = "MANAGED";
}

package org.god.ibatis.core;

public class Const
{
    private Const(){}
    //整个框架的常量类
    public static final String UN_POOLED_DATASOURCE = "UNPOOLED";
    public static final String POOLED_DATASOURCE = "POOLED";
    public static final String JNDI_DATASOURCE = "JNDI";
    public static final String JDBC_TRANSACTION = "JDBC";
    public static final String MANAGED_TRANSACTION = "MANAGED";
}

package org.god.ibatis.core;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;

public class JdbcTransaction implements Transaction
{
    //Jdbc事务管理器
    //godBatis只实现这个
    //我们控制事务需要调用connection的方法实现
    //需要调用连接对象的方法
    //我们的连接对象是从数据源来的
    //数据源属性必须要有,不然无法做事务的操作
    private DataSource dataSource = null;
    //数据源属性,是获取Connection对象的,所以这个数据源要实现DataSource
    //我们只需要三个实现即可,POOLED,UNPOOLED,JNDI
    public JdbcTransaction(DataSource dataSource, boolean autoCommit) {
        //创建事务管理器对象
        this.dataSource = dataSource;
        this.autoCommit = autoCommit;
    }
    //将connection对外暴露,可以执行SQL语句,必须在同一个事务管理器下,是同一个连接
    @Override
    public Connection getConnection()
    {
        return connection;
    }

    //因为openConnection已经创建对象了,就不会再生成新的连接,就能保证是同一个连接对象了
    private Connection connection;
    @Override
    public void openConnection()
    {
        try
        {
            connection = dataSource.getConnection();
            connection.setAutoCommit(autoCommit);
        }
        catch (SQLException e)
        {
            throw new RuntimeException(e);
        }
    }
    private boolean autoCommit;
    //自动提交的标记,
    @Override
    public void commit()
    {
        try
        {
            connection.commit();
        }
        catch (SQLException e)
        {
            e.printStackTrace();
        }
    }

    @Override
    public void rollback()
    {
        try {
            connection.rollback();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void close()
    {
        try {
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

package org.god.ibatis.core;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;

public class JdbcTransaction implements Transaction
{
    //Jdbc事务管理器
    //godBatis只实现这个
    //我们控制事务需要调用connection的方法实现
    //需要调用连接对象的方法
    //我们的连接对象是从数据源来的
    //数据源属性必须要有,不然无法做事务的操作
    private DataSource dataSource = null;
    //数据源属性,是获取Connection对象的,所以这个数据源要实现DataSource
    //我们只需要三个实现即可,POOLED,UNPOOLED,JNDI
    public JdbcTransaction(DataSource dataSource, boolean autoCommit) {
        //创建事务管理器对象
        this.dataSource = dataSource;
        this.autoCommit = autoCommit;
    }
    //将connection对外暴露,可以执行SQL语句,必须在同一个事务管理器下,是同一个连接
    @Override
    public Connection getConnection()
    {
        return connection;
    }

    //因为openConnection已经创建对象了,就不会再生成新的连接,就能保证是同一个连接对象了
    private Connection connection;
    @Override
    public void openConnection()
    {
        try
        {
            connection = dataSource.getConnection();
            connection.setAutoCommit(autoCommit);
        }
        catch (SQLException e)
        {
            throw new RuntimeException(e);
        }
    }
    private boolean autoCommit;
    //自动提交的标记,
    @Override
    public void commit()
    {
        try
        {
            connection.commit();
        }
        catch (SQLException e)
        {
            e.printStackTrace();
        }
    }

    @Override
    public void rollback()
    {
        try {
            connection.rollback();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void close()
    {
        try {
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}


package org.god.ibatis.core;

import javax.sql.DataSource;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.logging.Logger;

//数据源的实现类JNDI
//使用第三方的数据库连接池获取Connection对象
public class JndiDataSource implements DataSource
{
    @Override
    public Connection getConnection() throws SQLException {
        return null;
    }

    @Override
    public Connection getConnection(String username, String password) throws SQLException {
        return null;
    }

    @Override
    public PrintWriter getLogWriter() throws SQLException {
        return null;
    }

    @Override
    public void setLogWriter(PrintWriter out) throws SQLException {

    }

    @Override
    public void setLoginTimeout(int seconds) throws SQLException {

    }

    @Override
    public int getLoginTimeout() throws SQLException {
        return 0;
    }

    @Override
    public Logger getParentLogger() throws SQLFeatureNotSupportedException {
        return null;
    }

    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
        return null;
    }

    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        return false;
    }
}

package org.god.ibatis.core;

import javax.sql.DataSource;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.logging.Logger;

//数据源的实现类JNDI
//使用第三方的数据库连接池获取Connection对象
public class JndiDataSource implements DataSource
{
    @Override
    public Connection getConnection() throws SQLException {
        return null;
    }

    @Override
    public Connection getConnection(String username, String password) throws SQLException {
        return null;
    }

    @Override
    public PrintWriter getLogWriter() throws SQLException {
        return null;
    }

    @Override
    public void setLogWriter(PrintWriter out) throws SQLException {

    }

    @Override
    public void setLoginTimeout(int seconds) throws SQLException {

    }

    @Override
    public int getLoginTimeout() throws SQLException {
        return 0;
    }

    @Override
    public Logger getParentLogger() throws SQLFeatureNotSupportedException {
        return null;
    }

    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
        return null;
    }

    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        return false;
    }
}

package org.god.ibatis.core;

import javax.sql.DataSource;
import java.sql.Connection;

public class ManagedTransaction implements Transaction
{
    //godBatis对这个类就不实现了
    private DataSource dataSource;

    @Override
    public void openConnection() {

    }

    @Override
    public void commit() {

    }

    @Override
    public Connection getConnection() {
        return null;
    }

    @Override
    public void rollback() {

    }

    @Override
    public void close() {

    }
}

package org.god.ibatis.core;

import javax.sql.DataSource;
import java.sql.Connection;

public class ManagedTransaction implements Transaction
{
    //godBatis对这个类就不实现了
    private DataSource dataSource;

    @Override
    public void openConnection() {

    }

    @Override
    public void commit() {

    }

    @Override
    public Connection getConnection() {
        return null;
    }

    @Override
    public void rollback() {

    }

    @Override
    public void close() {

    }
}

package org.god.ibatis.core;

public class MappedStatement
{
    //这是一个普通的java类,封装了一个SQL标签
    //一个MappedStatement对象对应一个SQL标签
    //一个sql标签中所有的信息封装到该对象中
    //体现了面向对象编程实现
    //要封装的结果集类型
    //当select语句的时候,会对应一个resultType的值
    public MappedStatement(){}
    private String sql;
    private String resultType;

    @Override
    public String toString() {
        return "MappedStatement{" +
                "sql='" + sql + '\'' +
                ", resultType='" + resultType + '\'' +
                '}';
    }

    public String getSql() {
        return sql;
    }

    public void setSql(String sql) {
        this.sql = sql;
    }

    public String getResultType()
    {
        return resultType;
    }

    public void setResultType(String resultType)
    {
        this.resultType = resultType;
    }

    public MappedStatement(String sql, String resultType)
    {
        this.sql = sql;
        this.resultType = resultType;
    }
}

package org.god.ibatis.core;

public class MappedStatement
{
    //这是一个普通的java类,封装了一个SQL标签
    //一个MappedStatement对象对应一个SQL标签
    //一个sql标签中所有的信息封装到该对象中
    //体现了面向对象编程实现
    //要封装的结果集类型
    //当select语句的时候,会对应一个resultType的值
    public MappedStatement(){}
    private String sql;
    private String resultType;

    @Override
    public String toString() {
        return "MappedStatement{" +
                "sql='" + sql + '\'' +
                ", resultType='" + resultType + '\'' +
                '}';
    }

    public String getSql() {
        return sql;
    }

    public void setSql(String sql) {
        this.sql = sql;
    }

    public String getResultType()
    {
        return resultType;
    }

    public void setResultType(String resultType)
    {
        this.resultType = resultType;
    }

    public MappedStatement(String sql, String resultType)
    {
        this.sql = sql;
        this.resultType = resultType;
    }
}


package org.god.ibatis.core;

import javax.sql.DataSource;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.logging.Logger;

//数据源的实现类POOLED
//使用GodBatis内置的数据库连接池获取对象
public class PooledDataSource implements DataSource {
    @Override
    public Connection getConnection() throws SQLException {
        //从数据库连接池中获取connection对象
        //需要自己写一个连接池(自己封装)
        return null;
    }

    @Override
    public Connection getConnection(String username, String password) throws SQLException {
        return null;
    }

    @Override
    public PrintWriter getLogWriter() throws SQLException {
        return null;
    }

    @Override
    public void setLogWriter(PrintWriter out) throws SQLException {

    }

    @Override
    public void setLoginTimeout(int seconds) throws SQLException {

    }

    @Override
    public int getLoginTimeout() throws SQLException {
        return 0;
    }

    @Override
    public Logger getParentLogger() throws SQLFeatureNotSupportedException {
        return null;
    }

    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
        return null;
    }

    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        return false;
    }
}

package org.god.ibatis.core;

import javax.sql.DataSource;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.logging.Logger;

//数据源的实现类POOLED
//使用GodBatis内置的数据库连接池获取对象
public class PooledDataSource implements DataSource {
    @Override
    public Connection getConnection() throws SQLException {
        //从数据库连接池中获取connection对象
        //需要自己写一个连接池(自己封装)
        return null;
    }

    @Override
    public Connection getConnection(String username, String password) throws SQLException {
        return null;
    }

    @Override
    public PrintWriter getLogWriter() throws SQLException {
        return null;
    }

    @Override
    public void setLogWriter(PrintWriter out) throws SQLException {

    }

    @Override
    public void setLoginTimeout(int seconds) throws SQLException {

    }

    @Override
    public int getLoginTimeout() throws SQLException {
        return 0;
    }

    @Override
    public Logger getParentLogger() throws SQLFeatureNotSupportedException {
        return null;
    }

    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
        return null;
    }

    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        return false;
    }
}

package org.god.ibatis.core;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.sql.*;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class SqlSession
{
    protected SqlSession(SqlSessionFactory sqlSessionFactory)
    {
        this.sqlSessionFactory = sqlSessionFactory;
    }
    private SqlSessionFactory sqlSessionFactory;
    //insert
    public int insert(String sqlId,Object obj)
    {
        PreparedStatement statement = null;
        Connection connection = sqlSessionFactory.getTransaction().getConnection();
        int count = 0;
        try
        {
            //JDBC代码,执行insert语句,完成插入操作
            String oldSql = sqlSessionFactory.getMappedStatements().get(sqlId).getSql();
            String newSql = oldSql.replaceAll("#\\{[a-zA-Z0-9_$]*}","?");
            statement = connection.prepareStatement(newSql);
            //给?传值
            Map transfer = Transfer(oldSql);
            Iterator iterator = transfer.entrySet().iterator();
            while(iterator.hasNext())
            {
                Map.Entry entry = (Map.Entry)iterator.next();
                Integer index = (Integer)entry.getKey();
                String value = (String)entry.getValue();
                String methodName = "get" + value.toUpperCase().charAt(0) + value.substring(1);
                Method declaredMethod = obj.getClass().getDeclaredMethod(methodName);
                Object invoke = declaredMethod.invoke(obj);
                statement.setString(index,invoke.toString());
            }
            //执行SQL
            count = statement.executeUpdate();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (statement != null)
            {
                try
                {
                    statement.close();
                }
                catch (SQLException e)
                {
                    throw new RuntimeException(e);
                }
            }
        }
        return count;
    }
    public Object SelectOne(String sqlId,Object obj)
    {
        Object o = null;
        if(sqlSessionFactory.getMappedStatements().get(sqlId) != null)
        {
            Connection connection = null;
            PreparedStatement statement = null;
            ResultSet resultSet = null;
            try
            {
                connection = sqlSessionFactory.getTransaction().getConnection();
                MappedStatement mappedStatement = sqlSessionFactory.getMappedStatements().get(sqlId);
                String oldSql = mappedStatement.getSql();
                String newSql = oldSql.replaceAll("#\\{[a-zA-Z0-9_$]*}","?");
                statement = connection.prepareStatement(newSql);
                //给占位符传值
                Map map = Transfer(oldSql);
                Iterator iterator = map.entrySet().iterator();
                while(iterator.hasNext())
                {
                    Map.Entry entry = (Map.Entry) iterator.next();
                    Integer integer = (Integer)entry.getKey();
                    statement.setString(integer,obj.toString());
                }
                //查询返回结果集
                resultSet = statement.executeQuery();
                if(resultSet.next())
                {
                    String resultType = mappedStatement.getResultType();
                    Class<?> aClass = Class.forName(resultType);
                    Constructor<?> declaredConstructor = aClass.getDeclaredConstructor();
                    o = declaredConstructor.newInstance();
                    //赋值
                    ResultSetMetaData metaData = resultSet.getMetaData();
                    int columnCount = metaData.getColumnCount();
                    for (int i = 1; i < columnCount + 1; i++)
                    {
                        String columnName = metaData.getColumnName(i);
                        String value = resultSet.getString(columnName);
                        //直接赋值法
//                        Field declaredField = aClass.getDeclaredField(columnName);
//                        declaredField.setAccessible(true);
//                        declaredField.set(o,value);
                        String MethodName = "set" + columnName.toUpperCase().charAt(0) + columnName.substring(1);
                        Method declaredMethod = aClass.getDeclaredMethod(MethodName,String.class);
                        declaredMethod.invoke(o,value);
                    }
                }
            }
            catch (Exception e)
            {
                throw new RuntimeException(e);
            }
            finally
            {
                if (statement != null)
                {
                    try
                    {
                        statement.close();
                    }
                    catch (SQLException e)
                    {
                        throw new RuntimeException(e);
                    }
                }
                if (resultSet != null)
                {
                    try
                    {
                        resultSet.close();
                    }
                    catch(SQLException e)
                    {
                        throw new RuntimeException(e);
                    }
                }
            }
        }
        return o;
    }
    public Map Transfer(String oldSql) throws Exception
    {
        Map<Integer,String> map = new HashMap<>();
        int fromIndex = 0;
        int index = 1;
        while(true)
        {
            int starIndex = oldSql.indexOf("#",fromIndex);
            if(starIndex < 0)
            {
                break;
            }
            int endIndex = oldSql.indexOf("}",fromIndex);
            String value = oldSql.substring(starIndex + 2,endIndex).trim();
            map.put(index,value);
            fromIndex = endIndex + 1;
            index++;
        }
        return map;
    }
    public void commit()
    {
        sqlSessionFactory.getTransaction().commit();
    }
    public void rollback()
    {
        sqlSessionFactory.getTransaction().rollback();
    }
    public void close()
    {
        sqlSessionFactory.getTransaction().close();
    }
}

package org.god.ibatis.core;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.sql.*;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class SqlSession
{
    protected SqlSession(SqlSessionFactory sqlSessionFactory)
    {
        this.sqlSessionFactory = sqlSessionFactory;
    }
    private SqlSessionFactory sqlSessionFactory;
    //insert
    public int insert(String sqlId,Object obj)
    {
        PreparedStatement statement = null;
        Connection connection = sqlSessionFactory.getTransaction().getConnection();
        int count = 0;
        try
        {
            //JDBC代码,执行insert语句,完成插入操作
            String oldSql = sqlSessionFactory.getMappedStatements().get(sqlId).getSql();
            String newSql = oldSql.replaceAll("#\\{[a-zA-Z0-9_$]*}","?");
            statement = connection.prepareStatement(newSql);
            //给?传值
            Map transfer = Transfer(oldSql);
            Iterator iterator = transfer.entrySet().iterator();
            while(iterator.hasNext())
            {
                Map.Entry entry = (Map.Entry)iterator.next();
                Integer index = (Integer)entry.getKey();
                String value = (String)entry.getValue();
                String methodName = "get" + value.toUpperCase().charAt(0) + value.substring(1);
                Method declaredMethod = obj.getClass().getDeclaredMethod(methodName);
                Object invoke = declaredMethod.invoke(obj);
                statement.setString(index,invoke.toString());
            }
            //执行SQL
            count = statement.executeUpdate();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (statement != null)
            {
                try
                {
                    statement.close();
                }
                catch (SQLException e)
                {
                    throw new RuntimeException(e);
                }
            }
        }
        return count;
    }
    public Object SelectOne(String sqlId,Object obj)
    {
        Object o = null;
        if(sqlSessionFactory.getMappedStatements().get(sqlId) != null)
        {
            Connection connection = null;
            PreparedStatement statement = null;
            ResultSet resultSet = null;
            try
            {
                connection = sqlSessionFactory.getTransaction().getConnection();
                MappedStatement mappedStatement = sqlSessionFactory.getMappedStatements().get(sqlId);
                String oldSql = mappedStatement.getSql();
                String newSql = oldSql.replaceAll("#\\{[a-zA-Z0-9_$]*}","?");
                statement = connection.prepareStatement(newSql);
                //给占位符传值
                Map map = Transfer(oldSql);
                Iterator iterator = map.entrySet().iterator();
                while(iterator.hasNext())
                {
                    Map.Entry entry = (Map.Entry) iterator.next();
                    Integer integer = (Integer)entry.getKey();
                    statement.setString(integer,obj.toString());
                }
                //查询返回结果集
                resultSet = statement.executeQuery();
                if(resultSet.next())
                {
                    String resultType = mappedStatement.getResultType();
                    Class<?> aClass = Class.forName(resultType);
                    Constructor<?> declaredConstructor = aClass.getDeclaredConstructor();
                    o = declaredConstructor.newInstance();
                    //赋值
                    ResultSetMetaData metaData = resultSet.getMetaData();
                    int columnCount = metaData.getColumnCount();
                    for (int i = 1; i < columnCount + 1; i++)
                    {
                        String columnName = metaData.getColumnName(i);
                        String value = resultSet.getString(columnName);
                        //直接赋值法
//                        Field declaredField = aClass.getDeclaredField(columnName);
//                        declaredField.setAccessible(true);
//                        declaredField.set(o,value);
                        String MethodName = "set" + columnName.toUpperCase().charAt(0) + columnName.substring(1);
                        Method declaredMethod = aClass.getDeclaredMethod(MethodName,String.class);
                        declaredMethod.invoke(o,value);
                    }
                }
            }
            catch (Exception e)
            {
                throw new RuntimeException(e);
            }
            finally
            {
                if (statement != null)
                {
                    try
                    {
                        statement.close();
                    }
                    catch (SQLException e)
                    {
                        throw new RuntimeException(e);
                    }
                }
                if (resultSet != null)
                {
                    try
                    {
                        resultSet.close();
                    }
                    catch(SQLException e)
                    {
                        throw new RuntimeException(e);
                    }
                }
            }
        }
        return o;
    }
    public Map Transfer(String oldSql) throws Exception
    {
        Map<Integer,String> map = new HashMap<>();
        int fromIndex = 0;
        int index = 1;
        while(true)
        {
            int starIndex = oldSql.indexOf("#",fromIndex);
            if(starIndex < 0)
            {
                break;
            }
            int endIndex = oldSql.indexOf("}",fromIndex);
            String value = oldSql.substring(starIndex + 2,endIndex).trim();
            map.put(index,value);
            fromIndex = endIndex + 1;
            index++;
        }
        return map;
    }
    public void commit()
    {
        sqlSessionFactory.getTransaction().commit();
    }
    public void rollback()
    {
        sqlSessionFactory.getTransaction().rollback();
    }
    public void close()
    {
        sqlSessionFactory.getTransaction().close();
    }
}

package org.god.ibatis.core;

import java.util.Map;

public class SqlSessionFactory
{
    //一个数据库对应一个SqlSessionFactory对象
    //通过这个对象可以开启会话,建立与数据库的连接
    //一个SqlSessionFactory对象可以开启多个SqlSession会话
    //所以这个事务管理器应该是一个接口,面向接口编程
    protected SqlSessionFactory(){}
    public SqlSession openSession()
    {
        //开启会话的前提就是开启连接
        transaction.openConnection();
        //创建SqlSession对象
        SqlSession sqlSession = new SqlSession(this);
        return sqlSession;
    }

    protected SqlSessionFactory(Transaction transaction, Map<String, MappedStatement> mappedStatements) {
        this.transaction = transaction;
        this.mappedStatements = mappedStatements;
    }

    public Transaction getTransaction() {
        return transaction;
    }

    public void setTransaction(Transaction transaction) {
        this.transaction = transaction;
    }

    public Map<String, MappedStatement> getMappedStatements() {
        return mappedStatements;
    }

    public void setMappedStatements(Map<String, MappedStatement> mappedStatements) {
        this.mappedStatements = mappedStatements;
    }

    //事务管理器属性
    private Transaction transaction;
    //存放sql对象的map集合,key是SqlId,Value是对应的SQL标签对象
    private Map<String,MappedStatement> mappedStatements;
}

package org.god.ibatis.core;

import java.util.Map;

public class SqlSessionFactory
{
    //一个数据库对应一个SqlSessionFactory对象
    //通过这个对象可以开启会话,建立与数据库的连接
    //一个SqlSessionFactory对象可以开启多个SqlSession会话
    //所以这个事务管理器应该是一个接口,面向接口编程
    protected SqlSessionFactory(){}
    public SqlSession openSession()
    {
        //开启会话的前提就是开启连接
        transaction.openConnection();
        //创建SqlSession对象
        SqlSession sqlSession = new SqlSession(this);
        return sqlSession;
    }

    protected SqlSessionFactory(Transaction transaction, Map<String, MappedStatement> mappedStatements) {
        this.transaction = transaction;
        this.mappedStatements = mappedStatements;
    }

    public Transaction getTransaction() {
        return transaction;
    }

    public void setTransaction(Transaction transaction) {
        this.transaction = transaction;
    }

    public Map<String, MappedStatement> getMappedStatements() {
        return mappedStatements;
    }

    public void setMappedStatements(Map<String, MappedStatement> mappedStatements) {
        this.mappedStatements = mappedStatements;
    }

    //事务管理器属性
    private Transaction transaction;
    //存放sql对象的map集合,key是SqlId,Value是对应的SQL标签对象
    private Map<String,MappedStatement> mappedStatements;
}

package org.god.ibatis.core;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;
import org.god.ibatis.utils.Resources;

import javax.sql.DataSource;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class SqlSessionFactoryBuilder
{
    //通过godBatis-config文件,创建SqlSessionFactory对象
    public SqlSessionFactoryBuilder(){}
    public SqlSessionFactory build(InputStream is)
    {
        //解析godBatis-config文件创建SqlSessionFactory对象
        //build操作的核心就是要解析XML文件
        //解析完成要构建SqlSessionFactory对象
        //解析GodBatis-config文件
        SAXReader reader = new SAXReader();
        Document document = null;
        SqlSessionFactory sqlSessionFactory = null;
        try
        {
            document = reader.read(is);
            Element rootElement = (Element)document.selectSingleNode("/configuration/environments");
            String defaultId = rootElement.attributeValue("default");
            Element environment = (Element) document.selectSingleNode("/configuration/environments/environment[@id='" + defaultId +"']");
            Element transactionManagerEle = environment.element("transactionManager");
            Element dataSourceEle = environment.element("dataSource");
            DataSource dataSource = getDataSource(dataSourceEle);
            //获取事务管理器
            Transaction transaction = getTransaction(transactionManagerEle,dataSource);
            //获取MappedStatements
            List<Node> mappers = document.selectNodes("//mapper");
            List<String> mapperList = new ArrayList<>();
            mappers.forEach(node ->
            {
                Element mapper = (Element)node;
                String resource = mapper.attributeValue("resource");
                mapperList.add(resource);
            });
            //获取整个文件中所有的mapper标签
            Map<String,MappedStatement> mappedStatements = getMappedStatements(mapperList);
            sqlSessionFactory = new SqlSessionFactory(transaction,mappedStatements);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return sqlSessionFactory;
    }

    private Map<String, MappedStatement> getMappedStatements(List<String> mapperList)
    {
        Map<String,MappedStatement> map = new HashMap<>();
        mapperList.forEach(resource ->
        {
            SAXReader reader = new SAXReader();
            InputStream ip = Resources.getResourceAsStream(resource);
            Document document = null;
            try
            {
                document = reader.read(ip);
            }
            catch (DocumentException e)
            {
                throw new RuntimeException(e);
            }
            Element mapper = document.getRootElement();
            String namespace = mapper.attributeValue("namespace");
            List<Element> elements = mapper.elements();
            elements.forEach(element ->
            {
                MappedStatement mappedStatement = new MappedStatement();
                String resultType = element.attributeValue("resultType");
                String id = element.attributeValue("id");
                if(resultType != null)
                {
                    mappedStatement.setResultType(resultType);
                }
                else
                {
                    mappedStatement.setResultType("null");
                }
                String sql = element.getTextTrim();
                mappedStatement.setSql(sql);
                String sqlId = namespace + "." + id;
                map.put(sqlId,mappedStatement);
            });
        });
        return map;
    }

    private Transaction getTransaction(Element transactionManagerEle,DataSource dataSource)
    {
        //获取事务管理器对象
        String type = transactionManagerEle.attributeValue("type").trim().toUpperCase();
        Transaction transaction = null;
        if(Const.JDBC_TRANSACTION.equals(type))
        {
            //默认是开启事务的,将来需要手动提交的
            transaction = new JdbcTransaction(dataSource,false);
        }
        if(Const.MANAGED_TRANSACTION.equals(type))
        {
            transaction = new ManagedTransaction();
        }
        return transaction;
    }

    private DataSource getDataSource(Element dataSourceEle) 
    {
        //获取数据源对象
        String type = dataSourceEle.attributeValue("type").trim().toUpperCase();
        DataSource dataSource = null;
        List<Element> elements = dataSourceEle.elements();
        Map<String,String> map = new HashMap<>();
        elements.forEach(element -> 
        {
            String name = element.attributeValue("name");
            String value = element.attributeValue("value");
            map.put(name,value);
        });
        String driver = map.get("driver");
        String url = map.get("url");
        String username = map.get("username");
        String password = map.get("password");
        if(Const.UN_POOLED_DATASOURCE.equals(type))
        {
            dataSource = new UnPooledDataSource(driver,url,username,password);
        }
        else if(Const.POOLED_DATASOURCE.equals(type))
        {
            dataSource = new PooledDataSource();
        }
        else if(Const.JNDI_DATASOURCE.equals(type))
        {
            dataSource = new JndiDataSource();
        }
        return dataSource;
    }
}

package org.god.ibatis.core;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;
import org.god.ibatis.utils.Resources;

import javax.sql.DataSource;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class SqlSessionFactoryBuilder
{
    //通过godBatis-config文件,创建SqlSessionFactory对象
    public SqlSessionFactoryBuilder(){}
    public SqlSessionFactory build(InputStream is)
    {
        //解析godBatis-config文件创建SqlSessionFactory对象
        //build操作的核心就是要解析XML文件
        //解析完成要构建SqlSessionFactory对象
        //解析GodBatis-config文件
        SAXReader reader = new SAXReader();
        Document document = null;
        SqlSessionFactory sqlSessionFactory = null;
        try
        {
            document = reader.read(is);
            Element rootElement = (Element)document.selectSingleNode("/configuration/environments");
            String defaultId = rootElement.attributeValue("default");
            Element environment = (Element) document.selectSingleNode("/configuration/environments/environment[@id='" + defaultId +"']");
            Element transactionManagerEle = environment.element("transactionManager");
            Element dataSourceEle = environment.element("dataSource");
            DataSource dataSource = getDataSource(dataSourceEle);
            //获取事务管理器
            Transaction transaction = getTransaction(transactionManagerEle,dataSource);
            //获取MappedStatements
            List<Node> mappers = document.selectNodes("//mapper");
            List<String> mapperList = new ArrayList<>();
            mappers.forEach(node ->
            {
                Element mapper = (Element)node;
                String resource = mapper.attributeValue("resource");
                mapperList.add(resource);
            });
            //获取整个文件中所有的mapper标签
            Map<String,MappedStatement> mappedStatements = getMappedStatements(mapperList);
            sqlSessionFactory = new SqlSessionFactory(transaction,mappedStatements);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return sqlSessionFactory;
    }

    private Map<String, MappedStatement> getMappedStatements(List<String> mapperList)
    {
        Map<String,MappedStatement> map = new HashMap<>();
        mapperList.forEach(resource ->
        {
            SAXReader reader = new SAXReader();
            InputStream ip = Resources.getResourceAsStream(resource);
            Document document = null;
            try
            {
                document = reader.read(ip);
            }
            catch (DocumentException e)
            {
                throw new RuntimeException(e);
            }
            Element mapper = document.getRootElement();
            String namespace = mapper.attributeValue("namespace");
            List<Element> elements = mapper.elements();
            elements.forEach(element ->
            {
                MappedStatement mappedStatement = new MappedStatement();
                String resultType = element.attributeValue("resultType");
                String id = element.attributeValue("id");
                if(resultType != null)
                {
                    mappedStatement.setResultType(resultType);
                }
                else
                {
                    mappedStatement.setResultType("null");
                }
                String sql = element.getTextTrim();
                mappedStatement.setSql(sql);
                String sqlId = namespace + "." + id;
                map.put(sqlId,mappedStatement);
            });
        });
        return map;
    }

    private Transaction getTransaction(Element transactionManagerEle,DataSource dataSource)
    {
        //获取事务管理器对象
        String type = transactionManagerEle.attributeValue("type").trim().toUpperCase();
        Transaction transaction = null;
        if(Const.JDBC_TRANSACTION.equals(type))
        {
            //默认是开启事务的,将来需要手动提交的
            transaction = new JdbcTransaction(dataSource,false);
        }
        if(Const.MANAGED_TRANSACTION.equals(type))
        {
            transaction = new ManagedTransaction();
        }
        return transaction;
    }

    private DataSource getDataSource(Element dataSourceEle) 
    {
        //获取数据源对象
        String type = dataSourceEle.attributeValue("type").trim().toUpperCase();
        DataSource dataSource = null;
        List<Element> elements = dataSourceEle.elements();
        Map<String,String> map = new HashMap<>();
        elements.forEach(element -> 
        {
            String name = element.attributeValue("name");
            String value = element.attributeValue("value");
            map.put(name,value);
        });
        String driver = map.get("driver");
        String url = map.get("url");
        String username = map.get("username");
        String password = map.get("password");
        if(Const.UN_POOLED_DATASOURCE.equals(type))
        {
            dataSource = new UnPooledDataSource(driver,url,username,password);
        }
        else if(Const.POOLED_DATASOURCE.equals(type))
        {
            dataSource = new PooledDataSource();
        }
        else if(Const.JNDI_DATASOURCE.equals(type))
        {
            dataSource = new JndiDataSource();
        }
        return dataSource;
    }

package org.god.ibatis.core;

import java.sql.Connection;

public interface Transaction
{
    //事务管理器接口
    //所有的事务管理都应该遵循此规范
    //JDBC和MANAGED事务管理器都应该实现这个接口
    //Transaction事务管理器通过事务方法
    //提交事务,回滚事务,关闭事务
    void openConnection();
    //真正的开启数据库连接
    void commit();
    //获取数据库连接对象的方法
    Connection getConnection();
    void rollback();
    void close();
}

package org.god.ibatis.core;

import java.sql.Connection;

public interface Transaction
{
    //事务管理器接口
    //所有的事务管理都应该遵循此规范
    //JDBC和MANAGED事务管理器都应该实现这个接口
    //Transaction事务管理器通过事务方法
    //提交事务,回滚事务,关闭事务
    void openConnection();
    //真正的开启数据库连接
    void commit();
    //获取数据库连接对象的方法
    Connection getConnection();
    void rollback();
    void close();
}


package org.god.ibatis.core;

import javax.sql.DataSource;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.logging.Logger;

//数据源的实现类UNPOOLED
//不使用连接池,每一次都新建Connection对象
public class UnPooledDataSource implements DataSource {
    //数据库驱动,值从配置文件中来
    private String url;
    private String username;
    private String password;
    public UnPooledDataSource() {}
    public UnPooledDataSource(String driver, String url, String username, String password) {
        //直接注册驱动
        try
        {
            Class.forName(driver);
        }
        catch (ClassNotFoundException e)
        {
            throw new RuntimeException(e);
        }
        //创建一个数据源对象
        this.url = url;
        this.username = username;
        this.password = password;
    }

    @Override
    public Connection getConnection() throws SQLException
    {
        Connection connection = DriverManager.getConnection(url, username, password);
        return connection;
    }

    @Override
    public Connection getConnection(String username, String password) throws SQLException
    {
        Connection connection = DriverManager.getConnection(url, username, password);
        return null;
    }

    @Override
    public PrintWriter getLogWriter() throws SQLException {
        return null;
    }

    @Override
    public void setLogWriter(PrintWriter out) throws SQLException {

    }

    @Override
    public void setLoginTimeout(int seconds) throws SQLException {

    }

    @Override
    public int getLoginTimeout() throws SQLException {
        return 0;
    }

    @Override
    public Logger getParentLogger() throws SQLFeatureNotSupportedException {
        return null;
    }

    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
        return null;
    }

    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        return false;
    }
}

package org.god.ibatis.core;

import javax.sql.DataSource;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.logging.Logger;

//数据源的实现类UNPOOLED
//不使用连接池,每一次都新建Connection对象
public class UnPooledDataSource implements DataSource {
    //数据库驱动,值从配置文件中来
    private String url;
    private String username;
    private String password;
    public UnPooledDataSource() {}
    public UnPooledDataSource(String driver, String url, String username, String password) {
        //直接注册驱动
        try
        {
            Class.forName(driver);
        }
        catch (ClassNotFoundException e)
        {
            throw new RuntimeException(e);
        }
        //创建一个数据源对象
        this.url = url;
        this.username = username;
        this.password = password;
    }

    @Override
    public Connection getConnection() throws SQLException
    {
        Connection connection = DriverManager.getConnection(url, username, password);
        return connection;
    }

    @Override
    public Connection getConnection(String username, String password) throws SQLException
    {
        Connection connection = DriverManager.getConnection(url, username, password);
        return null;
    }

    @Override
    public PrintWriter getLogWriter() throws SQLException {
        return null;
    }

    @Override
    public void setLogWriter(PrintWriter out) throws SQLException {

    }

    @Override
    public void setLoginTimeout(int seconds) throws SQLException {

    }

    @Override
    public int getLoginTimeout() throws SQLException {
        return 0;
    }

    @Override
    public Logger getParentLogger() throws SQLFeatureNotSupportedException {
        return null;
    }

    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
        return null;
    }

    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        return false;
    }
}

package org.god.ibatis.utils;

import java.io.InputStream;

public class Resources
{
    //godBatis提供的资源工具类,完成类路径中资源的加载
    private Resources(){}
    //工具类的构造方法都是私有化的,因为方法都是静态的
    //为了避免new对象,所以构造方法私有化
    public static InputStream getResourceAsStream(String resource)
    {
        //从类路径下加载资源
        //从类路径中获取资源作为一个输入流
        return ClassLoader.getSystemClassLoader().getResourceAsStream(resource);
    }
}

package org.god.ibatis.utils;

import java.io.InputStream;

public class Resources
{
    //godBatis提供的资源工具类,完成类路径中资源的加载
    private Resources(){}
    //工具类的构造方法都是私有化的,因为方法都是静态的
    //为了避免new对象,所以构造方法私有化
    public static InputStream getResourceAsStream(String resource)
    {
        //从类路径下加载资源
        //从类路径中获取资源作为一个输入流
        return ClassLoader.getSystemClassLoader().getResourceAsStream(resource);
    }
}
旧约Alatus
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JDBC封装步骤
08-23
文档脉络清楚的详述了实现JDBC封装所需要进行的步骤。
【MyBatis系列1】MyBatis快速入门demo(基于传统JDBC,DBUtils,Hibernate的对比分析)
zwx900102的博客
09-04 3037
JDBC,DBUtils,Hibernate,Mybatis对比分析前言JDBC编程Apache DbUtilsORM模型常见的ORM框架HibernateMyBatisMyBatis简单示例总结 前言 作为一名Java后台开发，与数据库打交道是必不可少的一部分，那么与数据库打交道就涉及到了如何建立连接，如何将数据库的表转换为Java对象等等，这些都是需要考虑的问题，所以Java中提供了JDBC来供我们操作数据库 JDBC编程 JDBC（Java Data Base Connectivity）,早先的Jav
MyBatis
weixin_47520834的博客
09-09 196
MyBatis 1.什么是 MyBatis？ MyBatis是对jdbc的轻量级封装，是一个orm对象关系映射框架，(通过xml或注解的方式，把实体类与表之间做映射关系),目的是为了简化开发，达到 以OOP的方式来操作数据库(不写sql)。 dbutils是一个jdbc组件； mybatis–>mybatis-plus（大大提高开发效率） mybatis是一个半自动的orm框架，还要写sql. 2.使用mybatis ​ 2.1 安装环境: ​ mybatis的核心jar包；数据
JDBC 和 mybatis
与你清欢
10-18 839
1. 什么是JDBC,有什么用 JDBC API 允许用户访问任何形式的表格数据，尤其是存储在关系数据库中的数据。 2. jdbc 安装 复制mysql-connector-java-5.1.49.jar 到lib 文件夹下 右键lib add to library 3. 使用 1. 注册驱动 使用 Class.forName("com.mysql.jdbc.Driver") 连接数据库 通过 DriverManager.getConnection(url,user,pass..
比较一下 JDBC, dbutils, Mybatis 和 Hibernate
一切都会好起来的，即使不在今天
10-24 2584
JDBC: 原生访问数据库的方式, 其它三个都是对 JDBC 不同程度的包装 访问数据库比较麻烦, 代码重复度极高 dbutils: 是对jdbc进行了相对简单的包装, 主要就是能自动封装查询结构 集, 需要在代码中写 sql 语句 Mybatis: 进一步封装 jdbc, Sql 语句写在配置文件中, 面向对象操作, 有一 二级缓存功能 Hibernate: 对 jdbc 封装得最彻底的框架, ...
Mybatis 框架搭建封装JDBC，实现sql语句
Xiayebuliang的博客
01-09 898
8.4、加载mybatis-config.xml 配置文件。
006Mybatis之动态sql
qq_44835120的博客
05-02 141
在使用JDBC拼接sql是件很痛苦的事，mybatis的便捷之一就在与可以在xml里面使用动态sql，不仅可以避免多个空格等麻烦，可读性也有所提高。 环境搭建 （1）创建数据库 DROP TABLE IF EXISTS `blog`; CREATE TABLE `blog` ( `id` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL, `title` varchar(32) CHARACTER SET utf8 CO
mybatis 对jdbc封装
qq_46015410的博客
03-18 3137
基于maven结构的mybatis数据库封装
mybatis实现jdbc三种方式实例
llussize的博客
03-13 547
学习mybatis套路之前，我们得明白它的原理。其实很简单，mybatis就是较为高级一点的JDBC。也就是用来连接数据库实现操作的持久层框架。所以mybatis有以下几步：1&gt;conf.xml配置文件——配置连接数据库的url、user、password等2&gt;创建entity实体类——与数据库的字段保持一致，3&gt;创建sql.xml文件——读取xml文件操作的sq语句4&gt;T...
使用Mybatis进行JDBC操作
m0_68758365的博客
03-08 1244
(1)sqlsession简单介绍sqlSession提供select、insert、update、delete方法，在旧版本中使用sqlsession接口的这些方法，但是在新版本中Mybatis就会建议直接使用mapper接口的方法。
【基于MyBatis框架的JDBC基础实验】
twfplayer的博客
09-11 663
基于MyBatis框架的JDBC基础实验
JdbcUtil（Jdbc通过工具类）
01-05
JdbcUtil（Jdbc通过工具类）
Spring Boot 集成 Sharding-JDBC + Mybatis-Plus 实现分库分表功能
09-07
主要介绍了Spring Boot 集成 Sharding-JDBC + Mybatis-Plus 实现分库分表功能,本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
idea free-idea-mybatis-2019.12.18插件
01-10
idea free-idea-mybatis-2019.12.18插件（原文件名已存在，则换了个资源名）,直接下载解压即可
mybatis-plus3.5.2 jar包
06-25
mybatis-plus3.5.2常用jar包，mybatis-plus-3.5.2.jar、mybatis-plus-annotation-3.5.2.jar、mybatis-plus-core-3.5.2.jar、mybatis-plus-extension-3.5.2.jar、mybatis-plus-generator-3.5.2.jar和源码包mybatis-...
MyBatis-Plus入门+MyBatis-Plus文档手册 中文pdf高清版.rar
11-09
mybatis在持久层框架中还是比较火的，一般项目都是基于ssm。虽然mybatis可以直接在xml中...《MyBatis-Plus入门文档》主要介绍了MyBatis-Plus入门使用，以及关于mybatis-plus的更多介绍及特性，感兴趣的可以下载学习一下
mybatis-plus-code-generator-3.5.2.x.jar
03-09
MyBatis-Plus代码生成器
MyBatis与传统jdbc批量新增数据对比
骏马逸动，心随你动的博客
01-16 933
传统JDBC批量插入方法： 1.Java代码中使用For循环直接插入SQL数据如：execute()或executeUpdate()方法。 2.借助于Statement、Prestatement对象的批处理方法addBatch public class jdbcUtil { // 处理数据库事务，批量操作需要手动提交事务 public static void commit(C...
JdbcTemplate、mybatis、mybatis-plus的原理及其应用实现
最新发布
2302_76703265的博客
11-09 579
JdbcTemplate，是 Spring 对 JDBC 的封装，是Spring框架提供的数据访问模块之一，用于简化JDBC操作的工具类，能够更方便的进行数据库操作。MyBatis 会根据注解的内容来执行相应的 SQL 操作。
MyBatis和MyBatis-Plus框架
04-06
MyBatis是一款优秀的持久层框架，它封装了JDBC操作数据库的细节，并且提供了映射器和对象关系映射（ORM）的支持，使得我们能够通过简单的配置和编写SQL语句就能完成数据库的操作。 MyBatis-Plus是MyBatis的增强工具...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

旧约Alatus

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值