删除MongDb相关代码，删除多余的配置文件。

ipu-nacos-demo/src/main/resources/dev/application.properties

@@ -31,7 +31,7 @@ nacos.config.server-addr=47.105.160.21:8800
#nacos.config.ext-config[1].group=DEFAULT_GROUP
#nacos.config.ext-config[1].refresh=true
#老版本配置，方法一------------------------------------------------------
#老版本配置，方法二------------------------------------------------------
#nacos.config.shared-dataids=data1, data2
#nacos.config.refreshable-dataids=data1, data2
# 主配置 group-id

ipu-rest-scaffold/src/main/java/com/ai/ipu/server/control/MongoDbController.java

@@ -1,123 +0,0 @@
package com.ai.ipu.server.control;
import com.ai.ipu.basic.util.IpuException;
import com.ai.ipu.basic.util.IpuUtility;
import com.ai.ipu.data.JMap;
import com.ai.ipu.data.impl.JsonMap;
import com.ai.ipu.server.service.MongoDbService;
import com.ai.ipu.server.util.RestScaffoldConstant;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
/**
 * @author miaozy@asiainfo.com
 * @desc mongodb使用范例
 */
@Controller
@RequestMapping("/mongodb")
public class MongoDbController {
    @Autowired
    MongoDbService MongoDbService;
    private String connName = "data";
    private String dbName = "test";
    
    @ResponseBody
    @RequestMapping("/selectUser")
    public JMap executeSelect(JMap params) throws Exception {
        JMap retMap = new JsonMap();
        params.put("connName", connName);
        params.put("dbName", dbName);
        if (!params.containsKey("condParam"))
        	params.put("condParam", "{\"name\": \"tom\"}");
        
        try {
        	//单独做查询时，不涉及事务控制，因此service的方法名命名就可以不遵照process开头。
            retMap.put("resultList", MongoDbService.executeSelect(params));
        } catch (IpuException ie) {
        	IpuUtility.error(ie.getMessage());
        } catch (Exception e) {
            IpuUtility.errorCode(RestScaffoldConstant.SERVER_004);
        }
        return retMap;
    }
    @ResponseBody
    @RequestMapping("/insertUser")
    public JMap executeInsert(JMap params) throws Exception {
        JMap retMap = new JsonMap();
        params.put("connName", connName);
        params.put("dbName", dbName);
        if (!params.containsKey("operType"))
        	params.put("operType", "insertUser");
        
        try {
        	/* 涉及事务控制，因此service的方法名命名就要遵照process开头。
        	 * 一个process开头的方法里，所有对mongodb的增删改都是一个事务
        	 * 如果需要支持多事务，有2种解决方案：
        	 * 1、不同的事务使用不同的service方法；参见processInsertUser和processInsertLog
        	 * 2、在一个service方法里，直接声明独立事务。参见processInsertUserAndLog
        	*/
            MongoDbService.processInsertUserAndLog(params);
            retMap.put("result", "插入一条用户记录成功");
        } catch (IpuException ie) {
        	IpuUtility.error(ie.getMessage());
        } catch (Exception e) {
            IpuUtility.errorCode(RestScaffoldConstant.SERVER_005);
        }
        return retMap;
    }
    @ResponseBody
    @RequestMapping("/updateUser")
    public JMap executeUpdate(JMap params) throws Exception {
        JMap retMap = new JsonMap();
        params.put("connName", connName);
        params.put("dbName", dbName);
        if (!params.containsKey("operType"))
        	params.put("operType", "updateUser");
        if (!params.containsKey("condParam"))
        	params.put("condParam", "{\"name\": \"tom\"}");
        
        try {
            try {
            	MongoDbService.processInsertLog(params);
            }catch (Exception e1) {}
            MongoDbService.processUpdateUser(params);
            retMap.put("result", "更改用户记录成功");
        } catch (IpuException ie) {
        	IpuUtility.error(ie.getMessage());
        } catch (Exception e) {
            IpuUtility.errorCode(RestScaffoldConstant.SERVER_006);
        }
        return retMap;
    }
    @ResponseBody
    @RequestMapping("/deleteUser")
    public JMap executeDelete(JMap params) throws Exception {
        JMap retMap = new JsonMap();
        params.put("connName", connName);
        params.put("dbName", dbName);
        if (!params.containsKey("operType"))
        	params.put("operType", "deleteUser");
        if (!params.containsKey("condParam"))
        	params.put("condParam", "{\"name\": \"tom\"}");
        
        try {
        	try {
            	MongoDbService.processInsertLog(params);
            }catch (Exception e1) {}
            MongoDbService.processDeleteUser(params);
            retMap.put("result", "删除用户记录成功");
        } catch (IpuException ie) {
        	IpuUtility.error(ie.getMessage());
        } catch (Exception e) {
            IpuUtility.errorCode(RestScaffoldConstant.SERVER_007);
        }
        return retMap;
    }
}

