Mybatis初始化加载流程————配置文件解析

本次测试的实例中的相关配置文件如下：
application.xml文件：

version="1.0" encoding="UTF-8"?>
"http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="name" value="mysql"/>
        <property name="url" value="xxxxxxx"/>
        <property name="username" value="xxxxxxx"/>
        <property name="password" value="zh4y4q5ang"/>
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    
    id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="mapperLocations" value="classpath:mybatis/*.xml"/>
        <property name="typeAliasesPackage" value="com.entities"/>
        <property name="configLocation" value="classpath:config/configuration.xml"/>
    
    id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.interfaces"/>
    
    id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    

configuration.xml文件：

<configuration>
    <plugins>
        <plugin interceptor="com.interceptors.LogInterceptor" >plugin>
    plugins>
configuration>

CityMapper.xml文件：

<mapper namespace="com.interfaces.CityMapper">
<resultMap id="BaseResultMap" type="com.entities.City">
    <id column="ID" jdbcType="INTEGER" property="id"/>
    <result column="Name" jdbcType="CHAR" property="name"/>
    <result column="CountryCode" jdbcType="CHAR" property="countrycode"/>
    <result column="District" jdbcType="CHAR" property="district"/>
    <result column="Population" jdbcType="INTEGER" property="population"/>
resultMap>
<select id="selectCityById" parameterType="int" resultType="com.entities.City">
    SELECT * FROM city WHERE ID=#{id,jdbcType=INTEGER}
select>
<insert id="insertCity" parameterType="com.entities.City">
    insert into city
    <trim prefix="(" suffix=")" suffixOverrides=",">
        <if test="id != null">
            ID,
        if>
        <if test="name != null">
            Name,
        if>
        <if test="countrycode != null">
            CountryCode,
        if>
        <if test="district != null">
            District,
        if>
        <if test="population != null">
            Population,
        if>
    trim>
    <trim prefix="values (" suffix=")" suffixOverrides=",">
        <if test="id != null">
            #{id,jdbcType=INTEGER},
        if>
        <if test="name != null">
            #{name,jdbcType=CHAR},
        if>
        <if test="countrycode != null">
            #{countrycode,jdbcType=CHAR},
        if>
        <if test="district != null">
            #{district,jdbcType=CHAR},
        if>
        <if test="population != null">
            #{population,jdbcType=INTEGER},
        if>
    trim>
insert>
<delete id="deleteCityById" parameterType="java.lang.Integer">
    delete from city
    where ID = #{id,jdbcType=INTEGER}
delete>

<update id="updateCityById" parameterType="com.entities.City">
    UPDATE city set Name=#{name,jdbcType=CHAR},
    CountryCode=#{countrycode,jdbcType=CHAR},
    District=#{district,jdbcType=CHAR},
    Population=#{population,jdbcType=INTEGER}
    WHERE ID=#{id,jdbcType=INTEGER}
update>
    <select id="selectWithIf" parameterType="map" resultMap="BaseResultMap">
        SELECT * FROM city <if test="id!=0">WHERE city.id=#{id}if> <if test="id==0" >limit 2if>
    select>

    <select id="selectWithChoose" parameterType="map" resultMap="BaseResultMap">
        SELECT * FROM city
        <choose >
            <when test="id==1">
                limit 1
            when>
            <when test="id==2">
                limit 2
            when>
            <otherwise>
                WHERE city.id=#{id}
            otherwise>
        choose>
    select>
    <select id="selectWithForeach" parameterType="map" resultMap="BaseResultMap">
        SELECT * FROM city
            WHERE city.id in
        <foreach collection="ids" item="tmp" open="(" close=")" separator="," index="">
            #{tmp.id}
        foreach>
    select>
mapper>

