├── spring-boot-starter-mongodb-pool
    ├── .settings
    │   ├── org.eclipse.m2e.core.prefs
    │   ├── org.eclipse.core.resources.prefs
    │   └── org.eclipse.jdt.core.prefs
    ├── .gitignore
    ├── .project
    ├── src
    │   └── main
    │   │   └── java
    │   │       └── com
    │   │           └── cxytiandi
    │   │               └── mongodb
    │   │                   ├── MongoPoolAutoConfiguration.java
    │   │                   ├── EnableMongoPool.java
    │   │                   ├── MongoPoolProperties.java
    │   │                   ├── PoolAttributeTag.java
    │   │                   └── MongoPoolInit.java
    ├── .classpath
    └── pom.xml
├── spring-boot-starter-mongodb-pool-example
    ├── .settings
    │   ├── org.eclipse.m2e.core.prefs
    │   ├── org.eclipse.core.resources.prefs
    │   └── org.eclipse.jdt.core.prefs
    ├── src
    │   └── main
    │   │   ├── java
    │   │       └── com
    │   │       │   └── cxytiandi
    │   │       │       └── mongodb
    │   │       │           └── example
    │   │       │               ├── UserRepository.java
    │   │       │               ├── User.java
    │   │       │               ├── App.java
    │   │       │               └── MongoController.java
    │   │   └── resources
    │   │       └── application.properties
    ├── target
    │   └── classes
    │   │   ├── META-INF
    │   │       └── maven
    │   │       │   └── com.cxytiandi
    │   │       │       └── spring-boot-starter-mongodb-pool-example
    │   │       │           ├── pom.properties
    │   │       │           └── pom.xml
    │   │   └── application.properties
    ├── .gitignore
    ├── .project
    ├── pom.xml
    └── .classpath
├── .gitignore
└── README.md


/spring-boot-starter-mongodb-pool/.settings/org.eclipse.m2e.core.prefs:
--------------------------------------------------------------------------------
1 | activeProfiles=
2 | eclipse.preferences.version=1
3 | resolveWorkspaceProjects=true
4 | version=1
5 | 


--------------------------------------------------------------------------------
/spring-boot-starter-mongodb-pool-example/.settings/org.eclipse.m2e.core.prefs:
--------------------------------------------------------------------------------
1 | activeProfiles=
2 | eclipse.preferences.version=1
3 | resolveWorkspaceProjects=true
4 | version=1
5 | 


--------------------------------------------------------------------------------
/spring-boot-starter-mongodb-pool/.settings/org.eclipse.core.resources.prefs:
--------------------------------------------------------------------------------
1 | eclipse.preferences.version=1
2 | encoding//src/main/java=UTF-8
3 | encoding//src/test/java=UTF-8
4 | encoding/<project>=UTF-8
5 | 


--------------------------------------------------------------------------------
/spring-boot-starter-mongodb-pool-example/.settings/org.eclipse.core.resources.prefs:
--------------------------------------------------------------------------------
1 | eclipse.preferences.version=1
2 | encoding//src/main/java=UTF-8
3 | encoding//src/main/resources=UTF-8
4 | encoding//src/test/java=UTF-8
5 | encoding/<project>=UTF-8
6 | 


--------------------------------------------------------------------------------
/spring-boot-starter-mongodb-pool/.settings/org.eclipse.jdt.core.prefs:
--------------------------------------------------------------------------------
1 | eclipse.preferences.version=1
2 | org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
3 | org.eclipse.jdt.core.compiler.compliance=1.5
4 | org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
5 | org.eclipse.jdt.core.compiler.source=1.5
6 | 


--------------------------------------------------------------------------------
/spring-boot-starter-mongodb-pool-example/src/main/java/com/cxytiandi/mongodb/example/UserRepository.java:
--------------------------------------------------------------------------------
 1 | package com.cxytiandi.mongodb.example;
 2 | 
 3 | import org.springframework.data.mongodb.repository.MongoRepository;
 4 | import org.springframework.stereotype.Repository;
 5 | 
 6 | @Repository
 7 | public interface UserRepository extends MongoRepository<User, String>{
 8 | 	
 9 | }
10 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # maven ignore
 2 | target/
 3 | *.jar
 4 | *.war
 5 | *.zip
 6 | *.tar
 7 | *.tar.gz
 8 | 
 9 | # eclipse ignore
10 | .settings/
11 | .project
12 | .classpath
13 | 
14 | # idea ignore
15 | .idea/
16 | *.ipr
17 | *.iml
18 | *.iws
19 | 
20 | # temp ignore
21 | *.log
22 | *.cache
23 | *.diff
24 | *.patch
25 | *.tmp
26 | *.java~
27 | *.properties~
28 | *.xml~
29 | 
30 | # system ignore
31 | .DS_Store
32 | Thumbs.db
33 | 


--------------------------------------------------------------------------------
/spring-boot-starter-mongodb-pool-example/target/classes/META-INF/maven/com.cxytiandi/spring-boot-starter-mongodb-pool-example/pom.properties:
--------------------------------------------------------------------------------
1 | #Generated by Maven Integration for Eclipse
2 | #Tue Dec 25 15:20:21 CST 2018
3 | version=2.0.0
4 | groupId=com.cxytiandi
5 | m2e.projectName=spring-boot-starter-mongodb-pool-example
6 | m2e.projectLocation=D\:\\mongopool\\spring-boot-starter-mongodb-pool-example
7 | artifactId=spring-boot-starter-mongodb-pool-example
8 | 


--------------------------------------------------------------------------------
/spring-boot-starter-mongodb-pool/.gitignore:
--------------------------------------------------------------------------------
 1 | # maven ignore
 2 | target/
 3 | *.jar
 4 | *.war
 5 | *.zip
 6 | *.tar
 7 | *.tar.gz
 8 | 
 9 | # eclipse ignore
10 | .settings/
11 | .project
12 | .classpath
13 | 
14 | # idea ignore
15 | .idea/
16 | *.ipr
17 | *.iml
18 | *.iws
19 | 
20 | # temp ignore
21 | *.log
22 | *.cache
23 | *.diff
24 | *.patch
25 | *.tmp
26 | *.java~
27 | *.properties~
28 | *.xml~
29 | 
30 | # system ignore
31 | .DS_Store
32 | Thumbs.db
33 | 


--------------------------------------------------------------------------------
/spring-boot-starter-mongodb-pool-example/.gitignore:
--------------------------------------------------------------------------------
 1 | # maven ignore
 2 | target/
 3 | *.jar
 4 | *.war
 5 | *.zip
 6 | *.tar
 7 | *.tar.gz
 8 | 
 9 | # eclipse ignore
10 | .settings/
11 | .project
12 | .classpath
13 | 
14 | # idea ignore
15 | .idea/
16 | *.ipr
17 | *.iml
18 | *.iws
19 | 
20 | # temp ignore
21 | *.log
22 | *.cache
23 | *.diff
24 | *.patch
25 | *.tmp
26 | *.java~
27 | *.properties~
28 | *.xml~
29 | 
30 | # system ignore
31 | .DS_Store
32 | Thumbs.db
33 | 