ipu-rest-scaffold/src/main/java/com/ai/ipu/server/service/MongoDbService.java

@@ -1,25 +0,0 @@
package com.ai.ipu.server.service;
import java.util.List;
import com.ai.ipu.data.JMap;
/**
 * @author miaozy@asiainfo.com
 */
public interface MongoDbService {
    List<String> executeSelect(JMap params) throws Exception;
    void processInsertUser(JMap params) throws Exception;
    
    void processInsertLog(JMap params) throws Exception;
    
    void processInsertUserAndLog(JMap params) throws Exception;
    void processUpdateUser(JMap params) throws Exception;
    void processDeleteUser(JMap params) throws Exception;
}

ipu-rest-scaffold/src/main/java/com/ai/ipu/server/service/impl/MongoDbServiceImpl.java

@@ -1,125 +0,0 @@
package com.ai.ipu.server.service.impl;
import com.ai.ipu.data.JMap;
import com.ai.ipu.nosql.INoSql;
import com.ai.ipu.nosql.mongodb.MongoCacheFactory;
import com.ai.ipu.server.service.MongoDbService;
import com.alibaba.fastjson.JSONObject;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.springframework.stereotype.Service;
/**
 * @author miaozy@asiainfo.com
 */
@Service
public class MongoDbServiceImpl implements MongoDbService {
	private String tableUser = "userInfo";
	private String tableLog = "operLog";
    @Override
    public List<String> executeSelect(JMap params) throws Exception {
        String condParam = params.getString("condParam");
        String sortParam = params.getString("sortParam") == null ? "{}" : params.getString("sortParam");
        INoSql noSql = MongoCacheFactory.getMongoDao(params.getString("connName"), params.getString("dbName"), tableUser);
        return noSql.executeSelect(condParam, sortParam);
    }
    @Override
    public void processInsertUser(JMap params) throws Exception {
        INoSql noSql = MongoCacheFactory.getMongoDao(params.getString("connName"), params.getString("dbName"), tableUser);
        JSONObject json = JSONObject.parseObject(buildUser(params));
        noSql.executeInsert(json);
    }
    
    @Override
    public void processInsertLog(JMap params) throws Exception {
        INoSql noSql = MongoCacheFactory.getMongoDao(params.getString("connName"), params.getString("dbName"), tableLog);
//        JSONObject json = JSONObject.parseObject(buildLog(params));
//        noSql.executeInsert(json);
        //也可以直接用标准sql
        noSql.executeInsert("insert into " + tableLog + "(connName, dbName, operType, cond) values ('data', 'test', 'insertUser', null)");
    }
    