在初始化spring框架的时候，会将在application.xml声明的bean注入到spring的上下文中。包括：
初始化dataSource,并将DataSource注入到spring框架中。
初始化SqlSessionFactoryBean对象，并将DataSource的实体对象注入到SqlSessionFactory中。
SqlSessionFactoryBean实现InitializingBean方法，在其实现的方法中，创建一个SqlSessionFactory对象，具体实现为DefaultSqlSessionFactory类，内部传入configuration对象。关于配置文件的主要解析过程就是在这里实现的。
下面来分析一下源码：

    @Override
    public void afterPropertiesSet() throws Exception {
        notNull(dataSource, "Property 'dataSource' is required");
        notNull(sqlSessionFactoryBuilder, "Property 'sqlSessionFactoryBuilder' is required");
        state((configuration == null && configLocation == null) || !(configuration != null && configLocation != null),
                "Property 'configuration' and 'configLocation' can not specified with together");
        //创建一个SqlSessionFactory对象，具体实现为DefaultSqlSessionFactor类
        this.sqlSessionFactory = buildSqlSessionFactory();
    }

    protected SqlSessionFactory buildSqlSessionFactory() throws IOException {

        Configuration configuration;
        //刚开始时，this.configuration为空，在测试中设置了mybatis的configuration的xml配置文件
        XMLConfigBuilder xmlConfigBuilder = null;
        if (this.configuration != null) {
            configuration = this.configuration;
            if (configuration.getVariables() == null) {
                configuration.setVariables(this.configurationProperties);
            } else if (this.configurationProperties != null) {
                configuration.getVariables().putAll(this.configurationProperties);
            }
        } else if (this.configLocation != null) {
            xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(), null, this.configurationProperties);
            //从XmlConfigBuilder中构建一个Configuration
            configuration = xmlConfigBuilder.getConfiguration();
        } else {
            LOGGER.debug(() -> "Property 'configuration' or 'configLocation' not specified, using default MyBatis Configuration");
            //直接新建一个Configuration对象
            configuration = new Configuration();
            if (this.configurationProperties != null) {
                configuration.setVariables(this.configurationProperties);
            }
        }

        if (this.objectFactory != null) {
            configuration.setObjectFactory(this.objectFactory);
        }

        if (this.objectWrapperFactory != null) {
            configuration.setObjectWrapperFactory(this.objectWrapperFactory);
        }

        if (this.vfs != null) {
            configuration.setVfsImpl(this.vfs);
        }

        //测试中设置了typeAliasesPackage
        if (hasLength(this.typeAliasesPackage)) {
            //根据，或者；对一条字符串进行分割，得到用来存放实体类的包名
            String[] typeAliasPackageArray = tokenizeToStringArray(this.typeAliasesPackage,
                    ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
            for (String packageToScan : typeAliasPackageArray) {
                //将对数据库记录封装的包名保存在Configuration对象中
                configuration.getTypeAliasRegistry().registerAliases(packageToScan,
                        typeAliasesSuperType == null ? Object.class : typeAliasesSuperType);
                LOGGER.debug(() -> "Scanned package: '" + packageToScan + "' for aliases");
            }
        }

        if (!isEmpty(this.typeAliases)) {
            for (Class typeAlias : this.typeAliases) {
                configuration.getTypeAliasRegistry().registerAlias(typeAlias);
                LOGGER.debug(() -> "Registered type alias: '" + typeAlias + "'");
            }
        }

        if (!isEmpty(this.plugins)) {
            for (Interceptor plugin : this.plugins) {
                //设置类一个log拦截器
                configuration.addInterceptor(plugin);
                LOGGER.debug(() -> "Registered plugin: '" + plugin + "'");
            }
        }

        if (hasLength(this.typeHandlersPackage)) {
            String[] typeHandlersPackageArray = tokenizeToStringArray(this.typeHandlersPackage,
                    ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
            for (String packageToScan : typeHandlersPackageArray) {
                configuration.getTypeHandlerRegistry().register(packageToScan);
                LOGGER.debug(() -> "Scanned package: '" + packageToScan + "' for type handlers");
            }
        }

        if (!isEmpty(this.typeHandlers)) {
            for (TypeHandler typeHandler : this.typeHandlers) {
                configuration.getTypeHandlerRegistry().register(typeHandler);
                LOGGER.debug(() -> "Registered type handler: '" + typeHandler + "'");
            }
        }

        //没有设置databaseId
        if (this.databaseIdProvider != null) {//fix #64 set databaseId before parse mapper xmls
            try {
                configuration.setDatabaseId(this.databaseIdProvider.getDatabaseId(this.dataSource));
            } catch (SQLException e) {
                throw new NestedIOException("Failed getting a databaseId", e);
            }
        }

        //测试中，没有使用缓存
        if (this.cache != null) {
            configuration.addCache(this.cache);
        }

        if (xmlConfigBuilder != null) {
            try {
                //开始解析configuration的xml配置文件
                //由于在测试的configuration配置文件中，只是定义了一个plugin，在解析的时候，直接解析出plugin的实现类，并将plugin的实体对象保存在configuration的实体对象中。
                xmlConfigBuilder.parse();
                LOGGER.debug(() -> "Parsed configuration file: '" + this.configLocation + "'");
            } catch (Exception ex) {
                throw new NestedIOException("Failed to parse config resource: " + this.configLocation, ex);
            } finally {
                ErrorContext.instance().reset();
            }
        }

        if (this.transactionFactory == null) {
            this.transactionFactory = new SpringManagedTransactionFactory();
        }

        configuration.setEnvironment(new Environment(this.environment, this.transactionFactory, this.dataSource));

        //从这里开始，处理mapper.xml文件
        if (!isEmpty(this.mapperLocations)) {
            for (Resource mapperLocation : this.mapperLocations) {
                if (mapperLocation == null) {
                    continue;
                }

                try {
                    //创建一个XMLMapperBuilder用来解析定义sql语句的xml文件
                    XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(),
                            configuration, mapperLocation.toString(), configuration.getSqlFragments());
                    //开始解析mapper.xml文件
                    xmlMapperBuilder.parse();
                } catch (Exception e) {
                    throw new NestedIOException("Failed to parse mapping resource: '" + mapperLocation + "'", e);
                } finally {
                    ErrorContext.instance().reset();
                }
                LOGGER.debug(() -> "Parsed mapper file: '" + mapperLocation + "'");
            }
        } else {
            LOGGER.debug(() -> "Property 'mapperLocations' was not specified or no matching resources found");
        }
        //返回一个SqlSessionFactory实体对象
        return this.sqlSessionFactoryBuilder.build(configuration);
    }

下面看看如何解析mapper.xml文件的：

    public void parse() {
        //判断当前mapper.xml文件是否已经被解析过
        if (!configuration.isResourceLoaded(resource)) {
            //在configurationElement完成mapper.xml中所有元素的解析，并将解析出来的相关属性全部保存在configuration中
            configurationElement(parser.evalNode("/mapper"));
            //添加已经加载过的mapper文件
            configuration.addLoadedResource(resource);
            //绑定sql语句与Java中定义的接口
            bindMapperForNamespace();
        }
        //这个几个方法都是将前面判断是不完整的语句再次解析一下，就不多说了
        parsePendingResultMaps();
        parsePendingCacheRefs();
        parsePendingStatements();
    }

    private void configurationElement(XNode context) {
        try {
            //namespace就是定义的接口：com.interfaces.CityMapper
            String namespace = context.getStringAttribute("namespace");
            if (namespace == null || namespace.equals("")) {
                throw new BuilderException("Mapper's namespace cannot be empty");
            }
            //想builderAssistant设置解析的文件对应的java接口
            builderAssistant.setCurrentNamespace(namespace);
            //解析出标签，测试中没有使用此标签
            cacheRefElement(context.evalNode("cache-ref"));
            //解析出标签，测试中没有使用此标签
            cacheElement(context.evalNode("cache"));
            //解析标签，这个标签官方已经不推荐使用了
            parameterMapElement(context.evalNodes("/mapper/parameterMap"));
            //解析标签
            resultMapElements(context.evalNodes("/mapper/resultMap"));
            //测试中没有使用此标签
            sqlElement(context.evalNodes("/mapper/sql"));
            //解析、、、标签
            buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
        } catch (Exception e) {
            throw new BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e);
        }
    }