--------------------------------------------------------------------------------
/spring-boot-starter-mongodb-pool-example/src/main/java/com/cxytiandi/mongodb/example/User.java:
--------------------------------------------------------------------------------
 1 | package com.cxytiandi.mongodb.example;
 2 | 
 3 | import org.springframework.data.mongodb.core.mapping.Document;
 4 | 
 5 | @Document(collection = "user")
 6 | public class User {
 7 | 	private String id;
 8 | 	private String name;
 9 | 
10 | 	public String getId() {
11 | 		return id;
12 | 	}
13 | 
14 | 	public void setId(String id) {
15 | 		this.id = id;
16 | 	}
17 | 
18 | 	public String getName() {
19 | 		return name;
20 | 	}
21 | 
22 | 	public void setName(String name) {
23 | 		this.name = name;
24 | 	}
25 | 
26 | }
27 | 


--------------------------------------------------------------------------------
/spring-boot-starter-mongodb-pool-example/target/classes/application.properties:
--------------------------------------------------------------------------------
 1 | spring.data.mongodb.testMongoTemplate.host=localhost
 2 | spring.data.mongodb.testMongoTemplate.port=27017
 3 | spring.data.mongodb.testMongoTemplate.database=backup
 4 | spring.data.mongodb.testMongoTemplate.showClass=false
 5 | spring.data.mongodb.testMongoTemplate.gridFsTemplateName=gridFsTemplate
 6 | 
 7 | spring.data.mongodb.logsMongoTemplate.host=localhost
 8 | spring.data.mongodb.logsMongoTemplate.port=27017
 9 | spring.data.mongodb.logsMongoTemplate.database=logs
10 | spring.data.mongodb.logsMongoTemplate.gridFsTemplateName=logsGridFsTemplate


--------------------------------------------------------------------------------
/spring-boot-starter-mongodb-pool-example/src/main/resources/application.properties:
--------------------------------------------------------------------------------
 1 | spring.data.mongodb.testMongoTemplate.host=localhost
 2 | spring.data.mongodb.testMongoTemplate.port=27017
 3 | spring.data.mongodb.testMongoTemplate.database=backup
 4 | spring.data.mongodb.testMongoTemplate.showClass=false
 5 | spring.data.mongodb.testMongoTemplate.gridFsTemplateName=gridFsTemplate
 6 | 
 7 | spring.data.mongodb.logsMongoTemplate.host=localhost
 8 | spring.data.mongodb.logsMongoTemplate.port=27017
 9 | spring.data.mongodb.logsMongoTemplate.database=logs
10 | spring.data.mongodb.logsMongoTemplate.gridFsTemplateName=logsGridFsTemplate


--------------------------------------------------------------------------------
/spring-boot-starter-mongodb-pool-example/src/main/java/com/cxytiandi/mongodb/example/App.java:
--------------------------------------------------------------------------------
 1 | package com.cxytiandi.mongodb.example;
 2 | 
 3 | import org.springframework.boot.SpringApplication;
 4 | import org.springframework.boot.autoconfigure.SpringBootApplication;
 5 | import com.cxytiandi.mongodb.EnableMongoPool;
 6 | 
 7 | /**
 8 |  * Mongodb连接池/多数据源扩展使用 Spring Boot集成案例
 9 |  * 
10 |  * @author yinjihuan
11 |  * 
12 |  * @about http://cxytiandi.com/about
13 |  *
14 |  */
15 | @SpringBootApplication
16 | @EnableMongoPool
17 | public class App {
18 | 	public static void main(String[] args) {
19 | 		SpringApplication.run(App.class, args);
20 | 	}
21 | }


--------------------------------------------------------------------------------
/spring-boot-starter-mongodb-pool/.project:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <projectDescription>
 3 | 	<name>spring-boot-starter-mongodb-pool</name>
 4 | 	<comment></comment>
 5 | 	<projects>
 6 | 	</projects>
 7 | 	<buildSpec>
 8 | 		<buildCommand>
 9 | 			<name>org.eclipse.jdt.core.javabuilder</name>
10 | 			<arguments>
11 | 			</arguments>
12 | 		</buildCommand>
13 | 		<buildCommand>
14 | 			<name>org.eclipse.m2e.core.maven2Builder</name>
15 | 			<arguments>
16 | 			</arguments>
17 | 		</buildCommand>
18 | 	</buildSpec>
19 | 	<natures>
20 | 		<nature>org.eclipse.jdt.core.javanature</nature>
21 | 		<nature>org.eclipse.m2e.core.maven2Nature</nature>
22 | 	</natures>
23 | </projectDescription>
24 | 


--------------------------------------------------------------------------------
/spring-boot-starter-mongodb-pool-example/.project:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <projectDescription>
 3 | 	<name>spring-boot-starter-mongodb-pool-example</name>
 4 | 	<comment></comment>
 5 | 	<projects>
 6 | 	</projects>
 7 | 	<buildSpec>
 8 | 		<buildCommand>
 9 | 			<name>org.eclipse.jdt.core.javabuilder</name>
10 | 			<arguments>
11 | 			</arguments>
12 | 		</buildCommand>
13 | 		<buildCommand>
14 | 			<name>org.eclipse.m2e.core.maven2Builder</name>
15 | 			<arguments>
16 | 			</arguments>
17 | 		</buildCommand>
18 | 	</buildSpec>
19 | 	<natures>
20 | 		<nature>org.eclipse.jdt.core.javanature</nature>
21 | 		<nature>org.eclipse.m2e.core.maven2Nature</nature>
22 | 	</natures>
23 | </projectDescription>
24 | 


--------------------------------------------------------------------------------
/spring-boot-starter-mongodb-pool-example/.settings/org.eclipse.jdt.core.prefs:
--------------------------------------------------------------------------------
 1 | eclipse.preferences.version=1
 2 | org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
 3 | org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate
 4 | org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
 5 | org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
 6 | org.eclipse.jdt.core.compiler.compliance=1.8
 7 | org.eclipse.jdt.core.compiler.debug.lineNumber=generate
 8 | org.eclipse.jdt.core.compiler.debug.localVariable=generate
 9 | org.eclipse.jdt.core.compiler.debug.sourceFile=generate
10 | org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
11 | org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
12 | org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
13 | org.eclipse.jdt.core.compiler.source=1.8
14 | 


--------------------------------------------------------------------------------
/spring-boot-starter-mongodb-pool/src/main/java/com/cxytiandi/mongodb/MongoPoolAutoConfiguration.java:
--------------------------------------------------------------------------------
 1 | package com.cxytiandi.mongodb;
 2 | 
 3 | import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
 4 | import org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration;
 5 | import org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration;
 6 | import org.springframework.context.annotation.Bean;
 7 | import org.springframework.context.annotation.Configuration;
 8 | import org.springframework.stereotype.Component;
 9 | 