    @Override
    public void processInsertUserAndLog(JMap params) throws Exception {
        INoSql noSql = MongoCacheFactory.getMongoDao(params.getString("connName"), params.getString("dbName"), tableLog);
        JSONObject json = JSONObject.parseObject(buildLog(params));
        noSql.executeInsert(json);
        
        //声明独立事务。operLog和userInfo是不同事务，userInfo插入失败不会回滚operLog。
        //如果不声明，则operLog和userInfo是同一事务；只要任何一个插入失败，则全部做事务回滚。
        MongoCacheFactory.commit(params.getString("connName"), params.getString("dbName"), tableLog);
        MongoCacheFactory.clear(params.getString("connName"), params.getString("dbName"), tableLog);
        
        noSql = MongoCacheFactory.getMongoDao(params.getString("connName"), params.getString("dbName"), tableUser);
        json = JSONObject.parseObject(buildUser(params));
        noSql.executeInsert(json);
    }
    @Override
    public void processUpdateUser(JMap params) throws Exception {
        String condParam = params.getString("condParam");
        String updateField = buildUser(params);
        INoSql noSql = MongoCacheFactory.getMongoDao(params.getString("connName"), params.getString("dbName"), tableUser);
        noSql.executeUpdateMany(condParam, updateField);
    }
    @Override
    public void processDeleteUser(JMap params) throws Exception {
        String condParam = params.getString("condParam");
        INoSql noSql = MongoCacheFactory.getMongoDao(params.getString("connName"), params.getString("dbName"), tableUser);
        noSql.executeDeleteMany(condParam);
    }
    
    private String buildUser(JMap params) {
    	StringBuffer result = new StringBuffer();
    	if (params.containsKey("data"))
    		result.append(params.getString("data"));
        else
        {
        	JSONObject data = new JSONObject();
        	for(Entry<String, Object> entry : params.entrySet()){
        		if (entry.getKey().equals("connName") || 
        				entry.getKey().equals("dbName") ||
        				entry.getKey().startsWith("oper") ||
        				entry.getKey().startsWith("cond"))       		
        			continue;
        		
        		data.put(entry.getKey(), entry.getValue());	
        	}
        	if (data.isEmpty())
        	{
        		data.put("name", "tom");
        		data.put("male", true);
        		Map info = new HashMap();
        		info.put("city", "beijing");
        		info.put("tag", "[\"tennis\",\"football\", \"travel\"]");
        		data.put("info", info);
        	}
        	result.append(data.toJSONString());
        }
    	return result.toString();
    }
    
    private String buildLog(JMap params) {
    	JSONObject data = new JSONObject();
    	for(Entry<String, Object> entry : params.entrySet()){
    		if (entry.getKey().equals("connName") || 
    				entry.getKey().equals("dbName") ||
    				entry.getKey().startsWith("oper") ||
    				entry.getKey().startsWith("cond"))       		
    		{
    			data.put(entry.getKey(), entry.getValue());
    		}
    		
    			
    	}
    	return data.toJSONString();
    }
}

ipu-rest-scaffold/src/main/resources/dev/ipu-nosql.xml