接来下分析如何解析resultMap标签：
    //additionalResultMappings为一个空的list
    private ResultMap resultMapElement(XNode resultMapNode, List<ResultMapping> additionalResultMappings) throws Exception {
        ErrorContext.instance().activity("processing " + resultMapNode.getValueBasedIdentifier());
        //获取resultMap的id，也是这个resultMap的唯一名称
        String id = resultMapNode.getStringAttribute("id",
                resultMapNode.getValueBasedIdentifier());
        //指明这个resultMap用来与数据库中字段相映射的java类
        String type = resultMapNode.getStringAttribute("type",
                resultMapNode.getStringAttribute("ofType",
                        resultMapNode.getStringAttribute("resultType",
                                resultMapNode.getStringAttribute("javaType"))));
        //测试中没有使用这个属性，暂不分析
        String extend = resultMapNode.getStringAttribute("extends");
        //是否自动映射
        Boolean autoMapping = resultMapNode.getBooleanAttribute("autoMapping");
        //获取与数据库字段相映射的java类型
        Class typeClass = resolveClass(type);
        //没有使用标签
        Discriminator discriminator = null;
        List<ResultMapping> resultMappings = new ArrayList<ResultMapping>();
        resultMappings.addAll(additionalResultMappings);
        List<XNode> resultChildren = resultMapNode.getChildren();
        //开始解析子标签，现在每一个标签都表示一个映射字段与属性的映射关系
        for (XNode resultChild : resultChildren) {
            if ("constructor".equals(resultChild.getName())) {
                processConstructorElement(resultChild, typeClass, resultMappings);
            } else if ("discriminator".equals(resultChild.getName())) {
                discriminator = processDiscriminatorElement(resultChild, typeClass, resultMappings);
            } else {
                List<ResultFlag> flags = new ArrayList<ResultFlag>();
                if ("id".equals(resultChild.getName())) {
                    flags.add(ResultFlag.ID);
                }
                //解析标签
                resultMappings.add(buildResultMappingFromContext(resultChild, typeClass, flags));
            }
        }
        //构建一个resultMapResolver对象，这个里面什么实质性的操作，具体的操作还是有MapperBuilderAssistant完成
        ResultMapResolver resultMapResolver = new ResultMapResolver(builderAssistant, id, typeClass, extend, discriminator, resultMappings, autoMapping);
        try {
            //创建一个ResultMap，返回ResultMap对象并将ResultMap保存在Configuration对象中
            //在Configuration对象中存在一个ResultMaps，以resultMap中的id作为key用来存储resultMap实体对象
            return resultMapResolver.resolve();
        } catch (IncompleteElementException e) {
            configuration.addIncompleteResultMap(resultMapResolver);
            throw e;
        }
    }

    private ResultMapping buildResultMappingFromContext(XNode context, Class resultType, List<ResultFlag> flags) throws Exception {
        //解析出result标签中所有的属性，并将属性的值传入builderAssistant中，又builderAssistant创建一个ResultMapping对象。
        String property;
        if (flags.contains(ResultFlag.CONSTRUCTOR)) {
            property = context.getStringAttribute("name");
        } else {
            property = context.getStringAttribute("property");
        }
        String column = context.getStringAttribute("column");
        String javaType = context.getStringAttribute("javaType");
        String jdbcType = context.getStringAttribute("jdbcType");
        String nestedSelect = context.getStringAttribute("select");
        String nestedResultMap = context.getStringAttribute("resultMap",
                processNestedResultMappings(context, Collections.<ResultMapping>emptyList()));
        String notNullColumn = context.getStringAttribute("notNullColumn");
        String columnPrefix = context.getStringAttribute("columnPrefix");
        String typeHandler = context.getStringAttribute("typeHandler");
        String resultSet = context.getStringAttribute("resultSet");
        String foreignColumn = context.getStringAttribute("foreignColumn");
        boolean lazy = "lazy".equals(context.getStringAttribute("fetchType", configuration.isLazyLoadingEnabled() ? "lazy" : "eager"));
        Class javaTypeClass = resolveClass(javaType);
        @SuppressWarnings("unchecked")
        Class extends TypeHandler> typeHandlerClass = (Class extends TypeHandler>) resolveClass(typeHandler);
        JdbcType jdbcTypeEnum = resolveJdbcType(jdbcType);
        //返回一个包含所有属性信息的resultMapping对象
        return builderAssistant.buildResultMapping(resultType, property, column, javaTypeClass, jdbcTypeEnum, nestedSelect, nestedResultMap, notNullColumn, columnPrefix, typeHandlerClass, flags, resultSet, foreignColumn, lazy);
    }
接下来看看如何解析具体的select语句：
    //在测试中传入的requiredDatabaseId为null
    private void buildStatementFromContext(List list, String requiredDatabaseId) {
        for (XNode context : list) {
            final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
            try {
                //开始解析sql语句的Satatement
                statementParser.parseStatementNode();
            } catch (IncompleteElementException e) {
                configuration.addIncompleteStatement(statementParser);
            }
        }
    }

    public void parseStatementNode() {
        //获取id，也是在java接口中的方法名
        String id = context.getStringAttribute("id");
        String databaseId = context.getStringAttribute("databaseId");
        if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {
          return;
        }
        //一次返回记录条数
        Integer fetchSize = context.getIntAttribute("fetchSize");
        //超时时间
        Integer timeout = context.getIntAttribute("timeout");
        String parameterMap = context.getStringAttribute("parameterMap");
        String parameterType = context.getStringAttribute("parameterType");
        Class parameterTypeClass = resolveClass(parameterType);
        //获取结果映射关系
        String resultMap = context.getStringAttribute("resultMap");
        String resultType = context.getStringAttribute("resultType");
        String lang = context.getStringAttribute("lang");
        LanguageDriver langDriver = getLanguageDriver(lang);

        Class resultTypeClass = resolveClass(resultType);
        String resultSetType = context.getStringAttribute("resultSetType");
        //没有指定的情况下，statementType默认为StatementType.PREPARED
        StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
        ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);
        //获取标签名称
        String nodeName = context.getNode().getNodeName();
        //分析出sql的命令
        SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));
        boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
        boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);
        boolean useCache = context.getBooleanAttribute("useCache", isSelect);
        boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false);

        // Include Fragments before parsing
        //解析sql语句中的include标签
        XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
        includeParser.applyIncludes(context.getNode());

        // Parse selectKey after includes and remove them.
        processSelectKeyNodes(id, parameterTypeClass, langDriver);

        // Parse the SQL (pre:  and  were parsed and removed)
        SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
        String resultSets = context.getStringAttribute("resultSets");
        String keyProperty = context.getStringAttribute("keyProperty");
        String keyColumn = context.getStringAttribute("keyColumn");
        KeyGenerator keyGenerator;
        //生成statementId
        String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX;
        keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true);
        if (configuration.hasKeyGenerator(keyStatementId)) {
          keyGenerator = configuration.getKeyGenerator(keyStatementId);
        } else {
          keyGenerator = context.getBooleanAttribute("useGeneratedKeys",
              configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType))
              ? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
        }

        builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
            fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
            resultSetTypeEnum, flushCache, useCache, resultOrdered, 
            keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
    }