10 | /**
11 |  * Mongodb数据库连接池信息自动配置
12 |  * 
13 |  * @author yinjihuan
14 |  * 
15 |  * @about http://cxytiandi.com/about
16 |  *
17 |  **/
18 | @Configuration
19 | @Component
20 | @EnableAutoConfiguration(exclude = {MongoAutoConfiguration.class, MongoDataAutoConfiguration.class})
21 | public class MongoPoolAutoConfiguration {
22 | 	
23 | 	@Bean
24 | 	public MongoPoolInit mongoPoolInit() {
25 | 		return new MongoPoolInit();
26 | 	}
27 | 	
28 | }
29 | 


--------------------------------------------------------------------------------
/spring-boot-starter-mongodb-pool/.classpath:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <classpath>
 3 | 	<classpathentry kind="src" output="target/classes" path="src/main/java">
 4 | 		<attributes>
 5 | 			<attribute name="optional" value="true"/>
 6 | 			<attribute name="maven.pomderived" value="true"/>
 7 | 		</attributes>
 8 | 	</classpathentry>
 9 | 	<classpathentry kind="src" output="target/test-classes" path="src/test/java">
10 | 		<attributes>
11 | 			<attribute name="optional" value="true"/>
12 | 			<attribute name="maven.pomderived" value="true"/>
13 | 		</attributes>
14 | 	</classpathentry>
15 | 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5">
16 | 		<attributes>
17 | 			<attribute name="maven.pomderived" value="true"/>
18 | 		</attributes>
19 | 	</classpathentry>
20 | 	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
21 | 		<attributes>
22 | 			<attribute name="maven.pomderived" value="true"/>
23 | 		</attributes>
24 | 	</classpathentry>
25 | 	<classpathentry kind="output" path="target/classes"/>
26 | </classpath>
27 | 


--------------------------------------------------------------------------------
/spring-boot-starter-mongodb-pool/src/main/java/com/cxytiandi/mongodb/EnableMongoPool.java:
--------------------------------------------------------------------------------
 1 | package com.cxytiandi.mongodb;
 2 | 
 3 | import java.lang.annotation.Documented;
 4 | import java.lang.annotation.ElementType;
 5 | import java.lang.annotation.Inherited;
 6 | import java.lang.annotation.Retention;
 7 | import java.lang.annotation.RetentionPolicy;
 8 | import java.lang.annotation.Target;
 9 | 
10 | import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
11 | import org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration;
12 | import org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration;
13 | import org.springframework.context.annotation.Import;
14 | 
15 | /**
16 |  * 启用Mongodb数据库连接池信息自动配置
17 |  * 
18 |  * @author yinjihuan
19 |  * 
20 |  * @about http://cxytiandi.com/about
21 |  *
22 |  **/
23 | @Target({ElementType.TYPE})
24 | @Retention(RetentionPolicy.RUNTIME)
25 | @Documented
26 | @Inherited
27 | @EnableAutoConfiguration(exclude={MongoAutoConfiguration.class,MongoDataAutoConfiguration.class})
28 | @Import({MongoPoolAutoConfiguration.class})
29 | public @interface EnableMongoPool {
30 | 
31 | }
32 | 


--------------------------------------------------------------------------------
/spring-boot-starter-mongodb-pool-example/pom.xml:
--------------------------------------------------------------------------------
 1 | <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 2 | 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 3 | 	<modelVersion>4.0.0</modelVersion>
 4 | 
 5 | 	<groupId>com.cxytiandi</groupId>
 6 | 	<artifactId>spring-boot-starter-mongodb-pool-example</artifactId>
 7 | 	<version>2.0.0</version>
 8 | 	<packaging>jar</packaging>
 9 | 
10 | 	<name>spring-boot-starter-mongodb-pool-example</name>
11 | 	<url>http://maven.apache.org</url>
12 | 
13 | 	<properties>
14 | 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
15 | 	</properties>
16 | 	<parent>
17 | 		<groupId>org.springframework.boot</groupId>
18 | 		<artifactId>spring-boot-starter-parent</artifactId>
19 | 		<version>2.0.1.RELEASE</version>
20 | 	</parent>
21 | 	<dependencies>
22 | 		<dependency>
23 | 			<groupId>org.springframework.boot</groupId>
24 | 			<artifactId>spring-boot-starter-web</artifactId>
25 | 		</dependency>
26 | 		<dependency>
27 | 			<groupId>com.cxytiandi</groupId>
28 | 			<artifactId>spring-boot-starter-mongodb-pool</artifactId>
29 | 			<version>2.0.2</version>
30 | 		</dependency>
31 | 	</dependencies>
32 | </project>
33 | 


--------------------------------------------------------------------------------
/spring-boot-starter-mongodb-pool-example/target/classes/META-INF/maven/com.cxytiandi/spring-boot-starter-mongodb-pool-example/pom.xml:
--------------------------------------------------------------------------------
 1 | <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 2 | 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 3 | 	<modelVersion>4.0.0</modelVersion>
 4 | 
 5 | 	<groupId>com.cxytiandi</groupId>
 6 | 	<artifactId>spring-boot-starter-mongodb-pool-example</artifactId>
 7 | 	<version>2.0.0</version>
 8 | 	<packaging>jar</packaging>
 9 | 
10 | 	<name>spring-boot-starter-mongodb-pool-example</name>
11 | 	<url>http://maven.apache.org</url>
12 | 
13 | 	<properties>
14 | 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
15 | 	</properties>
16 | 	<parent>
17 | 		<groupId>org.springframework.boot</groupId>
18 | 		<artifactId>spring-boot-starter-parent</artifactId>
19 | 		<version>2.0.1.RELEASE</version>
20 | 	</parent>
21 | 	<dependencies>
22 | 		<dependency>
23 | 			<groupId>org.springframework.boot</groupId>
24 | 			<artifactId>spring-boot-starter-web</artifactId>
25 | 		</dependency>
26 | 		<dependency>
27 | 			<groupId>com.cxytiandi</groupId>
28 | 			<artifactId>spring-boot-starter-mongodb-pool</artifactId>
29 | 			<version>2.0.0</version>
30 | 		</dependency>
31 | 	</dependencies>
32 | </project>
33 | 


--------------------------------------------------------------------------------
/spring-boot-starter-mongodb-pool-example/.classpath:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <classpath>
 3 | 	<classpathentry kind="src" output="target/classes" path="src/main/java">
 4 | 		<attributes>
 5 | 			<attribute name="optional" value="true"/>
 6 | 			<attribute name="maven.pomderived" value="true"/>
 7 | 		</attributes>
 8 | 	</classpathentry>
 9 | 	<classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources">