@@ -1,69 +0,0 @@
<?xml version = '1.0' encoding = 'UTF-8'?>
<connections>
    <connection name="data" type="mongo">
        <servers>
            <server ip="10.1.236.121" port="11000" />
            <server ip="10.1.236.121" port="11010" />
            <server ip="10.1.236.121" port="11020" />
        </servers>
        <!-- 连接时数据库名，不做身份验证时可空；身份认证时必填 -->
        <config name="authSource" value="admin"/>
        <!-- 认证机制，不做身份验证时可空；身份认证时必填。mongo3.0及更高版本缺省是SCRAM-SHA-1 -->
        <!-- mongo2.6以前缺省是MONGODB-CR， mongo4.0及更高版本已经不再支持-->
        <!-- 支持SCRAM-SHA-1、SCRAM-SHA-256-->
        <!-- 当前组件不支持x.509证书 -->
        <config name="authMechanism" value="SCRAM-SHA-256"/>
        <!-- 用户名，不做身份验证时可空；身份认证时必填 -->
        <config name="userName" value="ipuOper"/>
        <!-- 加密后的用户密码，不做身份验证时可空；身份认证时必填 -->
        <!-- 加密算法需要用一对@@包含，并且放在密码的最前面。如果没有发现加密算法，则为明文密码  -->
        <config name="encryptedPasswd" value="@DES@cqKYnoRap2YV9L7xEQ4fyw=="/>
        <!-- 解密秘钥 ，可为空 -->
        <config name="decryptedKey" value="Mongo4@121#_3$"/>
        <!-- 自定义解密算法需要在pom.xml里引入所需jar，并在此声明带全包名的类 -->
        <config name="decryptedClass" value="com.ai.ipu.nosql.util.DecryptUtil"/>
        <!-- 自定义解密算法的解密算法，加密后的秘钥（可为空，为空则只有1个参数）、密码串是算法的2个参数  -->
        <config name="decryptedMethod" value="decryptDES"/>
        <!-- 是否支持事务，true为支持，其他值为不支持 -->
        <config name="needTranscation" value="true"/>
        <!-- 复制集名称，可以为空 -->
        <config name="replicaSet" value="lpsa_repl"/>
        <!-- 客户端最大连接数，超过了将会被阻塞，默认100 -->
        <config name="connectionsPerHost" />
        <!-- 客户端最小连接数 -->
        <config name="minConnectionsPerHost" />
        <!-- 可被阻塞的线程数因子，默认值为5，如果connectionsPerHost配置为10， -->
        <!-- 那么最多能阻塞50个线程，超过50个之后就会收到一个异常  -->
        <config name="threadAllowedToBlockForConnectionMultiplier" />
        <!-- 阻塞线程获取连接的最长等待时间，默认120000 ms -->
        <config name="maxWaitTime" />
        <!-- 连接池连接最大空闲时间，默认为0 -->
        <config name="maxConnectionIdleTime" />
        <!-- 连接池连接的最大存活时间，默认为0 -->
        <config name="maxConnectionLifeTime" />
        <!-- 连接超时时间，默认值是0，就是不超时 -->
        <config name="connectTimeout" />
        <!-- 超时时间，默认值是0，就是不超时 -->
        <config name="socketTimeout" />
        <!-- 当没有手动关闭游标时,是否自动释放游标对象。默认为 true。-->
        <config name="cursorFinalizerEnabled" />
        <!-- MongoDB有5种ReadPreference模式 -->
        <!-- primary            主节点，默认模式，读操作只在主节点，如果主节点不可用，报错或者抛出异常。-->
        <!-- primaryPreferred   首选主节点，大多情况下读操作在主节点，如果主节点不可用，如故障转移，读操作在从节点。-->
        <!-- secondary          从节点，读操作只在从节点， 如果从节点不可用，报错或者抛出异常。-->
        <!-- secondaryPreferred 首选从节点，大多情况下读操作在从节点，特殊情况（如单主节点架构）读操作在主节点。-->
        <!-- nearest            最邻近节点，读操作在最邻近的成员，可能是主节点或者从节点-->
        <config name="readPreference" />
    </connection>
    
    <connection name="simple" type="mongo">
        <servers>
            <server ip="10.1.236.121" port="11000" />
            <server ip="10.1.236.121" port="11010" />
            <server ip="10.1.236.121" port="11020" />
        </servers>
        <!-- 复制集名称，可以为空 -->
        <config name="replicaSet" value="lpsa_repl"/>
    </connection>
</connections>

ipu-rest-scaffold/src/main/resources/dev/logback.xml