开始构建MappedStatement：
  public MappedStatement addMappedStatement(
      String id,
      SqlSource sqlSource,
      StatementType statementType,
      SqlCommandType sqlCommandType,
      Integer fetchSize,
      Integer timeout,
      String parameterMap,
      Class parameterType,
      String resultMap,
      Class resultType,
      ResultSetType resultSetType,
      boolean flushCache,
      boolean useCache,
      boolean resultOrdered,
      KeyGenerator keyGenerator,
      String keyProperty,
      String keyColumn,
      String databaseId,
      LanguageDriver lang,
      String resultSets) {

    if (unresolvedCacheRef) {
      throw new IncompleteElementException("Cache-ref not yet resolved");
    }

    id = applyCurrentNamespace(id, false);
    //判断是否是select命令，只有这个命令才会用到resultMap或者resultType这个属性
    boolean isSelect = sqlCommandType == SqlCommandType.SELECT;

    MappedStatement.Builder statementBuilder = new MappedStatement.Builder(configuration, id, sqlSource, sqlCommandType)
        .resource(resource)
        .fetchSize(fetchSize)
        .timeout(timeout)
        .statementType(statementType)
        .keyGenerator(keyGenerator)
        .keyProperty(keyProperty)
        .keyColumn(keyColumn)
        .databaseId(databaseId)
        .lang(lang)
        .resultOrdered(resultOrdered)
        .resultSets(resultSets)
        .resultMaps(getStatementResultMaps(resultMap, resultType, id))
        .resultSetType(resultSetType)
        .flushCacheRequired(valueOrDefault(flushCache, !isSelect))
        .useCache(valueOrDefault(useCache, isSelect))
        .cache(currentCache);

    ParameterMap statementParameterMap = getStatementParameterMap(parameterMap, parameterType, id);
    if (statementParameterMap != null) {
      //将ParameterMap设置到StatementBuilder中，这样在创建Mapped的时候就可以包含ParameterMap的值了
      statementBuilder.parameterMap(statementParameterMap);
    }

    MappedStatement statement = statementBuilder.build();
    //将创建好的Statement保存在Configuration对象中mappedStatements集合中，以statement的id为key进行存储
    configuration.addMappedStatement(statement);
    return statement;
  }
代码中都添加了注释，应该还算是比较容易看的，就不多说了！！！！ 
 到这里基本上就完成了初始的工作了，剩下的就是根据在java中声明的接口生成动态代理了。在实际使用接口的时候，实际是调用的是根据接口动态生成的代理对象。相关的内容在以后的博客中说吧！















 















你可能感兴趣的:(mybaits)



MyBatis 一级缓存原理
程序猿进阶
MyBatis&MyBatisPlusmybatis缓存java职场和发展面试系统架构数据库
优质博文：IT-BLOG-CN一、一级缓存配置MyBatis一级缓存默认是开启的。如果需要显示的开启，需要在MyBaits配置文件中标签中添加如下语句：value共有两个选项，SESSION或者STATEMENT，默认是SESSION级别，即在一个MyBatis会话中执行的所有语句，都会共享这一个缓存。一种是STATEMENT级别，可以理解为缓存只对当前执行的这一个Statement有效。一级缓存

MyBatis系列（六）——MyBatis的注解开发
moutory
前言在前面的系列文章中，我们已经知道了使用MyBatis作为持久层框架，通过xml配置文件操作数据进行开发的步骤。不过使用xml配置文件略微有些繁琐，在开发中我们可能还会使用注解来替代mapper映射文件的书写。熟悉MyBaits常用的注解使用，对于工作中阅读别人代码或者自己写代码时会有不错的帮助。本篇文章中将对MyBaits的常见注解使用进行介绍，主要分为单表和多表操作，也希望可以给各位读者一个

MyBatis系列（二）——MyBatis的动态代理和映射文件动态配置
moutory
前言我们在上一篇文章中讲了MyBatis的入门操作，但在入门操作篇中MyBatis在使用上还是有着一定的不便和冗余，本篇文章将对MyBatis的动态代理和如何在映射文件中编写动态sql进行讲解，希望对各位读者有所帮助。想要了解更多MyBaits系列文章，可以从下面的传送门阅读：MyBatis系列（一）——MyBatis的介绍和CRUD一、MyBatis的动态代理（一）回顾传统的实现mapper接口

java 进销存 销售报表 库存管理 商户管理 springmvc SSM crm 项目
非得起个昵称
系统介绍：1.系统采用主流的SSM框架jspJSTLbootstraphtml5(PC浏览器使用)2.springmvc+spring4.3.7+mybaits3.3SSM普通javaweb（非maven,附赠pom.xml文件）数据库：mysql3.开发工具：myeclipseeclipseidea均可,没有限制.我这边myeclipse2014导出来的项目源码-----------------