10 | 		<attributes>
11 | 			<attribute name="maven.pomderived" value="true"/>
12 | 		</attributes>
13 | 	</classpathentry>
14 | 	<classpathentry kind="src" output="target/test-classes" path="src/test/java">
15 | 		<attributes>
16 | 			<attribute name="optional" value="true"/>
17 | 			<attribute name="maven.pomderived" value="true"/>
18 | 		</attributes>
19 | 	</classpathentry>
20 | 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6">
21 | 		<attributes>
22 | 			<attribute name="maven.pomderived" value="true"/>
23 | 		</attributes>
24 | 	</classpathentry>
25 | 	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
26 | 		<attributes>
27 | 			<attribute name="maven.pomderived" value="true"/>
28 | 		</attributes>
29 | 	</classpathentry>
30 | 	<classpathentry kind="output" path="target/classes"/>
31 | </classpath>
32 | 


--------------------------------------------------------------------------------
/spring-boot-starter-mongodb-pool/pom.xml:
--------------------------------------------------------------------------------
 1 | <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 2 | 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 3 | 	<modelVersion>4.0.0</modelVersion>
 4 | 
 5 | 	<groupId>com.cxytiandi</groupId>
 6 | 	<artifactId>spring-boot-starter-mongodb-pool</artifactId>
 7 | 	<version>2.0.2</version>
 8 | 	<packaging>jar</packaging>
 9 | 
10 | 	<name>spring-boot-starter-mongodb-pool</name>
11 | 	<url>http://maven.apache.org</url>
12 | 
13 | 	<properties>
14 | 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
15 | 	</properties>
16 | 
17 | 	<dependencyManagement>
18 | 		<dependencies>
19 | 			<dependency>
20 | 				<groupId>org.springframework.boot</groupId>
21 | 				<artifactId>spring-boot-dependencies</artifactId>
22 | 				<version>2.0.1.RELEASE</version>
23 | 				<type>pom</type>
24 | 				<scope>import</scope>
25 | 			</dependency>
26 | 		</dependencies>
27 | 	</dependencyManagement>
28 | 	<dependencies>
29 | 		<dependency>
30 | 			<groupId>org.springframework.boot</groupId>
31 | 			<artifactId>spring-boot-starter-data-mongodb</artifactId>
32 | 		</dependency>
33 | 		<dependency>
34 | 			<groupId>org.springframework.boot</groupId>
35 | 			<artifactId>spring-boot-configuration-processor</artifactId>
36 | 		</dependency>
37 | 		<dependency>
38 | 			<groupId>org.projectlombok</groupId>
39 | 			<artifactId>lombok</artifactId>
40 | 			<version>1.16.12</version>
41 | 			<scope>provided</scope>
42 | 		</dependency>
43 | 	</dependencies>
44 | </project>
45 | 


--------------------------------------------------------------------------------
/spring-boot-starter-mongodb-pool/src/main/java/com/cxytiandi/mongodb/MongoPoolProperties.java:
--------------------------------------------------------------------------------
 1 | package com.cxytiandi.mongodb;
 2 | 
 3 | import lombok.Data;
 4 | 
 5 | @Data
 6 | public class MongoPoolProperties {
 7 | 	private String mongoTemplateName = "mongoTemplate";
 8 | 	
 9 | 	private String gridFsTemplateName = "gridFsTemplate";
10 | 	
11 | 	private String applicationName;
12 | 	
13 | 	// 集群模式，多个数据库地址，和host,port二选一。格式为：192.168.1.1:8212,192.168.1.2:8213
14 | 	private String uri;
15 | 	
16 | 	/**
17 | 	 * 存储时是否保存_class
18 | 	 */
19 | 	private boolean showClass = true;
20 | 	private String host;
21 | 	private Integer port = 27017;
22 | 	private String database;
23 | 	private String authenticationDatabase;
24 | 	private String gridFsDatabase;
25 | 	private String username;
26 | 	private char[] password;
27 | 
28 |     private int minConnectionsPerHost;
29 |     private int maxConnectionsPerHost = 100;
30 |     private int threadsAllowedToBlockForConnectionMultiplier = 5;
31 |     private int serverSelectionTimeout = 1000 * 30;
32 |     private int maxWaitTime = 1000 * 60 * 2;
33 |     private int maxConnectionIdleTime;
34 |     private int maxConnectionLifeTime;
35 |     private int connectTimeout = 1000 * 10;
36 |     private int socketTimeout = 0;
37 |     private boolean socketKeepAlive = false;
38 |     private boolean sslEnabled = false;
39 |     private boolean sslInvalidHostNameAllowed = false;
40 |     private boolean alwaysUseMBeans = false;
41 | 
42 |     private int heartbeatFrequency = 10000;
43 |     private int minHeartbeatFrequency = 500;
44 |     private int heartbeatConnectTimeout = 20000;
45 |     private int heartbeatSocketTimeout = 20000;
46 |     private int localThreshold = 15;
47 | }
48 | 


--------------------------------------------------------------------------------
/spring-boot-starter-mongodb-pool-example/src/main/java/com/cxytiandi/mongodb/example/MongoController.java:
--------------------------------------------------------------------------------
 1 | package com.cxytiandi.mongodb.example;
 2 | 
 3 | import java.io.File;
 4 | import java.io.FileInputStream;
 5 | import org.springframework.beans.factory.annotation.Autowired;
 6 | import org.springframework.beans.factory.annotation.Qualifier;
 7 | import org.springframework.data.mongodb.core.MongoTemplate;
 8 | import org.springframework.data.mongodb.gridfs.GridFsTemplate;
 9 | import org.springframework.web.bind.annotation.GetMapping;
10 | import org.springframework.web.bind.annotation.RestController;
11 | import com.mongodb.BasicDBObject;
12 | 
13 | @RestController
14 | public class MongoController {
15 | 
16 | 	@Autowired
17 | 	@Qualifier("testMongoTemplate")
18 | 	private MongoTemplate testMongoTemplate;
19 | 	
20 | 	@Autowired
21 | 	@Qualifier("logsMongoTemplate")
22 | 	private MongoTemplate logsMongoTemplate;
23 | 	
24 | 	@Autowired
25 | 	@Qualifier("gridFsTemplate")
26 | 	private GridFsTemplate gridFsTemplate;
27 | 	
28 | 	@Autowired
29 | 	@Qualifier("logsGridFsTemplate")
30 | 	private GridFsTemplate logsGridFsTemplate;
31 | 	
32 | 	@GetMapping("/")
33 | 	public Object get() throws Exception {
34 | 		gridFsTemplate.store(new FileInputStream(new File("D:\\course\\mongodb\\po\\Advertisement.java")), new BasicDBObject("name", "yinjihuan"));
35 | 		testMongoTemplate.getCollectionNames().forEach(System.out::println);
36 | 		return "success";
37 | 	}
38 | 	
39 | 	@GetMapping("/slave")
40 | 	public Object getSlave() throws Exception  {
41 | 		logsGridFsTemplate.store(new FileInputStream(new File("D:\\course\\mongodb\\po\\Advertisement.java")), new BasicDBObject("name", "yinjihuan222"));
42 | 		logsMongoTemplate.getCollectionNames().forEach(System.out::println);
43 | 		return "success";
44 | 	}
45 | 	
46 | 	@GetMapping("/save")
47 | 	public Object save() {
48 | 		User u = new User();
49 | 		u.setName("yinjihuan");
50 | 		testMongoTemplate.save(u);
51 | 		return "success";
52 | 	}
53 | }
54 | 