@@ -1,25 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
	<include resource="org/springframework/boot/logging/logback/base.xml" /> <!-- logback 提供的基本配置 -->
	<!-- 控制台 -->
	<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
		<encoder charset="UTF-8">
			<!-- <pattern>[%d{yyyy-MM-dd HH:mm:ss.SSS}] %5p %m%n</pattern> -->
			<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} {%thread} %-5level %logger{50}-%msg%n</pattern>
			<charset>UTF-8</charset> <!-- 解决中文乱码问题 -->
		</encoder>
	</appender>
	<!-- <root level="DEBUG"> -->
	<root level="ERROR"> <appender-ref ref="CONSOLE" /> </root> 
	<!-- 将上面两个 appender 关联到我们的项目 -->
	<logger name="com.ai.ipu" level="DEBUG"
		additivity="false"> <!-- name 是项目包名，为了方便调试，输出 DEBUG 级别及其以上的log -->
		<appender-ref ref="CONSOLE" />
	</logger>
        
	<logger name="org.springframework" level="INFO" />   <!-- spring 包下的 logger, 只输出 INFO 级别的 -->
</configuration> 

ipu-rest-scaffold/src/main/resources/pro/ipu-nosql.xml

@@ -1,69 +0,0 @@
<?xml version = '1.0' encoding = 'UTF-8'?>
<connections>
    <connection name="data" type="mongo">
        <servers>
            <server ip="10.1.236.121" port="11000" />
            <server ip="10.1.236.121" port="11010" />
            <server ip="10.1.236.121" port="11020" />
        </servers>
        <!-- 连接时数据库名，不做身份验证时可空；身份认证时必填 -->
        <config name="authSource" value="admin"/>
        <!-- 认证机制，不做身份验证时可空；身份认证时必填。mongo3.0及更高版本缺省是SCRAM-SHA-1 -->
        <!-- mongo2.6以前缺省是MONGODB-CR， mongo4.0及更高版本已经不再支持-->
        <!-- 支持SCRAM-SHA-1、SCRAM-SHA-256-->
        <!-- 当前组件不支持x.509证书 -->
        <config name="authMechanism" value="SCRAM-SHA-256"/>
        <!-- 用户名，不做身份验证时可空；身份认证时必填 -->
        <config name="userName" value="ipuOper"/>
        <!-- 加密后的用户密码，不做身份验证时可空；身份认证时必填 -->
        <!-- 加密算法需要用一对@@包含，并且放在密码的最前面。如果没有发现加密算法，则为明文密码  -->
        <config name="encryptedPasswd" value="@DES@cMBWCqZgG39bQ+PyRkJ4sw=="/>
        <!-- 解密秘钥 ，可为空 -->
        <config name="decryptedKey" value="325m@#$rt4vt"/>
        <!-- 自定义解密算法需要在pom.xml里引入所需jar，并在此声明带全包名的类 -->
        <config name="decryptedClass" value="com.ai.ipu.nosql.util.DecryptUtil"/>
        <!-- 自定义解密算法的解密算法，加密后的秘钥（可为空，为空则只有1个参数）、密码串是算法的2个参数  -->
        <config name="decryptedMethod" value="decryptDES"/>
        <!-- 是否支持事务，true为支持，其他值为不支持 -->
        <config name="needTranscation" value="true"/>
        <!-- 复制集名称，可以为空 -->
        <config name="replicaSet" value="lpsa_repl"/>
        <!-- 客户端最大连接数，超过了将会被阻塞，默认100 -->
        <config name="connectionsPerHost" />
        <!-- 客户端最小连接数 -->
        <config name="minConnectionsPerHost" />
        <!-- 可被阻塞的线程数因子，默认值为5，如果connectionsPerHost配置为10， -->
        <!-- 那么最多能阻塞50个线程，超过50个之后就会收到一个异常  -->
        <config name="threadAllowedToBlockForConnectionMultiplier" />
        <!-- 阻塞线程获取连接的最长等待时间，默认120000 ms -->
        <config name="maxWaitTime" />
        <!-- 连接池连接最大空闲时间，默认为0 -->
        <config name="maxConnectionIdleTime" />
        <!-- 连接池连接的最大存活时间，默认为0 -->
        <config name="maxConnectionLifeTime" />
        <!-- 连接超时时间，默认值是0，就是不超时 -->
        <config name="connectTimeout" />
        <!-- 超时时间，默认值是0，就是不超时 -->
        <config name="socketTimeout" />
        <!-- 当没有手动关闭游标时,是否自动释放游标对象。默认为 true。-->
        <config name="cursorFinalizerEnabled" />
        <!-- MongoDB有5种ReadPreference模式 -->
        <!-- primary            主节点，默认模式，读操作只在主节点，如果主节点不可用，报错或者抛出异常。-->
        <!-- primaryPreferred   首选主节点，大多情况下读操作在主节点，如果主节点不可用，如故障转移，读操作在从节点。-->
        <!-- secondary          从节点，读操作只在从节点， 如果从节点不可用，报错或者抛出异常。-->
        <!-- secondaryPreferred 首选从节点，大多情况下读操作在从节点，特殊情况（如单主节点架构）读操作在主节点。-->
        <!-- nearest            最邻近节点，读操作在最邻近的成员，可能是主节点或者从节点-->
        <config name="readPreference" />
    </connection>
    
    <connection name="simple" type="mongo">
        <servers>
            <server ip="10.1.236.121" port="11000" />
            <server ip="10.1.236.121" port="11010" />
            <server ip="10.1.236.121" port="11020" />
        </servers>
        <!-- 复制集名称，可以为空 -->
        <config name="replicaSet" value="lpsa_repl"/>
    </connection>