基于小程序的校园二手交易平台+springboot+vue.js附带文章和源代码设计说明文档ppt
微实coding
#微信小程序项目精品案例小程序springbootvue.js后端微信小程序
文章目录前言详细视频演示具体实现截图技术栈后端框架SpringBoot前端框架Vue持久层框架MyBaits系统测试系统测试目的系统功能测试系统测试结论为什么选择我代码参考数据库参考源码获取前言博主介绍：✌CSDN特邀作者、985计算机专业毕业、某互联网大厂高级全栈开发程序员、码云/掘金/华为云/阿里云/InfoQ/StackOverflow/github等平台优质作者、专注于Java、小程序、前

基于小程序的电子购物系统+springboot+vue.js附带文章和源代码设计说明文档ppt
微实coding
#微信小程序项目精品案例小程序springbootvue.js后端微信小程序
文章目录前言详细视频演示具体实现截图技术栈后端框架SpringBoot前端框架Vue持久层框架MyBaits系统测试系统测试目的系统功能测试系统测试结论为什么选择我代码参考数据库参考源码获取前言博主介绍：✌CSDN特邀作者、985计算机专业毕业、某互联网大厂高级全栈开发程序员、码云/掘金/华为云/阿里云/InfoQ/StackOverflow/github等平台优质作者、专注于Java、小程序、前

基于Java的中国共产党网站的设计与实现(源码+lw+部署文档+讲解等)
小蔡coding
#Java精选毕设java开发语言ssmvue.js
文章目录前言详细视频演示具体实现截图技术栈后端框架SpringBoot前端框架Vue持久层框架MyBaitsPlus系统测试系统测试目的系统功能测试系统测试结论为什么选择我自己的网站自己的小程序（小蔡coding）代码参考数据库参考源码获取前言博主介绍：✌全网粉丝10W+,CSDN特邀作者、博客专家、CSDN新星计划导师、全栈领域优质创作者，博客之星、掘金/华为云/阿里云/InfoQ等平台优质作者

基于SpringBoot+Vue的网上点餐系统附带文章和源代码
微实coding
springbootvue.js后端javaspringboot
文章目录前言详细视频演示具体实现截图技术栈后端框架SpringBoot前端框架Vue持久层框架MyBaitsPlus系统测试系统测试目的系统功能测试系统测试结论为什么选择我代码参考数据库参考源码获取前言博主介绍：✌全网粉丝25W+,CSDN特邀作者、985计算机专业毕业、某互联网大厂高级全栈开发程序员、码云/掘金/华为云/阿里云/InfoQ/StackOverflow/github等平台优质作者、

MyBatis篇----第一篇
数据大魔王
java面试题套2mybatistomcatjava
系列文章目录文章目录系列文章目录前言一、什么是Mybatis？二、Mybaits的优点三、MyBatis框架的缺点前言前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站，这篇文章男女通用，看懂了就去分享给你的码吧。一、什么是Mybatis？1、Mybatis是一个半ORM（对象关系映射）框架，它内部封装了JDBC，开发时只需要关注SQL语句本身，不需要

mybaitis基础---原生调用的2种方式
延歌_
https://mybatis.org/mybatis-3/zh/getting-started.html----中文网站mybatis原生调用的2种方式底层原理：mybatis本质是对JDBC的封装封装了一个会话slqsession对数据连接并定义了增删改查的方法mybaits有2个配置文件配置文件mybatis-config.xml全局映射器*Mapper.xml映射器1、通过session.

基于SpringBoot+Vue的个人理财系统附带文章和源代码
微实coding
#Java精品实战案例springbootvue.js后端javaspring
文章目录前言详细视频演示具体实现截图技术栈后端框架SpringBoot前端框架Vue持久层框架MyBaits系统测试系统测试目的系统功能测试系统测试结论为什么选择我代码参考数据库参考源码获取前言博主介绍：✌CSDN特邀作者、985计算机专业毕业、某互联网大厂高级全栈开发程序员、码云/掘金/华为云/阿里云/InfoQ/StackOverflow/github等平台优质作者、专注于Java、小程序、前

基于Java的校园二手交易平台的设计与实现(源码+lw+部署文档+讲解等)
小蔡coding
#Java精选毕设java开发语言ssmvue.js
文章目录前言详细视频演示具体实现截图技术栈后端框架SpringBoot前端框架Vue持久层框架MyBaitsPlus系统测试系统测试目的系统功能测试系统测试结论为什么选择我自己的网站自己的小程序（小蔡coding）代码参考数据库参考源码获取前言博主介绍：✌全网粉丝10W+,CSDN特邀作者、博客专家、CSDN新星计划导师、全栈领域优质创作者，博客之星、掘金/华为云/阿里云/InfoQ等平台优质作者

基于Java的健身房会员管理系统的设计与实现(源码+lw+部署文档+讲解等)
小蔡coding
#Java精选毕设java开发语言ssmvue.js
文章目录前言详细视频演示具体实现截图技术栈后端框架SpringBoot前端框架Vue持久层框架MyBaitsPlus系统测试系统测试目的系统功能测试系统测试结论为什么选择我自己的网站自己的小程序（小蔡coding）代码参考数据库参考源码获取前言博主介绍：✌全网粉丝10W+,CSDN特邀作者、博客专家、CSDN新星计划导师、全栈领域优质创作者，博客之星、掘金/华为云/阿里云/InfoQ等平台优质作者

基于SpringBoot+Vue的酒店客房管理系统附带文章和源代码
微实coding
springbootvue.js后端javaspring
文章目录前言详细视频演示具体实现截图技术栈后端框架SpringBoot前端框架Vue持久层框架MyBaits系统测试系统测试目的系统功能测试系统测试结论为什么选择我代码参考数据库参考源码获取前言博主介绍：✌CSDN特邀作者、985计算机专业毕业、某互联网大厂高级全栈开发程序员、码云/掘金/华为云/阿里云/InfoQ/StackOverflow/github等平台优质作者、专注于Java、小程序、前

Spring +Mybaits+Spring Boot+Spring Cloud
奈斯。-
workspringjava后端
Spring组件：SpringCore：核心类库，提供IOC服务；SpringContext：提供框架式的Bean访问方式，以及企业级功能（JNDI、定时任务等）；SpringAOP：AOP服务；SpringDAO：对JDBC的抽象，简化了数据访问异常的处理；SpringORM：对现有的ORM框架的支持；SpringWeb：提供了基本的面向web的总和特性，例如多方文件上传；SpringMVC：提

