From a3297be91f24047bd453a2e8e7b259e49ff2b8f4 Mon Sep 17 00:00:00 2001 From: wangyuan Date: Mon, 7 Jan 2019 10:00:52 +0800 Subject: [PATCH] =?UTF-8?q?=E5=86=99=E5=BA=93?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- common/build.gradle | 1 + .../ljsd/common/mogodb/LjsdMongoTemplate.java | 123 ++++++++++++++++++ .../com/ljsd/common/mogodb/MongoBase.java | 85 ++++++++++++ .../com/ljsd/common/mogodb/MongoConfig.java | 79 +++++++++++ .../com/ljsd/common/mogodb/MongoListen.java | 13 ++ .../com/ljsd/common/mogodb/MongoRoot.java | 51 ++++++++ .../common/mogodb/MongoRootConverter.java | 14 ++ .../mogodb/MongoSettingsProperties.java | 72 ++++++++++ .../ljsd/common/mogodb/MongoUpdateCache.java | 71 ++++++++++ .../mogodb/MongoUpdateCacheThreadLocal.java | 37 ++++++ .../ljsd/common/mogodb/test/TestMongo.java | 72 ++++++++++ .../mogodb/test/pojo/BaseInfoForTest.java | 44 +++++++ .../mogodb/test/pojo/PlayerForTest.java | 45 +++++++ serverlogic/build.gradle | 2 +- .../com/ljsd/jieling/GameApplication.class | Bin 4475 -> 0 bytes .../ljsd/{jieling => }/GameApplication.java | 2 +- .../network/server/ProtocolsManager.java | 2 +- 17 files changed, 710 insertions(+), 3 deletions(-) create mode 100644 common/src/main/java/com/ljsd/common/mogodb/LjsdMongoTemplate.java create mode 100644 common/src/main/java/com/ljsd/common/mogodb/MongoBase.java create mode 100644 common/src/main/java/com/ljsd/common/mogodb/MongoConfig.java create mode 100644 common/src/main/java/com/ljsd/common/mogodb/MongoListen.java create mode 100644 common/src/main/java/com/ljsd/common/mogodb/MongoRoot.java create mode 100644 common/src/main/java/com/ljsd/common/mogodb/MongoRootConverter.java create mode 100644 common/src/main/java/com/ljsd/common/mogodb/MongoSettingsProperties.java create mode 100644 common/src/main/java/com/ljsd/common/mogodb/MongoUpdateCache.java create mode 100644 common/src/main/java/com/ljsd/common/mogodb/MongoUpdateCacheThreadLocal.java create mode 100644 common/src/main/java/com/ljsd/common/mogodb/test/TestMongo.java create mode 100644 common/src/main/java/com/ljsd/common/mogodb/test/pojo/BaseInfoForTest.java create mode 100644 common/src/main/java/com/ljsd/common/mogodb/test/pojo/PlayerForTest.java delete mode 100644 serverlogic/out/production/classes/com/ljsd/jieling/GameApplication.class rename serverlogic/src/main/java/com/ljsd/{jieling => }/GameApplication.java (99%) diff --git a/common/build.gradle b/common/build.gradle index 2f708ca1c..6b8a0402e 100644 --- a/common/build.gradle +++ b/common/build.gradle @@ -13,6 +13,7 @@ repositories { dependencies { testCompile group: 'junit', name: 'junit', version: '4.12' + compile("org.springframework.boot:spring-boot-starter-data-mongodb:1.5.9.RELEASE") } diff --git a/common/src/main/java/com/ljsd/common/mogodb/LjsdMongoTemplate.java b/common/src/main/java/com/ljsd/common/mogodb/LjsdMongoTemplate.java new file mode 100644 index 000000000..64911877e --- /dev/null +++ b/common/src/main/java/com/ljsd/common/mogodb/LjsdMongoTemplate.java @@ -0,0 +1,123 @@ +package com.ljsd.common.mogodb; + +import com.mongodb.*; +import org.springframework.data.mongodb.core.MongoTemplate; + +import java.lang.ref.WeakReference; +import java.lang.reflect.Field; +import java.util.List; + + +public class LjsdMongoTemplate { + + private MongoTemplate mongoTemplate; + + public LjsdMongoTemplate( MongoTemplate mongoTemplate ){ + this.mongoTemplate = mongoTemplate; + } + + public DBCollection getCollection(String collectionName){ + return mongoTemplate.getCollection(collectionName); + } + + public void save(T obj) throws Exception { + MongoRoot root = (MongoRoot)obj; + mongoTemplate.save(obj,root.getCollection()); + root.setBsave(true); + } + + public List findAll(String collectionName, Class clazz) throws Exception { + List all = mongoTemplate.findAll(clazz, collectionName); + if(all!=null && !all.isEmpty()){ + T t = all.get(0); + if(t.getClass().getSuperclass() == MongoRoot.class){ + for(T t1 : all){ + dynamicChangeTheMongoRoot(t1, (MongoRoot) t1); + } + } + } + return all; + } + + public T findById(String collectionName, String id, Class clazz) throws Exception { + T result = mongoTemplate.findById(id, clazz, collectionName); + if(result.getClass().getSuperclass() == MongoRoot.class){ + dynamicChangeTheMongoRoot(result,(MongoRoot) result); + } + return result; + } + + public void chnage(Object obj){ + Class clazz = obj.getClass(); + } + + + public boolean remove(String collectionName, Object id) throws Exception { + //TODO 正确性未知,未测试 + DBCollection coll = mongoTemplate.getCollection(collectionName); + DBObject doc = coll.findOne(id); + if(doc == null){ + return false; + } + coll.remove(doc); + return true; + } + + public void updateValue(String collectionName, BasicDBObject searchQuery, BasicDBObject dbObject){ + DBCollection coll = mongoTemplate.getCollection(collectionName); + coll.update(searchQuery, dbObject); + } + + public void lastUpdate() throws Exception { + MongoUpdateCacheThreadLocal.update(this); + } + + public int inc(String collectionName, String id, String key){ + DBCollection collection = mongoTemplate.getCollection(collectionName); + BasicDBObject searchQuery = new BasicDBObject(); + searchQuery.put("_id", id); + // 使用collection的find方法查找document + DBCursor cursor = collection.find(searchQuery); + // 循环输出结果 + if (cursor.hasNext()) { + BasicDBObject update= new BasicDBObject().append("$inc",new BasicDBObject().append(key, 1)); + DBObject query = cursor.next(); + DBObject result = collection.findAndModify(query, update); + return Integer.valueOf(result.get(key).toString())+1; + } else { + searchQuery.put(key, 1); + collection.insert(searchQuery); + return 1; + } + } + + public int inc(String key){ + return inc("inc_c", "inc_k", key); + } + + public Object convertToMongoType(Object obj){ + return this.mongoTemplate.getConverter().convertToMongoType(obj); + } + + public void dynamicChangeTheMongoRoot(Object obj,MongoRoot mongoRoot) throws Exception { + Class clazz = obj.getClass(); + while (clazz != null && clazz != Object.class && clazz != MongoRoot.class) { + if(clazz == MongoBase.class){ + Field root = clazz.getDeclaredField("_root"); + root.setAccessible(true); + root.set(obj, new WeakReference<>(mongoRoot)); + return; + } + Field[] declaredFields = clazz.getDeclaredFields(); + for (Field tmpField : declaredFields){ + Class type = tmpField.getType(); + if(!MongoBase.class.isAssignableFrom(type)){ + continue; + } + tmpField.setAccessible(true); + dynamicChangeTheMongoRoot(tmpField.get(obj),mongoRoot); + } + clazz = clazz.getSuperclass(); + } + } +} \ No newline at end of file diff --git a/common/src/main/java/com/ljsd/common/mogodb/MongoBase.java b/common/src/main/java/com/ljsd/common/mogodb/MongoBase.java new file mode 100644 index 000000000..3beef85db --- /dev/null +++ b/common/src/main/java/com/ljsd/common/mogodb/MongoBase.java @@ -0,0 +1,85 @@ +package com.ljsd.common.mogodb; + +import org.springframework.data.annotation.Transient; + +import java.lang.ref.WeakReference; + +//使用下划线,是为了在json转换时,能转为正确的值 +public abstract class MongoBase { + @Transient + private WeakReference _root; + private String mongoKey; //该级对应的mongodb的key + @Transient + private boolean _save; + + public void init(MongoRoot root, String mongoKey, boolean _save) { + this._root = new WeakReference<>(root); + this.mongoKey = mongoKey; + this._save = _save; + } + + public void init(MongoRoot root, String mongoKey) { + this._root = new WeakReference<>(root); + this.mongoKey = mongoKey; + this._save = true; + } + + public void updateString(String fieldName, Object value) throws Exception { + MongoRoot mongoRoot = getMongoRoot(); + if (mongoRoot == null) return; + + MongoUpdateCacheThreadLocal.addUpdateRequest(this, mongoRoot.getMyMongoDBPool(), mongoRoot.getCollection(), mongoRoot.getId(), + mongoKey + "." + fieldName, value); + } + + public void updateString(String fieldName, MongoBase value) throws Exception { + MongoRoot mongoRoot = getMongoRoot(); + if (mongoRoot == null) return; + + MongoUpdateCacheThreadLocal.addUpdateRequest(value, mongoRoot.getMyMongoDBPool(), mongoRoot.getCollection(), mongoRoot.getId(), + mongoKey + "." + fieldName, value); + } + + + public void removeString(String key) { + MongoRoot mongoRoot = getMongoRoot(); + if (mongoRoot == null) return; + MongoUpdateCacheThreadLocal.removeRequest(this, mongoRoot.getMyMongoDBPool(), mongoRoot.getCollection(), mongoRoot.getId(), + mongoKey + "." + key); + } + + + private MongoRoot getMongoRoot() { + if (_root == null) { + return null; + } + MongoRoot mongoRoot = _root.get(); + if (mongoRoot == null) { + return null; + } + if (_save) { + return null; + } + return mongoRoot; + } + + public String getMongoKey() { + return mongoKey; + } + + public void setMongoKey(String mongoKey) { + this.mongoKey = mongoKey; + } + + public MongoRoot getRoot() { + return this._root.get(); + } + + public void setRoot(MongoRoot root) { + this._root = new WeakReference<>(root); + } + + public void set_save(boolean _save) { + this._save = _save; + } +} diff --git a/common/src/main/java/com/ljsd/common/mogodb/MongoConfig.java b/common/src/main/java/com/ljsd/common/mogodb/MongoConfig.java new file mode 100644 index 000000000..514f01758 --- /dev/null +++ b/common/src/main/java/com/ljsd/common/mogodb/MongoConfig.java @@ -0,0 +1,79 @@ +package com.ljsd.common.mogodb; + +import com.mongodb.*; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.boot.context.properties.ConfigurationProperties; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.data.mongodb.MongoDbFactory; +import org.springframework.data.mongodb.core.MongoTemplate; +import org.springframework.data.mongodb.core.SimpleMongoDbFactory; +import org.springframework.data.mongodb.core.convert.DefaultDbRefResolver; +import org.springframework.data.mongodb.core.convert.DefaultMongoTypeMapper; +import org.springframework.data.mongodb.core.convert.MappingMongoConverter; +import org.springframework.data.mongodb.core.mapping.MongoMappingContext; + +import java.net.UnknownHostException; + +@Configuration +public class MongoConfig { + + + // 注入配置实体 + @Autowired + private MongoSettingsProperties mongoSettingsProperties; + @Bean + @ConfigurationProperties( + prefix = "mongodb.options") + MongoSettingsProperties mongoSettingsProperties() { + return new MongoSettingsProperties(); + } + + @Value("${spring.data.mongodb.uri}") + private String MONGO_URI; + + + // 覆盖默认的MongoDbFactory + @Bean + MongoDbFactory mongoDbFactory() { + //客户端配置(连接数、副本集群验证) + MongoClientOptions.Builder builder = new MongoClientOptions.Builder(); + builder.connectionsPerHost(mongoSettingsProperties.getConnectionsPerHost()); + builder.minConnectionsPerHost(mongoSettingsProperties.getMinConnectionsPerHost()); + builder.maxWaitTime(mongoSettingsProperties.getMaxWaitTime()); + builder.socketTimeout(mongoSettingsProperties.getSocketTimeout()); + MongoClientURI mongoClientURI = new MongoClientURI(MONGO_URI,builder); + MongoDbFactory mongoDbFactory = null; + try { + mongoDbFactory = new SimpleMongoDbFactory(mongoClientURI); + } catch (UnknownHostException e) { + e.printStackTrace(); + } + return mongoDbFactory; + } + + @Bean + public MongoMappingContext mongoMappingContext() { + MongoMappingContext mappingContext = new MongoMappingContext(); + return mappingContext; + } + + @Bean //使用自定义的typeMapper去除写入mongodb时的“_class”字段 + public MappingMongoConverter mappingMongoConverter1() throws Exception { + DefaultDbRefResolver dbRefResolver = new DefaultDbRefResolver(this.mongoDbFactory()); + MappingMongoConverter converter = new MappingMongoConverter(dbRefResolver, this.mongoMappingContext()); + converter.setTypeMapper(new DefaultMongoTypeMapper(null)); + return converter; + } + + @Bean + public MongoTemplate mongoTemplate() throws Exception { + return new MongoTemplate(this.mongoDbFactory(), this.mappingMongoConverter1()); + } + + @Bean + public LjsdMongoTemplate ljsdMongoTemplate() throws Exception { + return new LjsdMongoTemplate(this.mongoTemplate()); + } +} diff --git a/common/src/main/java/com/ljsd/common/mogodb/MongoListen.java b/common/src/main/java/com/ljsd/common/mogodb/MongoListen.java new file mode 100644 index 000000000..259e87a6d --- /dev/null +++ b/common/src/main/java/com/ljsd/common/mogodb/MongoListen.java @@ -0,0 +1,13 @@ +package com.ljsd.common.mogodb; + +import com.ljsd.common.mogodb.test.pojo.PlayerForTest; +import org.springframework.data.mongodb.core.mapping.event.AbstractMongoEventListener; +import org.springframework.data.mongodb.core.mapping.event.AfterLoadEvent; + +public class MongoListen extends AbstractMongoEventListener { + + @Override + public void onAfterLoad(AfterLoadEvent event) { + super.onAfterLoad(event); + } +} diff --git a/common/src/main/java/com/ljsd/common/mogodb/MongoRoot.java b/common/src/main/java/com/ljsd/common/mogodb/MongoRoot.java new file mode 100644 index 000000000..52e505801 --- /dev/null +++ b/common/src/main/java/com/ljsd/common/mogodb/MongoRoot.java @@ -0,0 +1,51 @@ +package com.ljsd.common.mogodb; + +import org.springframework.data.annotation.Transient; + +//使用下划线,是为了在json转换时,能转为正确的值 +public abstract class MongoRoot { + @Transient + private boolean _bsave; //是否已经保存到了数据库 + @Transient + private LjsdMongoTemplate _ljsdMongoTemplate; //对应的mongodb连接池 + private String id; //如果是mongodb的根,则需要设置id + + public MongoRoot() { + + } + + public MongoRoot(String id) { + this.id = id; + } + + public String getId() { + return id; + } + + public int _getIntId() { + return Integer.valueOf(id); + } + + public void setId(String id) { + this.id = id; + } + + public abstract String getCollection(); + + public LjsdMongoTemplate getMyMongoDBPool() { + return _ljsdMongoTemplate; + } + + + public boolean isBsave() { + return _bsave; + } + + public void setBsave(boolean bsave) { + this._bsave = bsave; + } + + public void setMyMongoDBPool(LjsdMongoTemplate _ljsdMongoTemplate) { + this._ljsdMongoTemplate = _ljsdMongoTemplate; + } +} diff --git a/common/src/main/java/com/ljsd/common/mogodb/MongoRootConverter.java b/common/src/main/java/com/ljsd/common/mogodb/MongoRootConverter.java new file mode 100644 index 000000000..a90c0b29e --- /dev/null +++ b/common/src/main/java/com/ljsd/common/mogodb/MongoRootConverter.java @@ -0,0 +1,14 @@ +/*package com.ljsd.common.mogodb; + +import com.ljsd.common.mogodb.test.pojo.PlayerForTest; +import org.springframework.core.convert.converter.Converter; +import org.springframework.data.convert.ReadingConverter; +import org.springframework.data.mongodb.core.mapping.Document; +@ReadingConverter +public class MongoRootConverter implements Converter { + @Override + public PlayerForTest convert(Document source) { + System.out.println("123"); + return null; + } +}*/ diff --git a/common/src/main/java/com/ljsd/common/mogodb/MongoSettingsProperties.java b/common/src/main/java/com/ljsd/common/mogodb/MongoSettingsProperties.java new file mode 100644 index 000000000..0ddb94936 --- /dev/null +++ b/common/src/main/java/com/ljsd/common/mogodb/MongoSettingsProperties.java @@ -0,0 +1,72 @@ +package com.ljsd.common.mogodb; + +import org.springframework.stereotype.Component; +@Component +public class MongoSettingsProperties { + + private int maxWaitTime; + private int connectTimeout; + private int socketTimeout; + private int threadsAllowedToBlockForConnectionMultiplier; + private int connectionsPerHost; + private int minConnectionsPerHost; + private int maxConnectionIdleTime; + + + + public int getMaxWaitTime() { + return maxWaitTime; + } + + public void setMaxWaitTime(int maxWaitTime) { + this.maxWaitTime = maxWaitTime; + } + + public int getConnectTimeout() { + return connectTimeout; + } + + public void setConnectTimeout(int connectTimeout) { + this.connectTimeout = connectTimeout; + } + + public int getSocketTimeout() { + return socketTimeout; + } + + public void setSocketTimeout(int socketTimeout) { + this.socketTimeout = socketTimeout; + } + + public int getThreadsAllowedToBlockForConnectionMultiplier() { + return threadsAllowedToBlockForConnectionMultiplier; + } + + public void setThreadsAllowedToBlockForConnectionMultiplier(int threadsAllowedToBlockForConnectionMultiplier) { + this.threadsAllowedToBlockForConnectionMultiplier = threadsAllowedToBlockForConnectionMultiplier; + } + + public int getConnectionsPerHost() { + return connectionsPerHost; + } + + public void setConnectionsPerHost(int connectionsPerHost) { + this.connectionsPerHost = connectionsPerHost; + } + + public int getMinConnectionsPerHost() { + return minConnectionsPerHost; + } + + public void setMinConnectionsPerHost(int minConnectionsPerHost) { + this.minConnectionsPerHost = minConnectionsPerHost; + } + + public int getMaxConnectionIdleTime() { + return maxConnectionIdleTime; + } + + public void setMaxConnectionIdleTime(int maxConnectionIdleTime) { + this.maxConnectionIdleTime = maxConnectionIdleTime; + } +} diff --git a/common/src/main/java/com/ljsd/common/mogodb/MongoUpdateCache.java b/common/src/main/java/com/ljsd/common/mogodb/MongoUpdateCache.java new file mode 100644 index 000000000..ca82db456 --- /dev/null +++ b/common/src/main/java/com/ljsd/common/mogodb/MongoUpdateCache.java @@ -0,0 +1,71 @@ +package com.ljsd.common.mogodb; + +import ch.qos.logback.core.joran.util.beans.BeanUtil; +import com.mongodb.BasicDBObject; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +public class MongoUpdateCache { + class UpdateRequest { + MongoBase mongoBase; + String fullKey; + Object value; + int opCode; + + UpdateRequest(String fullKey, Object value, int opCode, MongoBase mongoBase) { + this.fullKey = fullKey; + this.value = value; + this.opCode = opCode; + this.mongoBase = mongoBase; + } + } + + //key:String, collection + ":" + id + private final Map> requestMap = new HashMap<>(); + + protected void addUpdateRequest(MongoBase mongoBase, String collection, String id, String fullKey, Object value, int opCode) { + String key = collection + ":" + id; + List listRequest = requestMap.get(key); + if (listRequest == null) { + listRequest = new ArrayList(); + requestMap.put(key, listRequest); + } + UpdateRequest request = new UpdateRequest(fullKey, value, opCode, mongoBase); + listRequest.add(request); + } + + protected void update(LjsdMongoTemplate ljsdMongoTemplate) throws IllegalAccessException { + BasicDBObject searchQuery = new BasicDBObject(); + + for (Map.Entry> entry : requestMap.entrySet()) { + String[] strs = entry.getKey().split(":"); + String collection = strs[0]; + String id = strs[1]; + + searchQuery.put("_id", id); + BasicDBObject valueDBObj = new BasicDBObject(); + BasicDBObject dbobj = new BasicDBObject(); + BasicDBObject removedbobj = new BasicDBObject(); + for (UpdateRequest request : entry.getValue()) { + if (request.opCode == 2) { + removedbobj.append(request.fullKey, request.value); + continue; + } + valueDBObj.append(request.fullKey, ljsdMongoTemplate.convertToMongoType(request.value)); + request.mongoBase.set_save(false); + } + dbobj.append("$set", valueDBObj); + if (!removedbobj.isEmpty()) { + dbobj.append("$unset", removedbobj); + } + + ljsdMongoTemplate.updateValue(collection, searchQuery, dbobj); + + } + requestMap.clear(); + } + +} diff --git a/common/src/main/java/com/ljsd/common/mogodb/MongoUpdateCacheThreadLocal.java b/common/src/main/java/com/ljsd/common/mogodb/MongoUpdateCacheThreadLocal.java new file mode 100644 index 000000000..73524b979 --- /dev/null +++ b/common/src/main/java/com/ljsd/common/mogodb/MongoUpdateCacheThreadLocal.java @@ -0,0 +1,37 @@ +package com.ljsd.common.mogodb; + +import java.util.HashMap; +import java.util.Map; + +public class MongoUpdateCacheThreadLocal { + private final static ThreadLocal> mongoUpdateCacheThreadLocal = new ThreadLocal<>(); + + private static MongoUpdateCache getMongoUpdateCache(LjsdMongoTemplate ljsdMongoTemplate) { + Map mongoUpdateCacheMap = mongoUpdateCacheThreadLocal.get(); + if (mongoUpdateCacheMap == null) { + mongoUpdateCacheMap = new HashMap(); + mongoUpdateCacheThreadLocal.set(mongoUpdateCacheMap); + } + MongoUpdateCache mongoUpdateCache = mongoUpdateCacheMap.get(ljsdMongoTemplate); + if (mongoUpdateCache == null) { + mongoUpdateCache = new MongoUpdateCache(); + mongoUpdateCacheMap.put(ljsdMongoTemplate, mongoUpdateCache); + } + return mongoUpdateCache; + } + + protected static void addUpdateRequest(MongoBase mongoBase, LjsdMongoTemplate ljsdMongoTemplate, String collection, String id, String fullKey, Object value) { + MongoUpdateCache mongoUpdateCache = getMongoUpdateCache(ljsdMongoTemplate); + mongoUpdateCache.addUpdateRequest(mongoBase, collection, id, fullKey, value, 1); + } + + protected static void removeRequest(MongoBase mongoBase, LjsdMongoTemplate ljsdMongoTemplate, String collection, String id, String fullKey) { + MongoUpdateCache mongoUpdateCache = getMongoUpdateCache(ljsdMongoTemplate); + mongoUpdateCache.addUpdateRequest(mongoBase, collection, id, fullKey, "", 2); + } + + protected static void update(LjsdMongoTemplate ljsdMongoTemplate) throws IllegalAccessException { + MongoUpdateCache mongoUpdateCache = getMongoUpdateCache(ljsdMongoTemplate); + mongoUpdateCache.update(ljsdMongoTemplate); + } +} diff --git a/common/src/main/java/com/ljsd/common/mogodb/test/TestMongo.java b/common/src/main/java/com/ljsd/common/mogodb/test/TestMongo.java new file mode 100644 index 000000000..d9c175c77 --- /dev/null +++ b/common/src/main/java/com/ljsd/common/mogodb/test/TestMongo.java @@ -0,0 +1,72 @@ +package com.ljsd.common.mogodb.test; + +import com.ljsd.common.mogodb.LjsdMongoTemplate; +import com.ljsd.common.mogodb.test.pojo.BaseInfoForTest; +import com.ljsd.common.mogodb.test.pojo.PlayerForTest; +import com.mongodb.MongoClientURI; +import org.springframework.data.mongodb.core.MongoTemplate; +import org.springframework.data.mongodb.core.SimpleMongoDbFactory; +import org.springframework.data.mongodb.core.convert.DefaultDbRefResolver; +import org.springframework.data.mongodb.core.convert.DefaultMongoTypeMapper; +import org.springframework.data.mongodb.core.convert.MappingMongoConverter; +import org.springframework.data.mongodb.core.mapping.MongoMappingContext; + +import java.net.UnknownHostException; + +public class TestMongo { + private static LjsdMongoTemplate ljsdMongoTemplate; + + public static void main(String[] args) { + try { + ljsdMongoTemplate = getLjsdMongoTemplate(); + PlayerForTest.init(ljsdMongoTemplate); + //save(); + PlayerForTest one = findOne(); + update(one); + System.out.println(); + + } catch (UnknownHostException e) { + e.printStackTrace(); + } catch (Exception e) { + e.printStackTrace(); + } + } + + public static void update(PlayerForTest playerForTest) throws Exception { + BaseInfoForTest baseInfoForTest = playerForTest.getBaseInfoForTest(); + baseInfoForTest.setName("222222522"); + ljsdMongoTemplate.lastUpdate(); + + } + + public static PlayerForTest findOne() throws Exception { + return ljsdMongoTemplate.findById(PlayerForTest.getCollectionName(),"1",PlayerForTest.class); + } + + public static void save() throws Exception { + BaseInfoForTest baseInfoForTest = new BaseInfoForTest(); + baseInfoForTest.setAge(10); + baseInfoForTest.setName("test"); + PlayerForTest playerForTest = new PlayerForTest(1,baseInfoForTest); + ljsdMongoTemplate.save(playerForTest); + System.out.println(ljsdMongoTemplate); + } + + public static LjsdMongoTemplate getLjsdMongoTemplate() throws UnknownHostException { + SimpleMongoDbFactory simpleMongoDbFactory = new SimpleMongoDbFactory(new MongoClientURI("mongodb://60.1.1.14:27017/ysj_20215999999")); + DefaultDbRefResolver dbRefResolver = new DefaultDbRefResolver(simpleMongoDbFactory); + MappingMongoConverter converter = new MappingMongoConverter(dbRefResolver, new MongoMappingContext()); + converter.setTypeMapper(new DefaultMongoTypeMapper(null)); + // MongoTemplate mongoTemplate = new MongoTemplate(simpleMongoDbFactory, converter); + /* MappingMongoConverter mongoMapping = (MappingMongoConverter) mongoTemplate.getConverter(); + mongoMapping.setCustomConversions(customConversions()); // tell mongodb to use the custom converters + mongoMapping.afterPropertiesSet();*/ + return new LjsdMongoTemplate(new MongoTemplate(simpleMongoDbFactory, converter)); + } + + /* private static CustomConversions customConversions() { + List> converterList = new ArrayList>(); + converterList.add(new MongoRootConverter()); + return new CustomConversions(converterList); + }*/ +} diff --git a/common/src/main/java/com/ljsd/common/mogodb/test/pojo/BaseInfoForTest.java b/common/src/main/java/com/ljsd/common/mogodb/test/pojo/BaseInfoForTest.java new file mode 100644 index 000000000..937f6fae2 --- /dev/null +++ b/common/src/main/java/com/ljsd/common/mogodb/test/pojo/BaseInfoForTest.java @@ -0,0 +1,44 @@ +package com.ljsd.common.mogodb.test.pojo; + +import com.ljsd.common.mogodb.MongoBase; + +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; + +public class BaseInfoForTest extends MongoBase { + private String name; + private int age; + + private Map otherInfoMsg = new ConcurrentHashMap<>(); + + public BaseInfoForTest(){ + + } + + public String getName() { + return name; + } + + public void setName(String name) throws Exception { + updateString("name", name); + this.name = name; + } + + public int getAge() { + return age; + } + + public void setAge(int age) throws Exception { + updateString("age", name); + this.age = age; + } + + public Map getOtherInfoMsg() { + return otherInfoMsg; + } + + public void setOtherInfoMsg(Map otherInfoMsg) throws Exception { + updateString("otherInfoMsg", name); + this.otherInfoMsg = otherInfoMsg; + } +} diff --git a/common/src/main/java/com/ljsd/common/mogodb/test/pojo/PlayerForTest.java b/common/src/main/java/com/ljsd/common/mogodb/test/pojo/PlayerForTest.java new file mode 100644 index 000000000..1b1cc15e0 --- /dev/null +++ b/common/src/main/java/com/ljsd/common/mogodb/test/pojo/PlayerForTest.java @@ -0,0 +1,45 @@ +package com.ljsd.common.mogodb.test.pojo; + +import com.ljsd.common.mogodb.LjsdMongoTemplate; +import com.ljsd.common.mogodb.MongoRoot; + +public class PlayerForTest extends MongoRoot { + private final static String _COLLECTION_NAME = "play_test"; + private BaseInfoForTest baseInfoForTest; + + private static LjsdMongoTemplate _ljsdMongoTemplate; + + public static void init( LjsdMongoTemplate ljsdMongoTemplate){ + _ljsdMongoTemplate = ljsdMongoTemplate; + } + + public PlayerForTest(int playerId,BaseInfoForTest baseInfoForTest){ + setId(String.valueOf(playerId)); + this.baseInfoForTest = baseInfoForTest; + baseInfoForTest.init(this,"baseInfoForTest",false); + } + + public PlayerForTest(){ + setMyMongoDBPool(_ljsdMongoTemplate); + this.baseInfoForTest = new BaseInfoForTest(); + baseInfoForTest.init(this,"baseInfoForTest",false); + } + + + public BaseInfoForTest getBaseInfoForTest() { + return baseInfoForTest; + } + + public void setBaseInfoForTest(BaseInfoForTest baseInfoForTest) { + this.baseInfoForTest = baseInfoForTest; + } + + public static String getCollectionName() { + return _COLLECTION_NAME; + } + + @Override + public String getCollection() { + return _COLLECTION_NAME; + } +} diff --git a/serverlogic/build.gradle b/serverlogic/build.gradle index f02e8c0ce..e802635ab 100644 --- a/serverlogic/build.gradle +++ b/serverlogic/build.gradle @@ -18,11 +18,11 @@ dependencies { compile project(":netty") compile project(":hotfix") + compile project(":common") compile("org.javassist:javassist:3.18.2-GA") compile("org.springframework.boot:spring-boot:1.5.9.RELEASE") compile("org.springframework.boot:spring-boot-starter-test:1.5.9.RELEASE") - compile("org.springframework.boot:spring-boot-starter-data-mongodb:1.5.9.RELEASE") compile("org.springframework.boot:spring-boot-starter-data-redis:1.5.9.RELEASE") compile("io.netty:netty-all:4.0.21.Final") compile("com.google.protobuf:protobuf-java:2.5.0") diff --git a/serverlogic/out/production/classes/com/ljsd/jieling/GameApplication.class b/serverlogic/out/production/classes/com/ljsd/jieling/GameApplication.class deleted file mode 100644 index d3952b8dc1e9995e98f2f09d2c16267e50d9d77b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 4475 zcmb7I`(G5-75`q?b(Y;hbVU)P#+axJ3X?=*Di9(P)HQ(0QY@ym9d?IhaGBZ8%%X&* z?<9TN^xZUV`YwI9LJOiMP2X+Wq>tbF5A=`d4@tjwb{7_QA(qc)@11++oO93lo^#JR z!>e!Hd>OzI{40zAGBpTdLV=~gR*(&&8t;``j(l?E;K?B;_a?)*f~yLqB6t$h5xfsi zMeu%nAc7C#Lvr}AB>0Gek4l24!>GqIlJD6NJ{G~p@d*W=3}Xi}3O*Iar*TaVpOM3J za`VrzQN&u531ACUwuWt#*OkN!uDV(>X^U$rvTC zx^2rdu6hC;73GmjzSc;#4mag*=skPtRL_7wG%qJJdSqPdwbNl|8iHoG{FfG&TBxtdwA%Q@*oiYUKdQHpd&rOUN&Y;A@*E*?ZhIGf2 z>%wNh8#7&jz2)jk6SyT<7}9Yt<* z4cDdjPU=a|cBTX#EaxO{zTXR^T0F6Whf)Ns+ghSi&()-nEd)hCchWR)O9h<;Hf0^# zvy*nl?b9utetZiBq;Iuzt9YnDZJJ<7s|=@4r_bv0%H%vVqj7^2b+jVy>U@|9JiNB0 zesJWeyKJZwhA{dhpd5AZ`3Ka#_b@e>sf;xOH=;-~nT zztTXmVOZlIQ*X6mj1wr{E7+QrjVJ{ZE zR@bw$m3MM1!sja%;fjfiK;Kz^6Df%efg`b|@|<71 zY588IQYmb!ly~k-1-1j!;Dn)D?%B~n7AN*4v64#EozY#ly=i5sV$R$!sb_Ms7H+4? z%g*e!Ga06`d~aA^X`kiBT=Mv~70ks*pm?@5Zol6@vcY1%6|nq8eUaYp%nDv*VbfEo zLVqLB6f1|YLiY26K`GcSuy0MHR~{85M_Du;TF-5(sA=3L-(4l0EbTL`QJW1_sTPGM zK*nU4rw%5w=WN-35)t;Q(rp8Vo*HB&wsYLBnVa;GbkSz7C{IRDDgVQb?z zWXqw|HR5^>+r##9;$r@lm1$K|Sk$zSy&@YsHV`Y^wcJSazRLT4tb(;Ap;vHk`Hnm% zAd??&^J*xUn%Wu~pZ`u+!?~+D+i?%Sg97}xQxKLVmQP_>RypsG<;!2QGH|YuiO`?h z(C*Ky|C|F5vK`=foGXp9;2dmTfVj?wDs*w&;BPkK1fSJB0lM)RS2gItNm3mL#J>?D zCGdJ+4pp~MJsfxmf#K?CFtLCQb5LfXRL>)npK3TY&m%mC$PK8yvxr1%7qPJleTNoN zCs@cg3G}xtVza>WXy8Ls;1$%i1r9a_=CNhw&HqTA`bBK5;(mR9%RIKV1!mC@-M)y% zDmDQ-h8J*GTksZk4oj9@a@Z}0yXCNl$2JBRaL*j}&SLL8?wz54pcJsLF*uL?jlo46 z2;e&Hon~`!li#HQAB`bwrIq`+I)Dbmup3R-hl2!9BlL#}=Mh{Y_$eGkny}{x{4_y- zn)Ue_-@Zt=uT#cPzVI(lfFZgNBZ^sa&Tp+FVTAu11q#EYVK?L5w83h*=JfYy7 z|HaNXDIuufUB$gi3f>K&;5||3WRQ_E!uVpT=F@TR%=ml2W7TxH1TN+y@1xl?gDsEC zy=HoOf3pvzTplctL>6&Ku!n1i(zSG#gn1+XfzUvht9_W8c@}7XfQE0R$@Mg~frf9V z(FbVm12pg$P3)$D#lYN-Iv*zZCMu}9K=td0X=+L7I1iG4y97g$zeqHA1Fdst;PYM@ zqDf<9=(9EAxWf