手写Mybatis源码（原来真的很简单！！！）

---

一、JDBC操作数据库_问题分析

JDBC使用流程

1. 加载数据库驱动
2. 创建数据库连接
3. 创建编译对象
4. 设置入参执行SQL
5. 返回结果集

代码示例

public class JDBCTest {
    public static void main(String[] args) throws Exception {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            // 加载数据库驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 通过驱动管理类获取数据库链接
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis",
            "root","123456789");
            // 定义sql语句？表示占位符
            String sql = "select * from user where name = ?";
            // 获取预处理statement
            preparedStatement = connection.prepareStatement(sql);
            // 设置参数，第一个参数为sql语句中参数的序号(从1开始)，第二个参数为设置的参数值
            preparedStatement.setString(1, "zhangsan");
            // 向数据库发出sql执行查询，查询出结果集
            resultSet = preparedStatement.executeQuery();
            // 遍历查询结果集
            while (resultSet.next()) {
                int id = resultSet.getInt("id");
                String username = resultSet.getString("name");
                // 封装User
                User user = new User();
                user.setId(id);
                user.setName(username);
                System.out.println(user);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 释放资源
            if (resultSet != null) {
                try {
                    resultSet.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (preparedStatement != null) {
                try {
                    preparedStatement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

问题分析

存在问题	解决思路
数据库配置信息存在硬编码问题	使用配置文件
频繁创建、释放数据库连接问题	使用数据库连接池
SQL语句	使用配置文件
数据库配置信息存在硬编码问题	使用配置文件

二、自定义持久层框架_思路分析

主要分两部分，项目使用端：平常写代码所说的后台服务；持久层框架：即项目使用端引入的jar包

核心接口/类重点说明：

类名定义	角色定位	分工协作
Resources	资源辅助类	负责读取配置文件转化为输入流
Configuration	数据库资源类	负责存储数据库连接信息
MappedStatement	SQL与结果集资源类	负责存储SQL映射定义、存储结果集映射定义
SqlSessionFactoryBuilder	会话工厂构建者	负责解析配置文件，创建会话工厂SqlSessionFactory
SqlSessionFactory	会话工厂	负责创建会话SqlSession
SqlSession	会话	指派执行器Executor
Executor	执行器	负责执行SQL （配合指定资源Mapped Statement）

项目使用端：

1. 引入自定义持久层框架的jar包
2. sqlMapConfig.xml：数据库配置信息，以及mapper.xml的全路径
3. mapper.xml：SQL配置信息，存放SQL语句、参数类型、返回值类型相关信息

注意： sqlMapConfig.xml中引入mapper.xml是为了只读取一次配置文件，否则每个实体类会有一个mapper.xml，则需要读取很多次

自定义框架本身：

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

2. 创建两个javaBean(容器对象)：存放配置文件解析出来的内容

3. 解析配置文件(使用dom4j)，并创建SqlSession会话对象

4. 创建SqlSessionFactory接口以及实现类DefaultSqlSessionFactory

5. 创建SqlSession接口以及实现类DefaultSqlSession

SqlSession接口定义以上方法，DefaultSqlSession来决定什么操作调用对应的sql执行器

6. 创建Executor执行器接口以及实现类SimpleExecutor简单执行器

三、自定义框架_编码

项目使用端

创建sqlMapConfig核心配置文件：

<configuration>

    
    <dataSource>
        <property name="driverClassname" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis" />
        <property name="username" value="root" />
        <property name="password" value="123456789" />
    dataSource>

    
    <mappers>
        <mapper resource="mapper/UserMapper.xml"/>
    mappers>

configuration>

创建映射配置文件：

获取某个sql语句的唯一标示statementId：namespace.id 如：user.selectList

<mapper namespace="user">

    
    <select id="selectList" resultType="com.xc.pojo.User" >
        select * from user
    select>

    
    <select id="selectOne" resultType="com.xc.pojo.User" parameterType="com.xc.pojo.User" >
        select * from user where id = #{id} and name = #{name}
    select>

mapper>

User实体：

@Data
public class User {
    private Integer id;
    private String name;
}

pom.xml引入自定义框架

 <dependency>
     <groupId>com.xcgroupId>
     <artifactId>own-mybatisartifactId>
     <version>1.0-SNAPSHOTversion>
 dependency>

自定义框架本身

1、加载配置文件

• 根据配置文件的路径，加载配置文件成字节输入流，存到内存中

public class Resources {
    public static InputStream getResourceAsStream(String path){
        return Resources.class.getClassLoader().getResourceAsStream(path);
    }
}

2、创建两个配置类对象

• 映射配置类：mapper.xml解析出来内容
• 每个pojo实体都会对应一个mapper.xml文件即一个MapperStatement对象
• sqlCommandType：第四节 自定义框架_优化才会用到

@Data
public class MapperStatement {

    //唯一标识 statementId：namespace.id
    private String statementId;

    //返回值类型
    private String resultType;

    //参数类型
    private String parameterType;

    //sql语句
    private String sql;
    
    // 判断当前是什么操作的一个属性-增删改查
    private String sqlCommandType;
}

• 核心配置类：数据库配置信息以及映射配置类的map集合
• 将多个MapperStatement对象存入Map集合，statementId(namespace.id)作为key
• 将所有的配置文件都聚合到Configuration中，方便一次读取以及统一管理

@Data
public class Configuration {

    //数据源对象
    private DataSource dataSource;

    //map.xml对象集合 key：statementId
    private Map<String,MapperStatement> mapperStatementMap = new HashMap<>();
}

3、解析配置文件，填充配置类对象

• XMLConfigBuilder类的parse方法：解析核心配置类，返回Configuration对象
• 创建SqlSession工厂对象，以便之后创建SqlSession会话

public class SqlSessionFactoryBuilder {

    public SqlSessionFactory build(InputStream inputStream) throws Exception {
        //1.解析配置文件，封装容器对象：专门解析核心配置文件的解析类
        XMLConfigBuilder xmlConfigBuilder = new XMLConfigBuilder();
        Configuration configuration = xmlConfigBuilder.parse(inputStream);
        //2.创建SqlSessionFactory工厂对象
        return new DefaultSqlSessionFactory(configuration);
    }

}

• XMLConfigBuilder核心配置解析类里面嵌套着XMLMapperBuilder映射配置文件解析类
• 输入流转化为Document对象，一是根据property标签获取数据库配置信息并创建数据源添加到configuration
• 二是根据mapper标签通过XMLMapperBuilder解析类遍历解析配置文件同样添加到configuration的map集合类

public class XMLConfigBuilder {

    private Configuration configuration;

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

	// 使用dom4j+xpath解析
    public Configuration parse(InputStream inputStream) throws Exception {
        //将xml转化为Document对象
        Document document = new SAXReader().read(inputStream);
        //获取跟节点，对于sqlMapConfig.xml来说就是标签
        Element rootElement = document.getRootElement();

        // -------------解析数据库配置文件----------------

        // "//"表示从匹配选择的当前节点，而不考虑它们的位置
        // 即这里获取数据源url用户密码信息
        // 例：
        List<Element> propertyList = rootElement.selectNodes("//property");
        Properties properties = new Properties();
        for (Element element : propertyList) {
            // 获取标签中，name和value属性的值
            String name = element.attributeValue("name");
            String value = element.attributeValue("value");
            properties.setProperty(name,value);
        }
        // 创建数据源对象
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(properties.getProperty("driverClassName"));
        dataSource.setUrl(properties.getProperty("url"));
        dataSource.setUsername(properties.getProperty("username"));
        dataSource.setPassword(properties.getProperty("password"));
        // 将创建好的数据源添加到Configuration对象中
        configuration.setDataSource(dataSource);

        // -------------解析映射配置文件----------------

        /*
        1.获取映射配置文件路径
        2.根据路径进行映射文件的加载解析
        3.封装到MapperStatement，存入configuration的map集合中
        */
        // 例：
        List<Element> mapperList = rootElement.selectNodes("//mapper");
        for (Element element : mapperList) {
            String resource = element.attributeValue("resource");
            InputStream resourceAsStream = Resources.getResourceAsStream(resource);
            // XMLMapperBuilder 专门解析映射配置文件的对象-最后会存入configuration的map集合对象中
            XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(configuration);
            xmlMapperBuilder.parse(resourceAsStream);
        }
        return configuration;
    }
}

• 与XMLConfigBuilder解析类原理一样
• 传入configuration，并将解析好的MapperStatement对象添加到mapperStatementMap

public class XMLMapperBuilder {

    private Configuration configuration;

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

    public void parse(InputStream resourceAsStream) throws Exception {
        // 将输入流转化为Document对象，并获取跟节点
        Document document = new SAXReader().read(resourceAsStream);
        Element rootElement = document.getRootElement();

        // 例：
        String namespace = rootElement.attributeValue("namespace");
        /* 例：
            
                select * from user where id = #{id} and name = #{name}
            
        */
        List<Element> selectList = rootElement.selectNodes("//select");
        for (Element element : selectList) {
            String id = element.attributeValue("id");
            String resultType = element.attributeValue("resultType");
            String parameterType = element.attributeValue("parameterType");
            String sql = element.getTextTrim();

            // 封装MapperStatement对象
            MapperStatement mapperStatement = new MapperStatement();
            String statementId = namespace + "." + id;
            mapperStatement.setStatementId(statementId);
            mapperStatement.setParameterType(parameterType);
            mapperStatement.setResultType(resultType);
            mapperStatement.setSql(sql);
            //第四节 自定义框架_优化才会用到
            mapperStatement.setSqlCommandType("select");

            // 添加到configurations的map集合中
            configuration.getMapperStatementMap().put(statementId,mapperStatement);
        }
    }
}

4、创建SqlSessionFactory工厂接口及DefaultSqlSessionFactory实现类

• 为了创建SqlSession会话，调用增删改查方法

public interface SqlSessionFactory {

    // 创建SqlSession对象
    SqlSession openSession();

}

• 创建简单执行器，与核心配置类共同创建SqlSession会话实现类
• configuration提供数据配置和sql以及参数和结果集封装
• simpleExecutor提供JDBC执行sql底层原理

public class DefaultSqlSessionFactory implements SqlSessionFactory {

    private Configuration configuration;

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

    @Override
    public SqlSession openSession() {
        // 1.创建执行器对象-具体的包装jdbc的sql操作，关闭连接等
        Executor simpleExecutor = new SimpleExecutor();

        // 2.创建sqlSession对象-判断执行增删改查哪些操作等
        return new DefaultSqlSession(configuration,simpleExecutor);
    }
}

5、创建SqlSession会话接口及DefaultSqlSession实现类

• statementId(“namespace.id”)：定位具体Mapper.xml的sql语句以及入参和返回
• param：替换sql语句中的占位符？，可能字符串、对象、Map、集合

public interface SqlSession {

    // 查询多个结果
    <E> List<E> selectList(String statementId, Object param) throws Exception;

    // 查询单个结果
    <T> T selectOne(String statementId, Object param) throws Exception;

    // 清理资源
    void close();
    
}

• 利用聚合进来的configuration对象获取MapperStatement映射配置对象向下传给执行器
• 另外一个聚合进来的executor简单执行器来执行底层JDBC操作
• DefaultSqlSession的作用则是聚合配置类分发到不同执行器的不同方法
• 执行器种类：简单执行器、可重用执行器、批量执行器（这里只模拟第一种）

public class DefaultSqlSession implements SqlSession {

    private Configuration configuration;
    private Executor executor;

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

    @Override
    public <E> List<E> selectList(String statementId, Object param) throws Exception {
        // 根据StatementId获取映射配置对象MapperStatement
        MapperStatement mapperStatement = configuration.getMapperStatementMap().get(statementId);
        // 然后将具体的查询操作委派给SimpleExecutor执行器
        // 执行底层jdbc需要：1.数据库配置，2.sql配置信息
        return executor.query(configuration,mapperStatement,param);
    }

    @Override
    public <T> T selectOne(String statementId, Object param) throws Exception {
        // 调用selectList()
        List<Object> selectList = selectList(statementId, param);
        if (selectList.size() == 1){
            return (T) selectList.get(0);
        }else if (selectList.size() > 1){
            throw new Exception("返回数据不止一条！！！");
        }else {
            return null;
        }
    }

    @Override
    public void close() {
        executor.close();
    }

}

6、创建Executor执行器接口及SimpleExecutor实现类

• 执行器接口定义增删改查方法，具体的JDBC底层操作由它的实现类来完成

public interface Executor { 

    <E> List<E> query(Configuration configuration, MapperStatement mapperStatement, Object param) 
    	throws Exception;

    void close();
}

• 执行器实现类整体流程就是JDBC那一套，从加载驱动到处理结果集
• getBoundSql方法功能：
  • 一是将 标签的sql语句“#{字段名}”替换成?赋值给finalSql。(这里使用的mybatis代码，不用深究就是根据正则表达式替换，最后有gitee代码链接)
    二是将替换?时候的字段名取出来放到ParameterMapping对象中，有多个，根据?次序，放入parameterMappingList集合
    入参根据
    标签的parameterType属性获取全限定类名，反射获取Class对象
    1. 遍历parameterMappingList，获取字段名，加上Class对象获取Field属性类
    2. query查询方法有个param参数，即入参对象（有可能字符串，集合这里只考虑对象），通过Field属性和param对象通过反射获取属性值
  • 结果集根据标签的resultType属性获取全限定类名，反射获取实例对象
    1. 通过结果集元数据获取字段名columnName，再resultSet.getObject获取数据库中对应字段值
    2. 通过java实体字段名和Class对象获取对应字段的Get方法的Method
    3. 这里说下1和2步骤中两个字段不是一回事，如果数据库和实体中不一样，这里需要转化成一致

    public class SimpleExecutor implements Executor{
    
        private Connection connection = null;
        private PreparedStatement preparedStatement = null;
        private ResultSet resultSet = null;
    
        @Override
        public <E> List<E> query(Configuration configuration, MapperStatement mapperStatement, Object param) 
        		throws Exception {
            // 1.加载驱动，获取数据库连接
            connection = configuration.getDataSource().getConnection();
    
            // 2.获取preparedStatement预编译对象
            // 从mapperStatement中获取sql语句
            // 例：select * from user where id = #{id} and username = #{username}
            String sql = mapperStatement.getSql();
    
            // 1)需要转化为：select * from user where id = ? and username = ?
            // 2)需要将替换的值保存下来，后续?赋值需要用到
            BoundSql boundSql = getBoundSql(sql);
            String finalSql = boundSql.getFinalSql();
            preparedStatement = connection.prepareStatement(finalSql);
    
            // 3.根据入参赋值？
            // 获取入参的全限定类名 com.xc.pojo.User
            String parameterType = mapperStatement.getParameterType();
            // 没有入参类型，表示sql没有参数，这里不需要?赋值
            if (parameterType != null){
                // 入参对象Class类
                Class<?> parameterTypeClass = Class.forName(parameterType);
                // 获取#{}参数字段list
                List<ParameterMapping> parameterMappingList = boundSql.getParameterMappingList();
                for (int i = 0; i < parameterMappingList.size(); i++) {
                    // 获取字段名称
                    ParameterMapping parameterMapping = parameterMappingList.get(i);
                    String paramName = parameterMapping.getContent();
                    // 通过反射获取入参对象的Field属性
                    Field field = parameterTypeClass.getDeclaredField(paramName);
                    // 禁用安全检查，不用排除private，效率提升好多倍
                    field.setAccessible(true);
                    // param为User对象，通过属性反射获取到user对象id和name的属性值
                    Object value = field.get(param);
                    // 赋值占位符，占位符？数字从1开始
                    preparedStatement.setObject(i + 1, value);
                }
            }
    
            // 4.执行sql,发起查询
            resultSet = preparedStatement.executeQuery();
    
            // 5.处理返回结果集
            List<E> list = new ArrayList<>();
            while (resultSet.next()){
                // 通过

    标签的返回值类型，创建返回对象 String resultType = mapperStatement.getResultType(); Class<?> resultTypeClass = Class.forName(resultType); Object obj = resultTypeClass.newInstance(); // 结果集的元数据信息：字段名，字段值等 // resultSet: 一条结果集对应一张表的所有字段 ResultSetMetaData metaData = resultSet.getMetaData(); for (int i = 1; i <= metaData.getColumnCount(); i++) { //数据库字段名 String columnName = metaData.getColumnName(i); // 字段的值 Object value = resultSet.getObject(columnName); // columnName：数据库字段，而下方需要实体中的字段，如果两边不一样，则这需要有一个转化 // 获取读写方法即get、set方法 PropertyDescriptor propertyDescriptor = new PropertyDescriptor(columnName, resultTypeClass); // 获取读方法-字段的set方法 Method writeMethod = propertyDescriptor.getWriteMethod(); // 反射为返回对象赋值 // 参数1：实例对象 参数2：要设置的值 writeMethod.invoke(obj,value); } list.add((E) obj); } return list; } /** * @Description 获取?占位符的sql，以及保存#{}中的字段名称 * * 1、将标签中的sql的 "#{字段名}" 整个部分替换成？，赋值 finalSql * 2、截取#{}中的字段名称，添加到ParameterMapping对象的content属性，多个，赋值List * * @Author xuchang * @Date 2022/10/19 16:44:51 */ private BoundSql getBoundSql(String sql) { // 1.创建标记处理器：配合标记解析器完成标记的处理解析工作 ParameterMappingTokenHandler parameterMappingTokenHandler = new ParameterMappingTokenHandler(); // 2.创建标记解析器 GenericTokenParser genericTokenParser = new GenericTokenParser("#{", "}", parameterMappingTokenHandler); // #{}占位符替换成？ 2.解析替换的过程中 将#{}里面的值保存下来 ParameterMapping String finalSql = genericTokenParser.parse(sql); // #{}里面的值的一个集合 id username List<ParameterMapping> parameterMappings = parameterMappingTokenHandler.getParameterMappings(); return new BoundSql(finalSql, parameterMappings); } @Override public void close() { // 释放资源 if (resultSet != null) { try { resultSet.close(); } catch (SQLException e) { e.printStackTrace(); } } if (preparedStatement != null) { try { preparedStatement.close(); } catch (SQLException e) { e.printStackTrace(); } } if (connection != null) { try { connection.close(); } catch (SQLException e) { e.printStackTrace(); } } } }

    @Data
    @AllArgsConstructor
    public class BoundSql {
    
        // 用?做占位符的sql语句
        private String finalSql;
    
        // 字段名称的集合
        private List<ParameterMapping> parameterMappingList;
    }
    

    @Data
    @AllArgsConstructor
    public class ParameterMapping {
        // 保存#{}中对于的字段名称
        private String content;
    }
    

    7、项目使用端利用自定义框架测试

    • 优点：完成一张表的增删改查只需要创建一个实体类。(其他类接口都是必须要有的)
    • 缺点1：sqlSession会话对象创建频繁，每次需要User的CRUD，就需要创建
    • 缺点2：调用方法需要手动添加参数statementId：namespace.id

    @Test
    public void test1() throws Exception {
        // 1.根据配置文件的路径，加载成字节输入流，存到内存中 注意：配置文件还未解析
        InputStream inputStream = Resources.getResourceAsStream("sqlMapConfig.xml");
    
        // 2.解析配置文件，封装到Configuration对象，创建sqlSessionFactory工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    
        // 3.生产sqlSession 创建执行器对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
    
        // 4.调用sqlSession方法
        User user = new User();
        user.setId(100);
        user.setName("zhangsan");
        User userOne = sqlSession.selectOne("user.selectOne", user);
        System.out.println("查询单个用户："+userOne);
    
        List<User> userList = sqlSession.selectList("user.selectList",null);
        System.out.println("查询所有用户："+userList.toString());
    
        // 5.释放资源
        sqlSession.close();
    }
    

    输出结果：

    查询单个用户：User(id=100, name=zhangsan)
    查询所有用户：[User(id=100, name=zhangsan), User(id=120, name=Lisi)]
    

    四、自定义框架_优化

    1、优化思路

    • 去掉statementId硬编码：创建一个UserMapper或IUserDao接口，每个方法名、入参、返回值和mapper.xml的
    标签的id、parameterType、resultType一一对应
  • sqlSession创建频繁：通过动态代理创建IUserDao的实现类，内容则是sqlSession.selectOne和sqlSession.selectList；这样sqlSession只需要创建一次，以后每次需要User的CRUD，则调用代理对象对应方法即可

  2、优化代码

  在sqlSession中添加方法

  public interface SqlSession {
  
  	...
  
      // 生成代理对象
      <T> T getMapper(Class<?> mapperClass);
  
  }
  

  对应实现类方法

  • 动态代理对象：不需要编译，运行期间生成字节码，通过传入的类加载器加载，只存在于内存中
  • mapperClass：UserMapper或IUserDao接口的Class对象
  • 代理类调用接口中的方法，则会被拦截进入invoke方法，因为没有目标类，则具体的实现都在invoke里面了
  • 通过mapperClass和方法名获取到statementId
  • statementId和参数有了，但是DefaultSqlSession要有CRUD查询和更新操作，所以sqlCommandType来区分

  public class DefaultSqlSession implements SqlSession {
  
      private Configuration configuration;
      private Executor executor;
  
      public DefaultSqlSession(Configuration configuration, Executor executor) {
          this.configuration = configuration;
          this.executor = executor;
      }
  
      @Override
      public <E> List<E> selectList(String statementId, Object param) throws Exception {
          // 根据StatementId获取映射配置对象MapperStatement
          MapperStatement mapperStatement = configuration.getMapperStatementMap().get(statementId);
          // 然后将具体的查询操作委派给SimpleExecutor执行器
          // 执行底层jdbc需要：1.数据库配置，2.sql配置信息
          return executor.query(configuration,mapperStatement,param);
      }
  
      @Override
      public <T> T selectOne(String statementId, Object param) throws Exception {
          // 调用selectList()
          List<Object> selectList = selectList(statementId, param);
          if (selectList.size() == 1){
              return (T) selectList.get(0);
          }else if (selectList.size() > 1){
              throw new Exception("返回数据不止一条！！！");
          }else {
              return null;
          }
      }
  
      @Override
      public void close() {
          executor.close();
      }
  
  
      @Override
      public <T> T getMapper(Class<?> mapperClass) {
  
          // 使用JDK动态代理生成基于接口的对象
          // 1、创建一个类(代理类)，实现目标接口，实现所有的方法实现
          // 2、动态代理类：代码运行期间生成的，而非编译期
          Object proxyInstance = Proxy.newProxyInstance(DefaultSqlSession.class.getClassLoader(), 
          	new Class[]{mapperClass}, new InvocationHandler() {
              // proxy：生成的代理对象本身，很少用
              // method：调用接口中哪个方法，则执行对应代理里的对应方法
              // args：调用方法的参数
              @Override
              public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                  // 执行底层JDBC
                  // 1.获取statementId
                  // ps:约定接口中的方法名要与标签的id属性名一致，
                  // 这样就可以通过接口获取statementId = namespace.id
                  String methodName = method.getName();// 方法名 - findAll
                  String className = mapperClass.getName();//接口类名 - com.xc.do.IUserDao
                  String statementId = className + "." + methodName;
  
                  // 2.判断调用sqlSession中CRUD的什么方法
                  // MapperStatement类添加属性sqlCommandType-sql增删改查类型
                  MapperStatement mapperStatement = configuration.getMapperStatementMap().get(statementId);
                  // select  update delete insert
                  String sqlCommandType = mapperStatement.getSqlCommandType();
                  switch (sqlCommandType){
                      case "select" :
                          // 3.判断调用selectOne还是selectList
                          // 获取返回值类型，
                          Type genericReturnType = method.getGenericReturnType();
                          // ParameterizedType是Type的子接口，表示一个有参数的类型，例如Collection，Map等
                          if(genericReturnType instanceof ParameterizedType){
                              if(args != null) {
                                  return selectList(statementId, args[0]);
                              }
                              return  selectList(statementId, null);
                          }
                          return selectOne(statementId,args[0]);
                      case "update":
                          // 执行更新方法调用
                          break;
                      case "delete":
                          // 执行delete方法调用
                          break;
                      case "insert":
                          // 执行insert方法调用
                          break;
                  }
                  return null;
              }
          });
  
          return (T) proxyInstance;
      }
  }
  
  3、优化后测试
  
  缺点：相较于优化前，需要新添加一个接口
  优点：不需要手动添加statementId，SqlSession不用频繁创建
  
  @Test
  public void test2() throws Exception {
      // 1.根据配置文件的路径，加载成字节输入流，存到内存中 注意：配置文件还未解析
      InputStream resourceAsSteam = Resources.getResourceAsStream("sqlMapConfig.xml");
  
      // 2.解析了配置文件，封装了Configuration对象  2.创建sqlSessionFactory工厂对象
      SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsSteam);
  
      // 3.生产sqlSession 创建了执行器对象
      SqlSession sqlSession = sqlSessionFactory.openSession();
  
      // 4.调用sqlSession方法
      IUserDao userDao = sqlSession.getMapper(IUserDao.class);
  
      List<User> all = userDao.findAll();
      for (User user : all) {
          System.out.println(user);
      }
  
      // 5.释放资源
      sqlSession.close();
  }
  
  五、Spring整合优化
  
  与Spring整合之后，InputStream、SqlSessionFactory、SqlSession、IUserDao代理对象统统不需要自己创建
  全都交给了spring容器管理，我们要做的就是@Autowired IUserDao userDao
  然后就可以用代理对象调用增删改查方法了
  
  六、gitee代码
  
   
  手写源码框架项目: https://gitee.com/xuchang614/own-mybatis
   
   
  测试框架项目: https://gitee.com/xuchang614/own-mybatis-test
   
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
   
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  你可能感兴趣的:(mybatis,mybatis,数据库)
  
  
  
  简要介绍联合索引
  dareu_4523
  八股-数据库数据库联合索引
  联合索引（CompositeIndex或Multiple-ColumnIndex）是数据库索引的一种类型，它由多个列组合在一起创建。联合索引的主要作用是加速包含多个列的查询，特别是涉及多列条件的查询语句。举例说明：假设有一个包含first_name和last_name列的users表：CREATETABLEusers(user_idINTPRIMARYKEY,first_nameVARCHAR(2
  
  java-redis-击穿
  Flying_Fish_Xuan
  javaredisspringboot
  Java与Redis之缓存击穿问题解决方案1.背景：缓存的基本概念在高并发系统中，缓存是一个非常重要的优化手段。它的基本思想是将热点数据缓存在高速的存储系统（如Redis、Memcached）中，从而减轻数据库等持久层的压力，并加快请求响应速度。常见的缓存模式有：缓存读写：读取数据时优先从缓存中获取，如果缓存中没有数据，则从数据库或其他持久化存储中获取并缓存。缓存失效策略：缓存系统通常会为每条缓存
  
  php 扫描条形码,将条形码扫描仪集成到PHP应用程序中？
  weixin_39575054
  php扫描条形码
  PHP可以很容易地用于阅读打印在纸质文档上的条形码。通过USB将手动条形码读取器连接到计算机，显着地将PHP(或任何其他Web编程语言)的可用性扩展到涉及文档和产品管理的任务，例如在数据库中查找书记录或列出特定客户的所有帐单。以下部分简要介绍了使用PHP连接和使用手动条形码读取器的过程。Theusageofbarcodescannersdescribedinthisarticleareinthes
  
  第4章 MyBatis的关联映射和缓存机制
  小猪宝宝哦
  mybatis缓存java
  目录/Contents第4章MyBatis的关联映射和缓存机制学习目标了解数据表之间的三种关联关系了解对象之间的三种关系熟悉关联关系中的嵌套查询和嵌套结果掌握一对一关联映射掌握一对多关联映射掌握多对多关联映射熟悉Mybatis的缓存机制学习内容1关联映射概述1.1关联映射关系1.1.1一对一关系1.1.2一对多关系1.1.3多对多关系1.2Java对象如何描述事物之间的关系1.3Java对象关联映
  
  第一章 认识Mybatis的核心组件
  qq_38911531
  1、可以从http://www.softpedia.com/get/Programming/Other-Programming-Files/MyBatis.shtml下载mybatis的jar包。2、mybatis的核心组件mybatis是由4个部分构成，sqlsessionFactoryBuilder(构造器)，他会根据配置或代码来生成sqlSessionFactory,采用的是分布构建的Bui
  
  数据采集与数据预处理（python）概述（一）
  数学难
  python开发语言
  一，数据采集的概念在处理海量事务时，我们经常需要针对特定条件进行数据的精准获取，这一过程被称为数据采集。数据采集的核心在于从多样化的数据存储形式中，根据具体需求进行有针对性的数据提取。这些数据存储形式丰富多样，涵盖了从简单的文本文档到复杂的数据库系统，再到多媒体文件等多个领域。常见的数据存储方式包括：文件系统（FileSystem）：文本文档：TXT,DOC,PDF,XLS(Excel),CSV等
  
  Mybatis的核心组件是什么？
  传智教育
  数据库javasql
  MyBatis是一个基于Java的持久层框架，所谓的持久层框架就是专门用来将数据进行持久化的框架，也就是说将数据存储到数据库中的框架。学习并掌握Mybatis，首先就要了解Mybatis的核心组件。下面，我们一起来了解一下Mybatis四大核心组件：SqlSessionFactoryBuilderSqlSessionFactorySqlSessionSQLMapper01SqlSessionFac
  
  第五章 SqlSession 的创建过程
  flying jiang
  MyBatis3源码深度解析javatomcatmybatis
  在MyBatis3中，SqlSession的创建过程涉及到对MyBatis配置文件的解析，这通常是通过XPath（XMLPathLanguage）来完成的。XPath是一种在XML文档中查找信息的语言，MyBatis使用它来解析配置文件（如mybatis-config.xml）中的元素和属性。以下是SqlSession创建过程中XPath使用的简要概述：读取配置文件：MyBatis首先需要读取其配
  
  掌握MySQL：数据库建模与ER图设计指南
  勤劳兔码农
  数据库mysqloracle
  掌握MySQL：数据库建模与ER图设计指南在现代软件开发中，数据库建模是设计和实现数据驱动型应用程序的关键步骤之一。通过数据库建模，我们能够更好地组织数据、提高数据的存储效率、增强数据的完整性和一致性。在MySQL环境下，良好的数据库建模和设计直接影响应用的性能和可维护性。本文将深入探讨数据库建模的基本概念、实体-关系（ER）图的设计原理，以及如何在MySQL中进行数据库建模与优化，为读者提供全面
  
  spring boot整合mybatis-plus
  兴趣互联
  MyBatis-Plus（简称MP）是一个MyBatis的增强工具，在MyBatis的基础上只做增强不做改变，为简化开发、提高效率而生。整合mybatis-plus只需要在pom.xml中引入mybatis-plus-boot-starter启动器(目前最新版本3.4.0)com.baomidoumybatis-plus-boot-starter3.3.2
  
  heidisql linux 安装_CentOS mysql GUI图形化数据库管理工具Heidisql的安装Navicat
  俄罗斯一只战斗鸡
  heidisqllinux安装
  在Windows下有用过Navicat和Heidisql，都是很强大的工具。因为Navicat是收费的，转到Linux环境下就一下使用Heidisql了。安装：系统环境：Centos7.2一、首先修改yum的源为阿里云：1、备份mv/etc/yum.repos.d/CentOS-Base.repo/etc/yum.repos.d/CentOS-Base.repo.backup2、下载新的CentO
  
  python提取数据库数据到前端html5显示_python html提取数据库数据
  weixin_39878745
  python开源工具列表【持续更新】以下是个人在工作中整理的一些pythonwheel，供参考。这个列表包含与网页抓取和数据处理的Python库网络通用urllib-网络库(stdlib)。requests-网络库。grab–网络库(基于pycurl)。pycurl–网络库(绑定libcurl)。urllib3–...文章武耀文2018-04-253128浏览量8个用于业余项目的优秀Python库
  
  unity连接mysql并读取所有数据库_Unity 3D 连接Mysql数据库
  地理沙龙
  usingUnityEngine;usingSystem;usingSystem.Data;usingSystem.Collections;usingMySql.Data.MySqlClient;usingMySql.Data;usingSystem.IO;publicclassSqlAccess{publicstaticMySqlConnectiondbConnection;//如果只是在本地的
  
  heidisql linux 安装_Linux和Windows下Mysql数据库安装详解
  吴钧泽
  heidisqllinux安装
  目录数据库原理数据库简介文件存储对数据的存储需求一直存在。保存数据的方式，经历了手工管理、文件管理等阶段，直至数据库管理阶段。文件存储方式保存数据的弊端：缺乏对数据的整体管理,数据不便修改；不利于数据分析和共享;数据量急剧增长,大量数据不可能长期保存在文件中。数据库应运而生，是人们存放数据、访问数据、操作数据的存储仓库。DB和DBMS数据库(Database,简称DB)是按照数据结构来组织、存储和
  
  淘宝海量数据库OceanBase:系统架构详解
  weixin_34356555
  数据库系统架构大数据
  无论从数据量还是访问量，OceanBase不再能够是一个单机系统，即使一台单机能服务高达几个TB的数据、提供几万QPS的服务能力，因此，分布式系统不可避免，然而，内部如何实现拆表(拆库)以及如何实现数据库的事务，成为了一个很大的挑战和十分艰难的抉择：相关文章：淘宝海量数据库之一：来自业务的挑战淘宝海量数据库之二：一致性选择淘宝海量数据库之三：事务的ACID一种选择是当前数据库的常用的水平拆库，淘宝
  
  unity 局域网读取文件_(转载)Unity3D连接本地或局域网MySQL数据库
  丛子涵
  unity局域网读取文件
  1usingMySql.Data.MySqlClient;2usingSystem;3usingSystem.Data;45publicclassMySqlAccess6{7publicstaticMySqlConnectionmySqlConnection;//连接类对象89privatestaticstringhost;//IP地址。如果只是在本地的话，写localhost就可以。10priv
  
  heidisql linux 安装_linux安装mysql教程
  是佐罗而非索隆
  heidisqllinux安装
  1系统约定安装文件下载目录：/data/softwareMysql目录安装位置：/usr/local/mysql数据库保存位置：/data/mysql日志保存位置：/data/log/mysql执行如下命名：#mkdir/data/software#cd/data/software--下载安装包--建议：在windows上使用迅雷下载，速度很快(我的是1M/s)，然后用工具(Xftp)上传到/da
  
  从理论到实践：MySQL 性能优化和高可用架构，一次讲清
  程序猿java易
  mysql性能优化架构
  数据库系统作为IT业务系统的核心，其高可用性和容灾能力对整个业务系统的连续性和数据完整性起着至关重要的作用，是企业正常运营的基石尤其是在性能优化与高可用架构两方面，很多从业多年的DBA限于生产环境的固定体系，往往盲人摸象，难窥全局。而性能优化和高可用又是一对存在根本矛盾的特性。可以说，掌握了这两项技术的平衡，就掌握了MySQL的绝大部分内容，也就把握了数据库核心技术的最主流脉络。这本《MySQL性
  
  Python使用pymysql和xlrd2将Excel数据导入MySQL数据库
  悬崖上的金鱼6
  数据库pythonexcelmysqloracle
  在数据处理和管理中，有时候需要将Excel文件中的数据导入到MySQL数据库中进行进一步的分析和操作。本文将介绍如何使用Python编程语言实现这个过程。导入所需库importxlrd2#导入xlrd2库，用于读取Excel文件importpymysql#导入pymysql库，用于连接和操作MySQL数据库fromdatetimeimportdatetime#导入datetime库，用于处理日期和
  
  【Java】已解决：org.springframework.transaction.TransactionTimedOutException
  屿小夏
  java数据库开发语言
  文章目录一、分析问题背景场景描述二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.transaction.TransactionTimedOutException一、分析问题背景在Spring框架中，TransactionTimedOutException是一种常见的事务超时异常。通常，这种异常发生在数据库操作时间超过了预设的事务超时时间
  
  SQLite数据库管理与Android应用集成
  含老司开挖掘机
  本文还有配套的精品资源，点击获取简介：SQLite是一种轻量级的关系型数据库，适用于移动设备和单机应用。它内置了对SQL标准的支持，并提供丰富的数据操作功能。在Android开发中，SQLite是默认的数据库解决方案，可通过SQLiteOpenHelper和SQLiteDatabaseAPI进行管理。本教程将通过实践帮助理解SQLite数据库的创建、管理和使用，以及如何将其与Android应用集成
  
  linux系统下PostgreSQL的使用
  敲代码的雪糕
  linuxlinuxpostgresql运维
  文章目录前言一、安装pgsql数据库二、安装c和c++驱动三、使用1、头文件2、源文件3、main文件4、编译前言最近工作中使用到了pgsql,主要是使用其c++驱动完成数据库创建及增删改查等操作…一、安装pgsql数据库使用命令如下:sudoapt-getinstallpostgresql安装完成,使用如下命令,确认数据库版本:psql--version二、安装c和c++驱动使用如下命令安装c驱
  
  Docker部署Doris数据库
  hai40587
  docker数据库容器
  Docker部署Doris数据库是一个涉及多个步骤的过程，包括环境准备、Docker镜像拉取、配置文件创建、容器启动与配置、以及后续的数据库操作等。以下是一个详细的Docker部署Doris数据库的教程，旨在帮助用户成功在Docker环境中部署并运行Doris数据库。一、环境准备在部署Doris之前，需要确保你的系统已经安装了Docker。Docker是一个开源的容器化平台，可以帮助你轻松地部署和
  
  两阶段事务提交
  码农小伙
  事务java
  简介分布式事务是指会涉及到操作多个数据库的事务,在分布式系统中，各个节点之间在物理上相互独立，通过网络进行沟通和协调。XA就是X/OpenDTP定义的交易中间件与数据库之间的接口规范（即接口函数），交易中间件用它来通知数据库事务的开始、结束以及提交、回滚等。XA接口函数由数据库厂商提供。二阶段提交(Two-phaseCommit)是指，在计算机网络以及数据库领域内，为了使基于分布式系统架构下的所有
  
  20个MySQL 日期和时间函数，附带用法说明
  蜗牛小白
  MySQLmysql数据库
  在数据库管理和数据处理过程中，日期和时间的处理是一个重要的方面。MySQL提供了一组强大的日期和时间函数，允许用户对日期和时间数据进行各种操作和计算。这些函数可以帮助用户进行日期的格式化、日期之间的差异计算、从日期中提取特定部分等操作。以下列举了一些常用的MySQL日期和时间函数及其详细示例，以帮助开发者更高效地处理和管理日期和时间数据。常用的MySQL日期和时间函数1.NOW()返回当前日期和时
  
  【.NET全栈】ASP.NET开发Web应用——ADO.NET数据访问技术
  JosieBook
  #.NET全栈.netasp.net前端
  文章目录前言一、ADO.NET基础1、ADO.NET架构2、ADO.NET数据提供者二、连接数据库1、SqlConnection数据库连接类2、使用SqlConnectionStringBuilder连接字符串3、关闭和释放连接4、在web.config配置文件中保存连接字符串5、连接池技术三、与数据库交互1、使用SqlCommand操作数据库2、为SqlCommand传递参数3、使用SqlCom
  
  MySQL笔记DCL-待续（密码、权限）
  乐瓜乐虫
  数据库笔记
  什么是DCL数据控制语言？数据控制语言（DCL：DataControlLanguage）是用来设置或者更改数据库用户或角色权限的语句，这些语句包括GRANT、DENY、REVOKE等语句mysql限制root用户指定ip登录查看root用户可以在哪台机器登录selectuser,hostfrommysql.userwhereuser='root';修改mysql库里边的user表updatemys
  
  Python+requests+pytest+openpyxl+allure+loguru框架详解
  乐瓜乐虫
  pythonpytest
  一、框架目录结构1）tools目录用来放公共方法存储，如发送接口以及读取测试数据的方法，响应断言数据库断言前置sql等方法；2）datas目录用例存储接口用例的测试数据，我是用excel来存储的数据，文件数据图片数据等；3）testcases目录用来存放测试用例，一个python文件对应一个接口模块的测试用例，不同接口分别别多个不同的python文件；4）outputs里有reports和logs
  
  mysqlcheck
  蓝蓝小天月
  MySQL数据库mysql
  mysqlbin中的其他工具包对于mysql的其他工具,有很多选项是公共的,例如你在对数据库进行检查的时候,需要指定host和user以及其password来连接上mysqlserver来进行相关操作,这个时候其实用到的host等东西跟我们之前的mysql-client其实是类似的也就是说他们是作为mysql众多工具的公共选项的,mysqlclient可以用,mysqlcheck也能用..下面是一
  
  2022年最新Kubernetes常见面试题汇总
  云小七
  kubernetes容器云原生java
  常规题1.简述etcd及其特点答∶etcd是CoreOS团队发起的开源项目，是一个管理配置信息和服务发现（servicediscovery）的项目，它的目标是构建一个高可用的分布式键值（key-value）数据库，基于Go语言实现。特点∶●简单∶支持REST风格的HTTP+JSONAPI●安全∶支持HTTPS方式的访问●快速：支持并发1k/s的写操作●可靠∶支持分布式结构，基于Raft的一致性算法
  
  java数字签名三种方式
  知了ing
  javajdk
  以下3钟数字签名都是基于jdk7的
  1，RSA
  String password="test";
  // 1.初始化密钥
  KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
  keyPairGenerator.initialize(51
  
  Hibernate学习笔记
  caoyong
  Hibernate
  1>、Hibernate是数据访问层框架，是一个ORM(Object Relation Mapping)框架，作者为:Gavin King
  2>、搭建Hibernate的开发环境
       a>、添加jar包:
       aa>、hibernatte开发包中/lib/required/所
  
  设计模式之装饰器模式Decorator（结构型）
  漂泊一剑客
  Decorator
  1. 概述
         若你从事过面向对象开发，实现给一个类或对象增加行为，使用继承机制，这是所有面向对象语言的一个基本特性。如果已经存在的一个类缺少某些方法，或者须要给方法添加更多的功能（魅力），你也许会仅仅继承这个类来产生一个新类—这建立在额外的代码上。
        
  
  读取磁盘文件txt，并输入String
  一炮送你回车库
  String
  public static void main(String[] args) throws IOException {
   
   String fileContent = readFileContent("d:/aaa.txt");
   
   System.out.println(fileContent);
    
  
  
  js三级联动下拉框
  3213213333332132
  三级联动
  
  //三级联动
  省/直辖市<select id="province"></select>
  市/省直辖<select id="city"></select>
  县/区 <select id="area"></select>
  
  
  erlang之parse_transform编译选项的应用
  616050468
  parse_transform游戏服务器属性同步abstract_code
           最近使用erlang重构了游戏服务器的所有代码，之前看过C++/lua写的服务器引擎代码，引擎实现了玩家属性自动同步给前端和增量更新玩家数据到数据库的功能，这也是现在很多游戏服务器的优化方向，在引擎层面去解决数据同步和数据持久化，数据发生变化了业务层不需要关心怎么去同步给前端。由于游戏过程中玩家每个业务中玩家数据更改的量其实是很少
  
  JAVA JSON的解析
  darkranger
  java
  
  // {
  // “Total”：“条数”，
  // Code: 1,
  //
  // “PaymentItems”:[
  // {
  // “PaymentItemID”:”支款单ID”,
  // “PaymentCode”:”支款单编号”,
  // “PaymentTime”:”支款日期”,
  // ”ContractNo”:”合同号”，
  // 
  
  POJ-1273-Drainage Ditches
  aijuans
  ACM_POJ
  POJ-1273-Drainage Ditches
  http://poj.org/problem?id=1273
  基本的最大流，按LRJ的白书写的
  #include<iostream>
  #include<cstring>
  #include<queue>
  using namespace std;
  #define INF 0x7fffffff
  int ma
  
  工作流Activiti5表的命名及含义
  atongyeye
  工作流Activiti
  activiti5 - http://activiti.org/designer/update在线插件安装
  activiti5一共23张表
  Activiti的表都以ACT_开头。 第二部分是表示表的用途的两个字母标识。 用途也和服务的API对应。
  ACT_RE_*: 'RE'表示repository。 这个前缀的表包含了流程定义和流程静态资源 （图片，规则，等等）。
  A
  
  android的广播机制和广播的简单使用
  百合不是茶
  android广播机制广播的注册
        Android广播机制简介 在Android中，有一些操作完成以后，会发送广播，比如说发出一条短信，或打出一个电话，如果某个程序接收了这个广播，就会做相应的处理。这个广播跟我们传统意义中的电台广播有些相似之处。之所以叫做广播，就是因为它只负责“说”而不管你“听不听”，也就是不管你接收方如何处理。另外，广播可以被不只一个应用程序所接收，当然也可能不被任何应
  
  Spring事务传播行为详解
  bijian1013
  javaspring事务传播行为
          在service类前加上@Transactional，声明这个service所有方法需要事务管理。每一个业务方法开始时都会打开一个事务。
          Spring默认情况下会对运行期例外(RunTimeException)进行事务回滚。这
  
  eidtplus operate
  征客丶
  eidtplus
  开启列模式: Alt+C 鼠标选择   OR   Alt+鼠标左键拖动
  列模式替换或复制内容(多行):
  右键-->格式-->填充所选内容-->选择相应操作
  OR
  Ctrl+Shift+V(复制多行数据,必须行数一致)
  -------------------------------------------------------
  
  【Kafka一】Kafka入门
  bit1129
  kafka
  这篇文章来自Spark集成Kafka(http://bit1129.iteye.com/blog/2174765)，这里把它单独取出来，作为Kafka的入门吧
    下载Kafka
  http://mirror.bit.edu.cn/apache/kafka/0.8.1.1/kafka_2.10-0.8.1.1.tgz
  2.10表示Scala的版本，而0.8.1.1表示Kafka
  
  Spring 事务实现机制
  BlueSkator
  spring代理事务
  Spring是以代理的方式实现对事务的管理。我们在Action中所使用的Service对象，其实是代理对象的实例，并不是我们所写的Service对象实例。既然是两个不同的对象，那为什么我们在Action中可以象使用Service对象一样的使用代理对象呢？为了说明问题，假设有个Service类叫AService，它的Spring事务代理类为AProxyService，AService实现了一个接口 
  
  bootstrap源码学习与示例：bootstrap-dropdown（转帖）
  BreakingBad
  bootstrapdropdown
  bootstrap-dropdown组件是个烂东西，我读后的整体感觉。
  一个下拉开菜单的设计：
  <ul class="nav pull-right">
  <li id="fat-menu" class="dropdown">
  
  
  读《研磨设计模式》-代码笔记-中介者模式-Mediator
  bylijinnan
  java设计模式
  声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/
  /*
  * 中介者模式（Mediator）：用一个中介对象来封装一系列的对象交互。
  * 中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
  *
  * 在我看来，Mediator模式是把多个对象（
  
  常用代码记录
  chenjunt3
  UIExcelJ#
   
  1、单据设置某行或某字段不能修改
  //i是行号,"cash"是字段名称
  getBillCardPanelWrapper().getBillCardPanel().getBillModel().setCellEditable(i, "cash", false);
  //取得单据表体所有项用以上语句做循环就能设置整行了
  getBillC
  
  搜索引擎与工作流引擎
  comsci
  算法工作搜索引擎网络应用
   
      最近在公司做和搜索有关的工作，(只是简单的应用开源工具集成到自己的产品中)工作流系统的进一步设计暂时放在一边了，偶然看到谷歌的研究员吴军写的数学之美系列中的搜索引擎与图论这篇文章中的介绍，我发现这样一个关系(仅仅是猜想)
    -----搜索引擎和流程引擎的基础--都是图论，至少像在我在JWFD中引擎算法中用到的是自定义的广度优先
  
  oracle Health Monitor
  daizj
  oracleHealth Monitor
  About Health Monitor
  Beginning with Release 11g, Oracle Database includes a framework called Health Monitor for running diagnostic checks on the database.
  About Health Monitor Checks
  Health M
  
  JSON字符串转换为对象
  dieslrae
  javajson
      作为前言,首先是要吐槽一下公司的脑残编译部署方式,web和core分开部署本来没什么问题,但是这丫居然不把json的包作为基础包而作为web的包,导致了core端不能使用,而且我们的core是可以当web来用的(不要在意这些细节),所以在core中处理json串就是个问题.没办法,跟编译那帮人也扯不清楚,只有自己写json的解析了.
    
  
  C语言学习八结构体，综合应用，学生管理系统
  dcj3sjt126com
  C语言
  实现功能的代码：
  # include <stdio.h>
  # include <malloc.h>
  struct Student
  {
  int age;
  float score;
  char name[100];
  };
  int main(void)
  {
  int len;
  struct Student * pArr;
  int i,
  
  vagrant学习笔记
  dcj3sjt126com
  vagrant
  想了解多主机是如何定义和使用的, 所以又学习了一遍vagrant
   
  1. vagrant virtualbox 下载安装
  https://www.vagrantup.com/downloads.html
  https://www.virtualbox.org/wiki/Downloads
   
  查看安装在命令行输入vagrant
   
   
  2.
  
  14.性能优化-优化-软件配置优化
  frank1234
  软件配置性能优化
  1.Tomcat线程池
  修改tomcat的server.xml文件：
  <Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" maxThreads="1200" m
  
  一个不错的shell 脚本教程 入门级
  HarborChung
  linuxshell
  一个不错的shell 脚本教程 入门级
  建立一个脚本 　　Linux中有好多中不同的shell，但是通常我们使用bash (bourne again shell) 进行shell编程，因为bash是免费的并且很容易使用。所以在本文中笔者所提供的脚本都是使用bash（但是在大多数情况下，这些脚本同样可以在 bash的大姐，bourne shell中运行）。 　　如同其他语言一样
  
  Spring4新特性——核心容器的其他改进
  jinnianshilongnian
  spring动态代理spring4依赖注入
  Spring4新特性——泛型限定式依赖注入
  Spring4新特性——核心容器的其他改进
  Spring4新特性——Web开发的增强
  Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC 
  Spring4新特性——Groovy Bean定义DSL
  Spring4新特性——更好的Java泛型操作API 
  Spring4新
  
  Linux设置tomcat开机启动
  liuxingguome
  tomcatlinux开机自启动
  执行命令sudo gedit /etc/init.d/tomcat6
  然后把以下英文部分复制过去。（注意第一句#!/bin/sh如果不写，就不是一个shell文件。然后将对应的jdk和tomcat换成你自己的目录就行了。
  #!/bin/bash
  #
  # /etc/rc.d/init.d/tomcat
  # init script for tomcat precesses
  
  第13章 Ajax进阶（下）
  onestopweb
  Ajax
  index.html
  <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  <html xmlns="http://www.w3.org/
  
  Troubleshooting Crystal Reports off BW
  blueoxygen
  BO
  http://wiki.sdn.sap.com/wiki/display/BOBJ/Troubleshooting+Crystal+Reports+off+BW#TroubleshootingCrystalReportsoffBW-TracingBOE
   
  Quite useful, especially this part:
  SAP BW connectivity
  For t
  
  Java开发熟手该当心的11个错误
  tomcat_oracle
  javajvm多线程单元测试
  #1、不在属性文件或XML文件中外化配置属性。比如，没有把批处理使用的线程数设置成可在属性文件中配置。你的批处理程序无论在DEV环境中，还是UAT（用户验收
  测试）环境中，都可以顺畅无阻地运行，但是一旦部署在PROD 上，把它作为多线程程序处理更大的数据集时，就会抛出IOException，原因可能是JDBC驱动版本不同，也可能是#2中讨论的问题。如果线程数目 可以在属性文件中配置，那么使它成为
  
  正则表达式大全
  yang852220741
  html编程正则表达式
  今天向大家分享正则表达式大全，它可以大提高你的工作效率
  正则表达式也可以被当作是一门语言，当你学习一门新的编程语言的时候，他们是一个小的子语言。初看时觉得它没有任何的意义，但是很多时候，你不得不阅读一些教程，或文章来理解这些简单的描述模式。
  一、校验数字的表达式
  数字：^[0-9]*$
  n位的数字：^\d{n}$
  至少n位的数字：^\d{n,}$
  m-n位的数字：^\d{m,n}$
  
  
  
  
  
  
  
  
  按字母分类：
  ABCDEFGHIJKLMNOPQRSTUVWXYZ其他
  
  
  
  
  
  
  首页 -
  关于我们 -
  站内搜索 -
  Sitemap -
  侵权投诉
  
  版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.