【springboot网上点餐系统毕业】
Bigcoding
#JAVA精选毕设springbootnotepad++后端
文章目录前言详细视频演示具体实现截图技术栈后端框架SpringBoot前端框架Vue持久层框架MyBaitsPlus系统测试系统测试目的系统功能测试系统测试结论为什么选择我代码参考数据库参考源码获取前言博主介绍：✌全网粉丝15W+,CSDN特邀作者、211毕业、高级全栈开发程序员、大厂多年工作经验、码云/掘金/华为云/阿里云/InfoQ/StackOverflow/github等平台优质作者、专注

【springboot教师工作量管理系统】
Bigcoding
#JAVA精选毕设springbootnotepad++后端
文章目录前言详细视频演示具体实现截图技术栈后端框架SpringBoot前端框架Vue持久层框架MyBaitsPlus系统测试系统测试目的系统功能测试系统测试结论为什么选择我代码参考数据库参考源码获取前言博主介绍：✌全网粉丝15W+,CSDN特邀作者、211毕业、高级全栈开发程序员、大厂多年工作经验、码云/掘金/华为云/阿里云/InfoQ/StackOverflow/github等平台优质作者、专注

【基于SpringBoot的在线文档管理系统】
Bigcoding
#JAVA精选毕设springbootnotepad++后端
文章目录前言详细视频演示具体实现截图技术栈后端框架SpringBoot前端框架Vue持久层框架MyBaitsPlus系统测试系统测试目的系统功能测试系统测试结论为什么选择我代码参考数据库参考源码获取前言博主介绍：✌全网粉丝15W+,CSDN特邀作者、211毕业、高级全栈开发程序员、大厂多年工作经验、码云/掘金/华为云/阿里云/InfoQ/StackOverflow/github等平台优质作者、专注

通过mybatis-plus-join 实现mybatis plus联表查询
面壁者-扬
mybatis
1、引包com.github.yulichangmybatis-plus-join-boot-starter1.4.10com.baomidoumybatis-plus-boot-starter3.4.02、mapper处理：把mybaitsplus的BaseMapper改成MPJBaseMapper@MapperpublicinterfaceScaleMapperextendsMPJBaseMa

Intellij IDEA中Mybatis Mapper自动注入警告的6种解决方案
Java_苏先生
点关注，不迷路；持续更新Java架构相关技术及资讯热文！！！相信使用Mybaits的小伙伴们一定会经常编写类似如下的代码：可以看到userMapper下有个红色警告。虽然代码本身并没有问题，能正常运行，但有个警告总归有点恶心。本文分析原因，并列出解决该警告的几种方案。原因众所周知，IDEA是非常智能的，它可以理解Spring的上下文。然而UserMapper这个接口是Mybatis的，IDEA理解

Springboot整合Spring-security
李白爱耍酷
springjava
Springboot整合spring-security1.创建springboot项目2.引入相关依赖。spring-boot-starter-securitymysql-connector-javapersistence-api（mybaits注解支持）spring-security-corespring-boot-starter-thymeleaf//springboot对thymeleaf的

MyBatis--03-- 一级缓存和二级缓存
知行合一。。。
Spring基础知识--SSMmybatis缓存spring
什么叫缓存将数据存放在程序内存中，用于减轻数据查询的压力，提升读取数据的速度，提高性能。对于任何一个持久层框架，都有缓存机制；缓存在电脑中有一块真实的存储空间Mybatis缓存mybaits提供一级缓存，和二级缓存。一级缓存（本地缓存）sqlSession级别的缓存。（相当于一个方法内的缓存）二级缓存（全局缓存）基于namespace名称空间级别的缓存.即一个mapper.xml对应一个缓存一级缓

【springboot学生读书笔记共享平台设计毕业项目】
Bigcoding
#JAVA精选毕设springbootnotepad++后端
文章目录前言详细视频演示具体实现截图技术栈后端框架SpringBoot前端框架Vue持久层框架MyBaitsPlus系统测试系统测试目的系统功能测试系统测试结论为什么选择我代码参考数据库参考源码获取前言博主介绍：✌全网粉丝15W+,CSDN特邀作者、211毕业、高级全栈开发程序员、大厂多年工作经验、码云/掘金/华为云/阿里云/InfoQ/StackOverflow/github等平台优质作者、专注

【springboot母婴商城系统毕业项目】
Bigcoding
#JAVA精选毕设springbootnotepad++后端
文章目录前言详细视频演示具体实现截图技术栈后端框架SpringBoot前端框架Vue持久层框架MyBaitsPlus系统测试系统测试目的系统功能测试系统测试结论为什么选择我代码参考数据库参考源码获取前言博主介绍：✌全网粉丝15W+,CSDN特邀作者、211毕业、高级全栈开发程序员、大厂多年工作经验、码云/掘金/华为云/阿里云/InfoQ/StackOverflow/github等平台优质作者、专注

【基于springboot的社区团购系统设计毕业项目】
Bigcoding
#JAVA精选毕设springbootnotepad++后端
文章目录前言详细视频演示具体实现截图技术栈后端框架SpringBoot前端框架Vue持久层框架MyBaitsPlus系统测试系统测试目的系统功能测试系统测试结论为什么选择我代码参考数据库参考源码获取前言博主介绍：✌全网粉丝15W+,CSDN特邀作者、211毕业、高级全栈开发程序员、大厂多年工作经验、码云/掘金/华为云/阿里云/InfoQ/StackOverflow/github等平台优质作者、专注

Java 商户管理系统 客户管理 库存管理 销售报表 SSM项目源码
IT祖师爷
统介绍：1.系统采用主流的SSM框架jspJSTLbootstraphtml5(PC浏览器使用)2.springmvc+spring4.3.7+mybaits3.3SSM普通javaweb（非maven,附赠pom.xml文件）数据库：mysql3.开发工具：myeclipseeclipseidea均可,没有限制.我这边myeclipse2014导出来的项目源码------------------