</connections>

ipu-rest-scaffold/src/main/resources/pro/log4j.properties

@@ -1,11 +0,0 @@
### set log levels ###
log4j.rootLogger=DEBUG
### direct log messages to stdout ###
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.Target=System.out
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-5p(%10c{1}) %m%n
### application log config ###
log4j.logger.com.ai.ipu=DEBUG,A1

ipu-rest-scaffold/src/main/resources/pro/log4j2.xml

@@ -0,0 +1,15 @@
<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
    <Appenders>
        <Console name="Console" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
        </Console>
    </Appenders>
    <Loggers>
        <Root level="WARN">
            <AppenderRef ref="Console"/>
        </Root>
        <logger name="com.ai" level="DEBUG"></logger>
        <logger name="org.springframework.boot.web" level="DEBUG"></logger>
    </Loggers>
</Configuration>

ipu-rest-scaffold/src/main/resources/test/ipu-nosql.xml

@@ -1,69 +0,0 @@
<?xml version = '1.0' encoding = 'UTF-8'?>
<connections>
    <connection name="data" type="mongo">
        <servers>
            <server ip="10.1.236.121" port="11000" />
            <server ip="10.1.236.121" port="11010" />
            <server ip="10.1.236.121" port="11020" />
        </servers>
        <!-- 连接时数据库名，不做身份验证时可空；身份认证时必填 -->
        <config name="authSource" value="admin"/>
        <!-- 认证机制，不做身份验证时可空；身份认证时必填。mongo3.0及更高版本缺省是SCRAM-SHA-1 -->
        <!-- mongo2.6以前缺省是MONGODB-CR， mongo4.0及更高版本已经不再支持-->
        <!-- 支持SCRAM-SHA-1、SCRAM-SHA-256-->
        <!-- 当前组件不支持x.509证书 -->
        <config name="authMechanism" value="SCRAM-SHA-256"/>
        <!-- 用户名，不做身份验证时可空；身份认证时必填 -->
        <config name="userName" value="ipuOper"/>
        <!-- 加密后的用户密码，不做身份验证时可空；身份认证时必填 -->
        <!-- 加密算法需要用一对@@包含，并且放在密码的最前面。如果没有发现加密算法，则为明文密码  -->
        <config name="encryptedPasswd" value="@DES@cMBWCqZgG39bQ+PyRkJ4sw=="/>
        <!-- 解密秘钥 ，可为空 -->
        <config name="decryptedKey" value="325m@#$rt4vt"/>
        <!-- 自定义解密算法需要在pom.xml里引入所需jar，并在此声明带全包名的类 -->
        <config name="decryptedClass" value="com.ai.ipu.nosql.util.DecryptUtil"/>
        <!-- 自定义解密算法的解密算法，加密后的秘钥（可为空，为空则只有1个参数）、密码串是算法的2个参数  -->
        <config name="decryptedMethod" value="decryptDES"/>
        <!-- 是否支持事务，true为支持，其他值为不支持 -->
        <config name="needTranscation" value="true"/>
        <!-- 复制集名称，可以为空 -->
        <config name="replicaSet" value="lpsa_repl"/>
        <!-- 客户端最大连接数，超过了将会被阻塞，默认100 -->
        <config name="connectionsPerHost" />
        <!-- 客户端最小连接数 -->
        <config name="minConnectionsPerHost" />
        <!-- 可被阻塞的线程数因子，默认值为5，如果connectionsPerHost配置为10， -->
        <!-- 那么最多能阻塞50个线程，超过50个之后就会收到一个异常  -->
        <config name="threadAllowedToBlockForConnectionMultiplier" />
        <!-- 阻塞线程获取连接的最长等待时间，默认120000 ms -->
        <config name="maxWaitTime" />
        <!-- 连接池连接最大空闲时间，默认为0 -->
        <config name="maxConnectionIdleTime" />
        <!-- 连接池连接的最大存活时间，默认为0 -->
        <config name="maxConnectionLifeTime" />
        <!-- 连接超时时间，默认值是0，就是不超时 -->
        <config name="connectTimeout" />
        <!-- 超时时间，默认值是0，就是不超时 -->
        <config name="socketTimeout" />
        <!-- 当没有手动关闭游标时,是否自动释放游标对象。默认为 true。-->
        <config name="cursorFinalizerEnabled" />
        <!-- MongoDB有5种ReadPreference模式 -->
        <!-- primary            主节点，默认模式，读操作只在主节点，如果主节点不可用，报错或者抛出异常。-->
        <!-- primaryPreferred   首选主节点，大多情况下读操作在主节点，如果主节点不可用，如故障转移，读操作在从节点。-->
        <!-- secondary          从节点，读操作只在从节点， 如果从节点不可用，报错或者抛出异常。-->
        <!-- secondaryPreferred 首选从节点，大多情况下读操作在从节点，特殊情况（如单主节点架构）读操作在主节点。-->
        <!-- nearest            最邻近节点，读操作在最邻近的成员，可能是主节点或者从节点-->
        <config name="readPreference" />
    </connection>
    
    <connection name="simple" type="mongo">
        <servers>
            <server ip="10.1.236.121" port="11000" />
            <server ip="10.1.236.121" port="11010" />
            <server ip="10.1.236.121" port="11020" />
        </servers>
        <!-- 复制集名称，可以为空 -->
        <config name="replicaSet" value="lpsa_repl"/>
    </connection>
</connections>

ipu-rest-scaffold/src/main/resources/test/log4j.properties

@@ -1,11 +0,0 @@
### set log levels ###
log4j.rootLogger=DEBUG
### direct log messages to stdout ###
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.Target=System.out
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-5p(%10c{1}) %m%n
### application log config ###
log4j.logger.com.ai.ipu=DEBUG,A1

ipu-rest-scaffold/src/main/resources/test/log4j2.xml

@@ -0,0 +1,15 @@
<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
    <Appenders>
        <Console name="Console" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
        </Console>
    </Appenders>
    <Loggers>
        <Root level="WARN">
            <AppenderRef ref="Console"/>
        </Root>
        <logger name="com.ai" level="DEBUG"></logger>
        <logger name="org.springframework.boot.web" level="DEBUG"></logger>
    </Loggers>
</Configuration>