--------------------------------------------------------------------------------
/spring-boot-starter-mongodb-pool/src/main/java/com/cxytiandi/mongodb/PoolAttributeTag.java:
--------------------------------------------------------------------------------
 1 | package com.cxytiandi.mongodb;
 2 | 
 3 | public class PoolAttributeTag {
 4 | 
 5 | 	public static final String GRID_FS_TEMPLATE_NAME = "gridFsTemplateName";
 6 | 	public static final String SHOW_CLASS = "showClass";
 7 | 	public static final String HOST = "host";
 8 | 	public static final String URI = "uri";
 9 | 	public static final String DATABASE = "database";
10 | 	public static final String PORT = "port";
11 | 	public static final String AUTH_DATABASE = "authenticationDatabase";
12 | 	public static final String GRIDFS_DATABASE = "gridFsDatabase";
13 | 	public static final String USERNAME = "username";
14 | 	public static final String PASSWORD = "password";
15 | 	public static final String MIN_CONN_PERHOST = "minConnectionsPerHost";
16 | 	public static final String MAX_CONN_PERHOST = "maxConnectionsPerHost";
17 | 	public static final String THREADS_ALLOWED_TO_BLOCK_FOR_CONN_MULTIPLIER = "threadsAllowedToBlockForConnectionMultiplier";
18 | 	public static final String SERVER_SELECTION_TIMEOUT = "serverSelectionTimeout";
19 | 	public static final String MAX_WAIT_TIME = "maxWaitTime";
20 | 	public static final String APPLICATIONNAME = "applicationName";
21 | 	
22 | 	public static final String MAX_CONN_IDLE_TIME = "maxConnectionIdleTime";
23 | 	public static final String MAX_CONN_LIFE_TIME = "maxConnectionLifeTime";
24 | 	public static final String CONN_TIMEOUT = "connectTimeout";
25 | 	public static final String SOCKET_TIMEOUT = "socketTimeout";
26 | 	public static final String SOCKET_KEEP_ALIVE = "socketKeepAlive";
27 | 	public static final String SSL_ENABLED = "sslEnabled";
28 | 	public static final String SSL_INVALID_HOSTNAME_ALLOWED = "sslInvalidHostNameAllowed";
29 | 	public static final String ALWAYS_USE_MBEANS = "alwaysUseMBeans";
30 | 	
31 | 	public static final String HEARTBEAT_FREQUENCY = "heartbeatFrequency";
32 | 	public static final String MIN_HEARTBEAT_FREQUENCY = "minHeartbeatFrequency";
33 | 	public static final String HEARTBEAT_CONN_TIMEOUT = "heartbeatConnectTimeout";
34 | 	public static final String HEARTBEAT_SOCKET_TIMEOUT = "heartbeatSocketTimeout";
35 | 	public static final String LOCAL_THRESHOLD = "localThreshold";
36 | 	
37 | }
38 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # spring-boot-starter-mongodb-pool
  2 | 
  3 | 在日常工作中，我们通过Spring Data Mongodb来操作Mongodb数据库，在Spring Boot中只需要引入spring-boot-starter-data-mongodb即可。
  4 | 
  5 | 很多时候我们往往需要操作多个数据库（微服务架构下一个服务一个独立的库），最简单的方式就是在项目中为每个数据库配置下，比如：
  6 | 
  7 | ```
  8 | @Bean 
  9 | @Primary
 10 | public MongoDbFactory mongoDbFactory() throws Exception {
 11 |     // 省略...
 12 |    return new SimpleMongoDbFactory(mongoClient, "db1");
 13 | }
 14 | 
 15 | @Bean
 16 | @Primary
 17 | public MongoTemplate mongoTemplate() throws Exception {
 18 | 	  //省略...
 19 | 	  MongoTemplate mongoTemplate = new MongoTemplate(mongoDbFactory(), converter);
 20 | 	  return mongoTemplate;
 21 | }
 22 | 
 23 | @Bean 
 24 | @Qualifier("mongoDbFactory2")
 25 | public MongoDbFactory mongoDbFactory2()hrows Exception {
 26 |     // 省略...
 27 |    return new SimpleMongoDbFactory(mongoClient, "db2);
 28 | }
 29 | 
 30 | @Bean
 31 | @Qualifier("mongoTemplate2")
 32 | public MongoTemplate mongoTemplate2() hrows Exception {
 33 |     //省略...
 34 |     MongoTemplate mongoTemplate = new MongoTemplate(mongoDbFactory(), converter);
 35 |     return mongoTemplate;
 36 | }
 37 | ```
 38 | 
 39 | 配置完成后注入使用的地方使用Qualifier注入即可使用对应的数据源，比如：
 40 | 
 41 | ```
 42 | @Autowired
 43 | @Qualifier("mongoTemplate2")
 44 | private MongoTemplate seaweedMongoTemplate;
 45 | ```
 46 | 
 47 | 上面是直接在项目中配置多数据源的方式，接下来我们讲下一个问题，数据库连接池的问题，Mongodb的驱动中自带了连接池，但是Spring Boot Starter中却没有对连接池的配置，往往我们也需要通过代码的方式去配置，比如：
 48 | 
 49 | ```
 50 |  @Bean
 51 |  public MongoClientOptions mongoClientOptions() {
 52 |      return new MongoClientOptions.Builder()
 53 |           //省略...
 54 |           .minConnectionsPerHost(...).build();
 55 |  }
 56 | ```
 57 | 
 58 | 虽然上面这些方式也都比较简单，但是在多个项目使用的时候都要去配置，重复代码比较严重，既然作为Starter按理来说是越简单越好，直接通过在属性文件中
 59 | 配置就可以搞定，但是却不行，为此我封装了这个Pool Starter。
 60 | 
 61 | ## 主要功能
 62 | 
 63 | - 目前最新的jar包只支持Spring Boot 2.0, Spring Boot 1.0版本的可以下载releases中的1.0.0版本的源码进行修改
 64 | - 可以配置多个数据源
 65 | - 支持连接池参数配置
 66 | - 支持去掉_class的配置
 67 | 
 68 | ## 不支持的功能
 69 | 
 70 | - 多数据源配置后不支持Repository接口方式的使用
 71 | - 不支持uri配置连接池信息
 72 | 
 73 | ## 仓库地址
 74 | 
 75 | ```
 76 | <repositories>
 77 | 	<repository>
 78 | 		<id>jitpack.io</id>
 79 | 		<url>https://www.jitpack.io</url>
 80 | 	</repository>
 81 | </repositories>
 82 | ```
 83 | 
 84 | ## Maven依赖
 85 | 
 86 | ```
 87 | <dependency>
 88 | 	<groupId>com.github.yinjihuan</groupId>
 89 | 	<artifactId>spring-boot-starter-mongodb-pool</artifactId>
 90 | 	<version>2.0.2</version>
 91 | </dependency>
 92 | ```
 93 | 
 94 | ## 配置方式
 95 | 
 96 | 配置采用spring.data.mongodb.mongoTemplate名称.属性名=值
 97 | 
 98 | ```
 99 | spring.data.mongodb.testMongoTemplate.host=localhost
100 | spring.data.mongodb.testMongoTemplate.port=27017
101 | spring.data.mongodb.testMongoTemplate.database=backup
102 | spring.data.mongodb.testMongoTemplate.showClass=false
103 | spring.data.mongodb.testMongoTemplate.gridFsTemplateName=gridFsTemplate
104 | 
105 | spring.data.mongodb.logsMongoTemplate.host=localhost
106 | spring.data.mongodb.logsMongoTemplate.port=27017
107 | spring.data.mongodb.logsMongoTemplate.database=logs
108 | spring.data.mongodb.logsMongoTemplate.gridFsTemplateName=logsGridFsTemplate
109 | ```
110 | 
111 | 带认证的集群配置方式：
112 | 
113 | ```
114 | spring.data.mongodb.testMongoTemplate.uri=localhost:27017,localhost:27018
115 | spring.data.mongodb.testMongoTemplate.username=yinjihuan
116 | spring.data.mongodb.testMongoTemplate.password=123456
117 | spring.data.mongodb.testMongoTemplate.database=backup
118 | spring.data.mongodb.testMongoTemplate.showClass=false
119 | ```
120 | 
121 | testMongoTemplate和logsMongoTemplate就是每个数据源对应的MongoTemplate
122 | 
123 | 同样的如果我们要操作GridFS的话也可以通过gridFsTemplateName属性来配置gridFsTemplate的名称
124 | 
125 | 配置完之后就可以使用了，使用代码如下：
126 | 
127 | ```
128 | @Autowired
129 | @Qualifier("testMongoTemplate")
130 | private MongoTemplate testMongoTemplate;
131 | 	
132 | @Autowired
133 | @Qualifier("logsMongoTemplate")
134 | private MongoTemplate logsMongoTemplate;
135 | ```
136 | 
137 | 完整的使用案列请参考：https://github.com/yinjihuan/spring-boot-starter-mongodb-pool/tree/master/spring-boot-starter-mongodb-pool-example
138 | 
139 | 完整的属性配置请参考：https://github.com/yinjihuan/spring-boot-starter-mongodb-pool/blob/master/spring-boot-starter-mongodb-pool/src/main/java/com/cxytiandi/mongodb/MongoPoolProperties.java
140 | 
141 | ```
142 | @Data
143 | public class MongoPoolProperties {
144 |     private String mongoTemplateName = "mongoTemplate";
145 | 	
146 |     private String gridFsTemplateName = "gridFsTemplate";
147 | 	
148 |     /**
149 |      * 存储时是否保存_class
150 |      */
151 |     private boolean showClass = true;
152 |     private String host;
153 |     private Integer port = 27017;
154 |     private String database;
155 |     private String authenticationDatabase;
156 |     private String gridFsDatabase;
157 |     private String username;
158 |     private char[] password;
159 | 
160 |     private int minConnectionsPerHost;
161 |     private int maxConnectionsPerHost = 100;
162 |     private int threadsAllowedToBlockForConnectionMultiplier = 5;
163 |     private int serverSelectionTimeout = 1000 * 30;
164 |     private int maxWaitTime = 1000 * 60 * 2;
165 |     private int maxConnectionIdleTime;
166 |     private int maxConnectionLifeTime;
167 |     private int connectTimeout = 1000 * 10;
168 |     private int socketTimeout = 0;
169 |     private boolean socketKeepAlive = false;
170 |     private boolean sslEnabled = false;
171 |     private boolean sslInvalidHostNameAllowed = false;
172 |     private boolean alwaysUseMBeans = false;
173 | 
174 |     private int heartbeatFrequency = 10000;
175 |     private int minHeartbeatFrequency = 500;
176 |     private int heartbeatConnectTimeout = 20000;
177 |     private int heartbeatSocketTimeout = 20000;
178 |     private int localThreshold = 15;
179 | }
180 | ```
181 | 
182 | # 去掉_class
183 |  Spring Data Mongodb在保存数据的时候会自动增加一个_class字段用来关联这条数据的Document实体类，大数据量下会浪费存储空间，我们可以通过下面的配置禁用掉：
184 |  
185 |  ```
186 |  spring.data.mongodb.testMongoTemplate.showClass=false
187 |  ```
188 | 
189 | # 作者
190 | - 尹吉欢 1304489315@qq.com
191 | - 博客 http://cxytiandi.com/blogs/yinjihuan
192 | - Spring Data Mongodb技术交流群：544478648
193 | 
194 | 更多技术分享请关注微信公众号：猿天地
195 | 
196 | ![image.png](http://upload-images.jianshu.io/upload_images/2685774-da01a73d0cfc3f35.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
197 | 


--------------------------------------------------------------------------------
/spring-boot-starter-mongodb-pool/src/main/java/com/cxytiandi/mongodb/MongoPoolInit.java:
--------------------------------------------------------------------------------
  1 | package com.cxytiandi.mongodb;
  2 | 
  3 | import java.util.ArrayList;
  4 | import java.util.Arrays;
  5 | import java.util.List;
  6 | import java.util.Map;
  7 | import java.util.Set;
  8 | import java.util.TreeSet;
  9 | 
 10 | import org.springframework.beans.BeansException;
 11 | import org.springframework.beans.factory.annotation.AnnotatedGenericBeanDefinition;
 12 | import org.springframework.beans.factory.config.BeanDefinitionHolder;
 13 | import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
 14 | import org.springframework.beans.factory.support.BeanDefinitionReaderUtils;
 15 | import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 16 | import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
 17 | import org.springframework.boot.context.properties.bind.Binder;
 18 | import org.springframework.context.EnvironmentAware;
 19 | import org.springframework.context.annotation.AnnotationConfigUtils;
 20 | import org.springframework.context.annotation.AnnotationScopeMetadataResolver;
 21 | import org.springframework.context.annotation.ScopeMetadata;
 22 | import org.springframework.context.annotation.ScopeMetadataResolver;
 23 | import org.springframework.core.env.Environment;
 24 | import org.springframework.data.mongodb.core.MongoTemplate;
 25 | import org.springframework.data.mongodb.core.SimpleMongoDbFactory;
 26 | import org.springframework.data.mongodb.core.convert.DefaultDbRefResolver;
 27 | import org.springframework.data.mongodb.core.convert.DefaultMongoTypeMapper;
 28 | import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
 29 | import org.springframework.data.mongodb.core.mapping.MongoMappingContext;
 30 | import org.springframework.data.mongodb.gridfs.GridFsTemplate;
 31 | import org.springframework.stereotype.Component;
 32 | import org.springframework.util.StringUtils;
 33 | 
 34 | import com.mongodb.MongoClient;
 35 | import com.mongodb.MongoClientOptions;
 36 | import com.mongodb.MongoCredential;
 37 | import com.mongodb.ServerAddress;
 38 | 
 39 | /**
 40 |  * 创建多数据源MongoTemplate
 41 |  * 
 42 |  * @author yinjihuan
 43 |  * 
 44 |  * @about http://cxytiandi.com/about
 45 |  *
 46 |  **/
 47 | @Component
 48 | public class MongoPoolInit implements BeanDefinitionRegistryPostProcessor, EnvironmentAware {
 49 | 
 50 | 	private List<MongoPoolProperties> pools = new ArrayList<MongoPoolProperties>();
 51 | 
 52 | 	private ScopeMetadataResolver scopeMetadataResolver = new AnnotationScopeMetadataResolver();
 53 | 
 54 | 	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
 55 | 
 56 | 	}
 57 | 
 58 | 	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
 59 | 		int index = 0;
 60 | 		for (MongoPoolProperties properties : pools) {
 61 | 			MongoClientOptions options = buildMongoOptions(properties);
 62 | 			List<ServerAddress> seeds = null;
 63 | 			// 优选选择URI构造链接
 64 | 			if (StringUtils.hasText(properties.getUri())) {
 65 | 				seeds = new ArrayList<ServerAddress>();
 66 | 				String[] uris = properties.getUri().split(",");
 67 | 				for (String u : uris) {
 68 | 					String[] us = u.split(":");
 69 | 					seeds.add(new ServerAddress(us[0], Integer.parseInt(us[1])));
 70 | 				}
 71 | 			} else {
 72 | 				seeds = Arrays.asList(new ServerAddress(properties.getHost(), properties.getPort()));
 73 | 			}
 74 | 			
 75 | 			MongoClient mongoClient = null;
 76 | 			// 认证信息
 77 | 			if (StringUtils.hasText(properties.getUsername()) && 
 78 | 					StringUtils.hasText(properties.getAuthenticationDatabase()) && properties.getPassword() != null) {
 79 | 				MongoCredential cre = MongoCredential.createCredential(properties.getUsername(), properties.getAuthenticationDatabase(), 
 80 | 						properties.getPassword());
 81 | 				mongoClient = new MongoClient(seeds, cre, options);
 82 | 			} else {
 83 | 				mongoClient = new MongoClient(seeds, options);
 84 | 			}
 85 | 			
 86 | 			SimpleMongoDbFactory mongoDbFactory = null;
 87 | 			if (StringUtils.hasText(properties.getDatabase())) {
 88 | 				mongoDbFactory = new SimpleMongoDbFactory(mongoClient, properties.getDatabase());
 89 | 			} else {
 90 | 				mongoDbFactory = new SimpleMongoDbFactory(mongoClient, properties.getGridFsDatabase());
 91 | 			}
 92 | 			
 93 | 			MappingMongoConverter converter = buildConverter(mongoDbFactory, properties.isShowClass());
 94 | 			boolean primary = false;
 95 | 			if (index == 0) {
 96 | 				primary = true;
 97 | 				index++;
 98 | 			}
 99 | 			
100 | 			registryMongoTemplate(registry, primary, properties, mongoDbFactory, converter);
101 | 			registryGridFsTemplate(registry, primary, properties, mongoDbFactory, converter);
102 | 		}
103 | 
104 | 	}
105 | 	
106 | 	private void registryGridFsTemplate(BeanDefinitionRegistry registry, boolean primary, MongoPoolProperties properties,
107 | 			SimpleMongoDbFactory mongoDbFactory, MappingMongoConverter converter) {
108 | 		AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(GridFsTemplate.class);
109 | 		ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
110 | 		abd.setScope(scopeMetadata.getScopeName());
111 | 		abd.getConstructorArgumentValues().addGenericArgumentValue(mongoDbFactory);
112 | 		abd.getConstructorArgumentValues().addGenericArgumentValue(converter);
113 | 		abd.setPrimary(primary);
114 | 		AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
115 | 		BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, properties.getGridFsTemplateName());
116 | 		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);
117 | 	}
118 | 
119 | 	private void registryMongoTemplate(BeanDefinitionRegistry registry, boolean primary, MongoPoolProperties properties,
120 | 			SimpleMongoDbFactory mongoDbFactory, MappingMongoConverter converter) {
121 | 		AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(MongoTemplate.class);
122 | 		ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
123 | 		abd.setScope(scopeMetadata.getScopeName());
124 | 		abd.getConstructorArgumentValues().addGenericArgumentValue(mongoDbFactory);
125 | 		abd.getConstructorArgumentValues().addGenericArgumentValue(converter);
126 | 		abd.setPrimary(primary);
127 | 		AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
128 | 		BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, properties.getMongoTemplateName());
129 | 		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);
130 | 	}
131 | 
132 | 	private MappingMongoConverter buildConverter(SimpleMongoDbFactory mongoDbFactory, boolean showClass) {
133 | 		MappingMongoConverter converter = new MappingMongoConverter(
134 | 				new DefaultDbRefResolver(mongoDbFactory),
135 | 				new MongoMappingContext());
136 | 		if (!showClass) {
137 | 			converter.setTypeMapper(new DefaultMongoTypeMapper(null));
138 | 		}
139 | 		return converter;
140 | 	}
141 | 
142 | 	private MongoClientOptions buildMongoOptions(MongoPoolProperties properties) {
143 | 		MongoClientOptions options = new MongoClientOptions.Builder()
144 | 				.applicationName(properties.getApplicationName())
145 | 				.connectionsPerHost(properties.getMaxConnectionsPerHost())
146 | 				.minConnectionsPerHost(properties.getMinConnectionsPerHost())
147 | 				.threadsAllowedToBlockForConnectionMultiplier(
148 | 						properties.getThreadsAllowedToBlockForConnectionMultiplier())
149 | 				.serverSelectionTimeout(properties.getServerSelectionTimeout())
150 | 				.maxWaitTime(properties.getMaxWaitTime())
151 | 				.maxConnectionIdleTime(properties.getMaxConnectionIdleTime())
152 | 				.maxConnectionLifeTime(properties.getMaxConnectionLifeTime())
153 | 				.connectTimeout(properties.getConnectTimeout()).socketTimeout(properties.getSocketTimeout())
154 | 				.socketKeepAlive(properties.isSocketKeepAlive()).sslEnabled(properties.isSslEnabled())
155 | 				.sslInvalidHostNameAllowed(properties.isSslInvalidHostNameAllowed())
156 | 				.alwaysUseMBeans(properties.isAlwaysUseMBeans())
157 | 				.heartbeatFrequency(properties.getHeartbeatFrequency())
158 | 				.minHeartbeatFrequency(properties.getMinHeartbeatFrequency())
159 | 				.heartbeatConnectTimeout(properties.getHeartbeatConnectTimeout())
160 | 				.heartbeatSocketTimeout(properties.getSocketTimeout())
161 | 				.localThreshold(properties.getLocalThreshold()).build();
162 | 		return options;
163 | 	}
164 | 
165 | 	public void setEnvironment(Environment environment) {
166 | 		// 初始化配置信息到对象的映射
167 | 		Map<String, Object> map = Binder.get(environment).bind("spring.data.mongodb", Map.class).get();
168 | 		Set<String> mongoTemplateNames = new TreeSet<String>();
169 | 		Set<String> keys = map.keySet();
170 | 
171 | 		for (String key : keys) {
172 | 			String mongoTemplateName = key.split("\\.")[0];
173 | 			mongoTemplateNames.add(mongoTemplateName);
174 | 		}
175 | 
176 | 		for (String name : mongoTemplateNames) {
177 | 			MongoPoolProperties pro = new MongoPoolProperties();
178 | 			buildProperties((Map)map.get(name), name, pro);
179 | 			pools.add(pro);
180 | 		}
181 | 	}
182 | 
183 | 	private void buildProperties(Map<String, Object> map, String name, MongoPoolProperties pro) {
184 | 		pro.setUri(formatStringValue(map, PoolAttributeTag.URI, ""));
185 | 		pro.setShowClass(formatBoolValue(map, PoolAttributeTag.SHOW_CLASS, true));
186 | 		pro.setMongoTemplateName(name);
187 | 		pro.setGridFsTemplateName(formatStringValue(map, PoolAttributeTag.GRID_FS_TEMPLATE_NAME, name + "GridFsTemplate"));
188 | 		pro.setHost(formatStringValue(map, PoolAttributeTag.HOST, "localhost"));
189 | 		pro.setPort(formatIntValue(map, PoolAttributeTag.PORT, 27017));
190 | 		pro.setDatabase(formatStringValue(map, PoolAttributeTag.DATABASE, "test"));
191 | 		pro.setAuthenticationDatabase(formatStringValue(map, PoolAttributeTag.AUTH_DATABASE, "admin"));
192 | 		pro.setGridFsDatabase(formatStringValue(map, PoolAttributeTag.GRIDFS_DATABASE, "test"));
193 | 		pro.setUsername(formatStringValue(map, PoolAttributeTag.USERNAME, null));
194 | 		pro.setPassword(formatChatValue(map, PoolAttributeTag.PASSWORD));
195 | 		pro.setApplicationName(formatStringValue(map, PoolAttributeTag.APPLICATIONNAME, null));
196 | 		
197 | 		pro.setMinConnectionsPerHost(formatIntValue(map, PoolAttributeTag.MIN_CONN_PERHOST, 0));
198 | 		pro.setMaxConnectionsPerHost(formatIntValue(map, PoolAttributeTag.MAX_CONN_PERHOST, 100));
199 | 		pro.setThreadsAllowedToBlockForConnectionMultiplier(formatIntValue(map, PoolAttributeTag.THREADS_ALLOWED_TO_BLOCK_FOR_CONN_MULTIPLIER, 5));
200 | 		pro.setServerSelectionTimeout(formatIntValue(map, PoolAttributeTag.SERVER_SELECTION_TIMEOUT, 1000 * 30));
201 | 		pro.setMaxWaitTime(formatIntValue(map, PoolAttributeTag.MAX_WAIT_TIME, 1000 * 60 * 2));
202 | 		pro.setMaxConnectionIdleTime(formatIntValue(map, PoolAttributeTag.MAX_CONN_IDLE_TIME, 0));
203 | 		pro.setMaxConnectionLifeTime(formatIntValue(map, PoolAttributeTag.MAX_CONN_LIFE_TIME, 0));
204 | 		pro.setConnectTimeout(formatIntValue(map, PoolAttributeTag.CONN_TIMEOUT, 1000 * 10));
205 | 		pro.setSocketTimeout(formatIntValue(map, PoolAttributeTag.SOCKET_TIMEOUT, 0));
206 | 		
207 | 		pro.setSocketKeepAlive(formatBoolValue(map, PoolAttributeTag.SOCKET_KEEP_ALIVE, false));
208 | 		pro.setSslEnabled(formatBoolValue(map, PoolAttributeTag.SSL_ENABLED, false));
209 | 		pro.setSslInvalidHostNameAllowed(formatBoolValue(map, PoolAttributeTag.SSL_INVALID_HOSTNAME_ALLOWED, false));
210 | 		pro.setAlwaysUseMBeans(formatBoolValue(map, PoolAttributeTag.ALWAYS_USE_MBEANS, false));
211 | 		
212 | 		pro.setHeartbeatFrequency(formatIntValue(map, PoolAttributeTag.HEARTBEAT_FREQUENCY, 10000));
213 | 		pro.setMinHeartbeatFrequency(formatIntValue(map, PoolAttributeTag.MIN_HEARTBEAT_FREQUENCY, 500));
214 | 		pro.setHeartbeatConnectTimeout(formatIntValue(map, PoolAttributeTag.HEARTBEAT_CONN_TIMEOUT, 20000));
215 | 		pro.setHeartbeatSocketTimeout(formatIntValue(map, PoolAttributeTag.HEARTBEAT_SOCKET_TIMEOUT, 20000));
216 | 		pro.setLocalThreshold(formatIntValue(map, PoolAttributeTag.LOCAL_THRESHOLD, 15));
217 | 	}
218 | 
219 | 	private String formatStringValue(Map<String, Object> map, String key, String defaultValue) {
220 | 		if (map.containsKey(key)) {
221 | 			return map.get(key).toString();
222 | 		}
223 | 		return defaultValue;
224 | 	}
225 | 	
226 | 	private int formatIntValue(Map<String, Object> map, String key, int defaultValue) {
227 | 		if (map.containsKey(key)) {
228 | 			return Integer.valueOf(map.get(key).toString());
229 | 		}
230 | 		return defaultValue;
231 | 	}
232 | 	
233 | 	private boolean formatBoolValue(Map<String, Object> map, String key, boolean defaultValue) {
234 | 		if (map.containsKey(key)) {
235 | 			return Boolean.valueOf(map.get(key).toString());
236 | 		}
237 | 		return defaultValue;
238 | 	}
239 | 	
240 | 	private char[] formatChatValue(Map<String, Object> map, String key) {
241 | 		if (map.containsKey(key)) {
242 | 			return map.get(key).toString().toCharArray();
243 | 		}
244 | 		return new char[0];
245 | 	}
246 | }
247 | 


--------------------------------------------------------------------------------