基于SpringBoot实现的社区疫情管理系统
星尘库
数据库javaspringboot后端java
基于SpringBoot实现的社区疫情管理系统前端采用了Vue+BootStrap技术进行开发,数据库为中小型企业常用的mysql数据库，后台技术采用SpringBoot+Mybaits+Spring技术框架由于老师叫我做的是居民隔离时的物资发放，然后由社区管理者发放物资，居民接收所以第六个功能就特别重要。一、社区用户功能：每日健康上报功能描述每天必须上报否则发送提醒如图1所示：相对应管理员功能：

IDEA插件mybatis log plugin下载与使用
道利义
idea插件开发工具
1、下载https://github.com/Link-Kou/intellij-mybaitslog下载成功后记得解压![!](https://img-blog.csdnimg.cn/20210423204600278.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9

mybatis-plus常用使用方法
胆小如鼠
mybatis
**mybaits-plus常用使用方法**常用三层分别继承方法1.1mapper层（接口定义层）可以用BaseMappercolumnMap);//根据map定义字段的条件删除intdelete(@Param(Constants.WRAPPER)Wrapperwrapper);//根据实体类定义的条件删除对象intdeleteBatchIds(@Param(Constants.COLLECTIO

java 进销存 销售报表 库存管理 商户管理 springmvc SSM crm 项目
夏雄111
系统介绍：1.系统采用主流的SSM框架jspJSTLbootstraphtml5(PC浏览器使用)2.springmvc+spring4.3.7+mybaits3.3SSM普通javaweb（非maven,附赠pom.xml文件）数据库：mysql3.开发工具：myeclipseeclipseidea均可,没有限制.我这边myeclipse2014导出来的项目源码-----------------

Algorithm
香水浓
javaAlgorithm
冒泡排序
public static void sort(Integer[] param) {
for (int i = param.length - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
int current = param[j];
int next = param[j + 1];

mongoDB 复杂查询表达式
开窍的石头
mongodb
1:count
   Pg: db.user.find().count();
   统计多少条数据
2:不等于$ne
   Pg: db.user.find({_id:{$ne:3}},{name:1,sex:1,_id:0});
   查询id不等于3的数据。
3：大于$gt $gte(大于等于)
&n

Jboss Java heap space异常解决方法, jboss OutOfMemoryError : PermGen space
0624chenhong
jvmjboss
转自
http://blog.csdn.net/zou274/article/details/5552630
解决办法：
window->preferences->java->installed jres->edit jre
把default vm arguments 的参数设为-Xms64m -Xmx512m
----------------

文件上传 下载 解析 相对路径
不懂事的小屁孩
文件上传
有点坑吧，弄这么一个简单的东西弄了一天多，身边还有大神指导着，网上各种百度着。
下面总结一下遇到的问题：
文件上传，在页面上传的时候，不要想着去操作绝对路径，浏览器会对客户端的信息进行保护，避免用户信息收到攻击。
在上传图片，或者文件时，使用form表单来操作。
前台通过form表单传输一个流到后台，而不是ajax传递参数到后台，代码如下:
<form action=&

怎么实现qq空间批量点赞
换个号韩国红果果
qq
纯粹为了好玩！！
逻辑很简单
1 打开浏览器console；输入以下代码。
先上添加赞的代码
var tools={};
//添加所有赞
function init(){
document.body.scrollTop=10000;
setTimeout(function(){document.body.scrollTop=0;},2000);//加

判断是否为中文
灵静志远
中文
方法一：
public class Zhidao {
public static void main(String args[]) {
String s = "sdf灭礌 kjl d{';\fdsjlk是";
int n=0;
for(int i=0; i<s.length(); i++) {
n = (int)s.charAt(i);
if((

一个电话面试后总结
a-john
面试
今天，接了一个电话面试，对于还是初学者的我来说，紧张了半天。
面试的问题分了层次，对于一类问题，由简到难。自己觉得回答不好的地方作了一下总结：
 
在谈到集合类的时候，举几个常用的集合类，想都没想，直接说了list,map。
 
然后对list和map分别举几个类型：
 
list方面：ArrayList,LinkedList。在谈到他们的区别时，愣住了

MSSQL中Escape转义的使用
aijuans
MSSQL
IF OBJECT_ID('tempdb..#ABC') is not null
drop table tempdb..#ABC
create table #ABC
(
PATHNAME NVARCHAR(50)
)
insert into #ABC
SELECT N'/ABCDEFGHI'
UNION ALL SELECT N'/ABCDGAFGASASSDFA'
UNION ALL

一个简单的存储过程
asialee
mysql存储过程构造数据批量插入
           今天要批量的生成一批测试数据，其中中间有部分数据是变化的，本来想写个程序来生成的，后来想到存储过程就可以搞定，所以随手写了一个，记录在此：
 
        
DELIMITER $$
DROP PROCEDURE IF EXISTS inse

annot convert from HomeFragment_1 to Fragment
百合不是茶
android导包错误
创建了几个类继承Fragment, 需要将创建的类存储在ArrayList<Fragment>中; 出现不能将new 出来的对象放到队列中,原因很简单;
    创建类时引入包是:import android.app.Fragment;
 
   创建队列和对象时使用的包是:import android.support.v4.ap

Weblogic10两种修改端口的方法
bijian1013
weblogic端口号配置管理config.xml
一.进入控制台进行修改    1.进入控制台:  http://127.0.0.1:7001/console     2.展开左边树菜单         域结构->环境->服务器-->点击AdminServer(管理) &

mysql 操作指令
征客丶
mysql
一、连接mysql
进入 mysql 的安装目录；
$ bin/mysql -p [host IP 如果是登录本地的mysql 可以不写 -p 直接 -u] -u [userName] -p
输入密码，回车，接连；
二、权限操作［如果你很了解mysql数据库后，你可以直接去修改系统表，然后用 mysql> flush privileges; 指令让权限生效］
1、赋权
mys

【Hive一】Hive入门
bit1129
hive
Hive安装与配置
Hive的运行需要依赖于Hadoop，因此需要首先安装Hadoop2.5.2，并且Hive的启动前需要首先启动Hadoop。
  Hive安装和配置的步骤
 
1. 从如下地址下载Hive0.14.0
 
http://mirror.bit.edu.cn/apache/hive/
 
 2.解压hive，在系统变

ajax 三种提交请求的方法
BlueSkator
Ajaxjqery
1、ajax 提交请求
$.ajax({
type:"post",
url : "${ctx}/front/Hotel/getAllHotelByAjax.do",
dataType : "json",
success : function(result) {
try {
for(v

mongodb开发环境下的搭建入门
braveCS
运维
 
linux下安装mongodb
1）官网下载mongodb-linux-x86_64-rhel62-3.0.4.gz
2）linux 解压 
gzip -d mongodb-linux-x86_64-rhel62-3.0.4.gz;
mv mongodb-linux-x86_64-rhel62-3.0.4 mongodb-linux-x86_64-rhel62-

编程之美-最短摘要的生成
bylijinnan
java数据结构算法编程之美

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
public class ShortestAbstract {
/**
* 编程之美 最短摘要的生成
* 扫描过程始终保持一个[pBegin,pEnd]的range,初始化确保[pBegin,pEnd]的ran

json数据解析及typeof
chengxuyuancsdn
jstypeofjson解析

// json格式
var people='{"authors": [{"firstName": "AAA","lastName": "BBB"},'
+' {"firstName": "CCC&

流程系统设计的层次和目标
comsci
设计模式数据结构sql框架脚本

                              流程系统设计的层次和目标
 

RMAN List和report 命令
daizj
oraclelistreportrman
LIST 命令
使用RMAN LIST 命令显示有关资料档案库中记录的备份集、代理副本和映像副本的
信息。使用此命令可列出：
• RMAN 资料档案库中状态不是AVAILABLE 的备份和副本
• 可用的且可以用于还原操作的数据文件备份和副本
• 备份集和副本，其中包含指定数据文件列表或指定表空间的备份
• 包含指定名称或范围的所有归档日志备份的备份集和副本
• 由标记、完成时间、可

二叉树:红黑树
dieslrae
二叉树
    红黑树是一种自平衡的二叉树,它的查找,插入,删除操作时间复杂度皆为O(logN),不会出现普通二叉搜索树在最差情况时时间复杂度会变为O(N)的问题.
    红黑树必须遵循红黑规则,规则如下
   
1、每个节点不是红就是黑。     2、根总是黑的  &

C语言homework3，7个小题目的代码
dcj3sjt126com
c
1、打印100以内的所有奇数。
# include <stdio.h>
int main(void)
{
int i;
for (i=1; i<=100; i++)
{
if (i%2 != 0)
printf("%d ", i);
}
return 0;
}
 2、从键盘上输入10个整数，

自定义按钮, 图片在上, 文字在下, 居中显示
dcj3sjt126com
自定义
#import <UIKit/UIKit.h>
@interface MyButton : UIButton
-(void)setFrame:(CGRect)frame ImageName:(NSString*)imageName Target:(id)target Action:(SEL)action Title:(NSString*)title Font:(CGFloa

MySQL查询语句练习题，测试足够用了
flyvszhb
sqlmysql
http://blog.sina.com.cn/s/blog_767d65530101861c.html
1.创建student和score表
CREATE  TABLE  student (
id  INT(10)  NOT NULL  UNIQUE  PRIMARY KEY  ,
name  VARCHAR

转：MyBatis Generator 详解
happyqing
mybatis
 
MyBatis Generator 详解
http://blog.csdn.net/isea533/article/details/42102297
 
MyBatis Generator详解
http://git.oschina.net/free/Mybatis_Utils/blob/master/MybatisGeneator/MybatisGeneator.

让程序员少走弯路的14个忠告
jingjing0907
工作计划学习
 
无论是谁，在刚进入某个领域之时，有再大的雄心壮志也敌不过眼前的迷茫：不知道应该怎么做，不知道应该做什么。下面是一名软件开发人员所学到的经验，希望能对大家有所帮助
 
1.不要害怕在工作中学习。
只要有电脑，就可以通过电子阅读器阅读报纸和大多数书籍。如果你只是做好自己的本职工作以及分配的任务，那是学不到很多东西的。如果你盲目地要求更多的工作，也是不可能提升自己的。放

nginx和NetScaler区别
流浪鱼
nginx
NetScaler是一个完整的包含操作系统和应用交付功能的产品，Nginx并不包含操作系统，在处理连接方面，需要依赖于操作系统，所以在并发连接数方面和防DoS攻击方面，Nginx不具备优势。
2.易用性方面差别也比较大。Nginx对管理员的水平要求比较高，参数比较多，不确定性给运营带来隐患。在NetScaler常见的配置如健康检查，HA等，在Nginx上的配置的实现相对复杂。
3.策略灵活度方

第11章 动画效果（下）
onestopweb
动画
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/

FAQ - SAP BW BO roadmap
blueoxygen
BOBW
http://www.sdn.sap.com/irj/boc/business-objects-for-sap-faq
 
Besides, I care that how to integrate tightly.
 
By the way, for BW consultants, please just focus on Query Designer which i

关于java堆内存溢出的几种情况
tomcat_oracle
javajvmjdkthread
【情况一】： 　　
java.lang.OutOfMemoryError: Java heap space：这种是java堆内存不够，一个原因是真不够，另一个原因是程序中有死循环； 　　如果是java堆内存不够的话，可以通过调整JVM下面的配置来解决： 　　<jvm-arg>-Xms3062m</jvm-arg> 　　<jvm-arg>-Xmx

Manifest.permission_group权限组
阿尔萨斯
Permission
结构
继承关系
public static final class Manifest.permission_group extends Object
java.lang.Object
android. Manifest.permission_group 常量
ACCOUNTS 直接通过统计管理器访问管理的统计
COST_MONEY可以用来让用户花钱但不需要通过与他们直接牵涉的权限
D








按字母分类：
ABCDEFGHIJKLMNOPQRSTUVWXYZ其他






首页 -
关于我们 -
站内搜索 -
Sitemap -
侵权投诉

版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.