安科网

mongodb+spring +morphia完整版框架搭建

LemonSnm

LemonSnm

2016-09-09

关注 关注
  • Morphia是一个开放源代码的对象关系映射框架，它对MongoDB数据库java版驱动进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵MongoDB数据库，也让Java程序员可以从复杂数据库设计中脱离出来，从而将更多的精力投入到业务逻辑中去。Morphia是一个轻量级的类型安全的Java对象to/fromMongoDB库.Morphia提高了通过注解的方式来保存mongodbcollection。
  • @Id注释指示Morphia哪个字段用作文档ID。如果试图持久保存对象（其@Id注释的字段为null），则Morphia会自动生成ID值。@Entity@Entity注释是必需的。其声明了在专用MongoDB集合上该类作为文档将持久保存。在默认情况下，Morphia使用类名称来命名集合。@Embedded@Embedded注释说明Morphia将此对象实例嵌入到另一个对象中去。而不单独的放到一个MongoDB集合。@Reference@Reference注释说明对象是对另外一个集合中的文档的引用。在从MongoDB集合中加载对象时，Morphia遵循着这些引用来建立对象关系。@Indexed类属性标记@Indexed注释，表明为此属性增加索引。@Property类属性标记@Property注释，表明为此属性在MongoDB数据库取一个别名。@Transient类属性标记@Transient注释则表明这个字段将不被持久化到数据库。4.Morphia编程模型
  • 1.定义被持久类@EntityclassMyEntity{@IdObjectIdid;Stringname;}2.
  • 初始化morphiaMongomongo=newMongo("localhost");//连接到本地mongoDB数据库Morphiamorphia=newMorphia();morphia.mapPackage("MyEntity");//
  • 告诉Morphia映射哪些类Datastoreds=morphia.createDatastore(mongo,"myDB");//创建名为“myDB”数据库，
  • mongo最好使用单实例模式ds.ensureIndexes();//在标记为@Id的类属性上创建索引ds.ensureCaps();//设置默认的mongoDB集合容量3.保存被持久化类MyEntitye=...;ds.save(e);//将MyEntity对象持久化到mongoDB数据库中4.查询MyEntitye=ds.find(MyEntity.class).get();//通过类型取的第一个数据项MyEntitye=ds.find(MyEntity.class).field("name")

Datastore接口把Java对象保存到MongoDB或从MongoDB中访问Java对象提供了安全类型的方法。它提供了get/find/save/delete方法为你操作Java对象。

来看代码吧。

配置文件xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/context
          http://www.springframework.org/schema/context/spring-context-3.0.xsd
          http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
          http://www.springframework.org/schema/tx
          http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
          
     <bean id="propertyConfigurer"
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="order" value="1" />
		<property name="ignoreUnresolvablePlaceholders" value="true" />
		<property name="locations">
			<list>
				<value>classpath:demo-provider-module.properties</value>
			</list>
		</property>
	</bean>
	<!-- writeConcern  -->
	<bean id="writeConcern" class="com.mongodb.WriteConcern">
		<!-- 对应全局的WriteConcern中的w，默认为0 -->
		<constructor-arg name="w" value="0" />
		<!-- 对应全局的WriteConcern中的wtimeout，默认为0 -->
		<constructor-arg name="wTimeoutMS" value="0" />
		<!-- 对应全局的WriteConcern.FSYNC_SAFE，如果为真，每次写入要等待写入磁盘，默认为false -->
		<constructor-arg name="fsync" value="false" />
		<!-- 对应全局的WriteConcern.JOURNAL_SAFE，如果为真，每次写入要等待日志文件写入磁盘，默认为false -->
		<constructor-arg name="journal" value="false" />
	</bean>
	
	<bean id="mongoClientOption" class="demo.dcn.mongodb.MongoClientOption">
		<property name="minConnectionsPerHost" value="50" />
		<property name="maxConnectionsPerHost" value="200" />
		<property name="threadsAllowedToBlockForConnectionMultiplier" value="20" />
		<property name="maxWaitTime" value="12000" />
		<property name="maxConnectionIdleTime" value="0" />
		<property name="maxConnectionLifeTime" value="0" />
		<property name="connectTimeout" value="3000" />
		<property name="socketTimeout" value="60000" />
		<property name="socketKeepAlive" value="true" />
		<property name="writeConcern" ref="writeConcern" />
    </bean>
	<!-- 使用工厂创建mongo实例 -->
	<bean id="mongo" class="demo.dcn.mongodb.MongoFactoryBean">
		<!-- mongoDB的配置对象 -->
		<property name="mongoOption" ref="mongoClientOption"/>
		<!-- 是否主从分离(读取从库)，默认为false，读写都在主库 -->
		<!-- <property name="readSecondary" value="true" /> -->

		<!-- 设定写策略，默认为WriteConcern.SAFE，优先级高于mongoOptions中的safe -->
		<property name="writeConcern" value="SAFE" />

		<!-- 设定服务器列表，默认为localhost:27017 -->
		<property name="serverStrings">
			<array>
				<value>${mongo.db.host_master}</value>
				<!-- <value>${mongo.db.host_salve}</value> -->
			</array>
		</property>
		<!-- 设定认证参数列表，默认为空 -->
		<!-- <property name="credentialStrings">
			<array>
			   <value>${mongo.db.credential_1}</value>
			</array>
		</property> -->
	</bean>
	
	<!-- 使用工厂创建morphia实例，同时完成类映射操作 -->
	<bean id="morphia"
		class="demo.dcn.mongodb.MorphiaFactoryBean">
		<!-- 指定要扫描的POJO包路径 -->
		<property name="mapPackages">
			<array>
				<value>demo.dcn.mongodb.vo</value>
			</array>
		</property>
	</bean>
	<!-- 使用工厂创建datastore，同时完成index和caps的确认操作 -->
	<bean id="datastore"
		class="demo.dcn.mongodb.DataStoreFactoryBean">
		<property name="morphia" ref="morphia" />
		<property name="mongo" ref="mongo" />
		<property name="dbName" value="${mongo.db.databaseName_1}" />
		<!-- 是否进行index和caps的确认操作，默认为flase -->
		<property name="toEnsureIndexes" value="true" /><!-- 是否确认索引存在，默认false -->
		<property name="toEnsureCaps" value="true" /><!-- 是否确认caps存在，默认false -->
	</bean>
</beans>

dataStoreFactoryBean工厂指定数据连接获取mongo,marphiadb对象。

package demo.dcn.mongodb;

import org.mongodb.morphia.Datastore;
import org.mongodb.morphia.Morphia;
import org.springframework.beans.factory.config.AbstractFactoryBean;
import com.mongodb.MongoClient;
public class DataStoreFactoryBean extends AbstractFactoryBean<Datastore> {
代码: 
...
(支持java, ruby, js, xml, html, php, python, c, c++, c#, sql)

privateMorphiamorphia;//morphia实例，最好是单例

privateMongoClientmongo;//mongo实例，最好是单例

privateStringdbName;//数据库名

privatebooleantoEnsureIndexes=false;//是否确认索引存在，默认false

privatebooleantoEnsureCaps=false;//是否确认caps存在，默认false

@Override

protectedDatastorecreateInstance()throwsException{

Datastoreds=morphia.createDatastore(mongo,dbName);

if(toEnsureIndexes){

ds.ensureIndexes();

}

if(toEnsureCaps){

ds.ensureCaps();

}

returnds;

}

@Override

publicClass<?>getObjectType(){

returnDatastore.class;

}

@Override

publicvoidafterPropertiesSet()throwsException{

super.afterPropertiesSet();

if(mongo==null){

thrownewIllegalStateException("mongoisnotset");

}

if(morphia==null){

thrownewIllegalStateException("morphiaisnotset");

}

}

/*----------------------setters-----------------------*/

publicMorphiagetMorphia(){

returnmorphia;

}

publicvoidsetMorphia(Morphiamorphia){

this.morphia=morphia;

}

publicMongoClientgetMongo(){

returnmongo;

}

publicvoidsetMongo(MongoClientmongo){

this.mongo=mongo;

}

publicStringgetDbName(){

returndbName;

}

publicvoidsetDbName(StringdbName){

this.dbName=dbName;

}

publicbooleanisToEnsureIndexes(){

returntoEnsureIndexes;

}

publicvoidsetToEnsureIndexes(booleantoEnsureIndexes){

this.toEnsureIndexes=toEnsureIndexes;

}

publicbooleanisToEnsureCaps(){

returntoEnsureCaps;

}

publicvoidsetToEnsureCaps(booleantoEnsureCaps){

this.toEnsureCaps=toEnsureCaps;

}

}

MongoClientOptionmongodb连接对象参数设定。

package demo.dcn.mongodb;

import javax.net.SocketFactory;

import org.bson.codecs.configuration.CodecRegistry;

import com.mongodb.DBDecoderFactory;
import com.mongodb.DBEncoderFactory;
import com.mongodb.DefaultDBDecoder;
import com.mongodb.DefaultDBEncoder;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.MongoClientOptions.Builder;
import com.mongodb.ReadPreference;
import com.mongodb.WriteConcern;

public class MongoClientOption {
	private String description;
	private ReadPreference readPreference = ReadPreference.primary();//读写分离
	private WriteConcern writeConcern = WriteConcern.ACKNOWLEDGED;//write concern 来让用户自己衡量性能和写安全 Acknowledged 中等级别，能够拿到mongodb返回的信息。默认是这个设置
	private CodecRegistry codecRegistry = MongoClient.getDefaultCodecRegistry();
	private int minConnectionsPerHost;
	private int maxConnectionsPerHost = 100; //最大的连接数
	private int threadsAllowedToBlockForConnectionMultiplier = 5;//线程队列数，它以上面connectionsPerHost值相乘的结果就是线程队列最大值。如果连接线程排满了队列就会抛出“Out of semaphores to get db”错误。
	private int serverSelectionTimeout = 1000 * 30;
	private int maxWaitTime = 1000 * 60 * 2;//最大等待连接的线程阻塞时间2分钟
	private int maxConnectionIdleTime;
	private int maxConnectionLifeTime;//最大连接存活数
	private int connectTimeout = 1000 * 10;//连接超时的毫秒。0是默认和无限
	private int socketTimeout = 0;//socket超时。0是默认和无限
	private boolean socketKeepAlive = false;
	private boolean sslEnabled = false;
	private boolean sslInvalidHostNameAllowed = false;
	private boolean alwaysUseMBeans = false;
	private int heartbeatFrequency = 10000;
	private int minHeartbeatFrequency = 500;
	private int heartbeatConnectTimeout = 20000;
	private int heartbeatSocketTimeout = 20000;
	private int localThreshold = 15;
	private boolean autoConnectRetry = true;//是否自动连接
	private String requiredReplicaSetName;
	private DBDecoderFactory dbDecoderFactory = DefaultDBDecoder.FACTORY;//Mongo Java驱动程序配置
	private DBEncoderFactory dbEncoderFactory = DefaultDBEncoder.FACTORY;//mongo java 编码工厂
	private SocketFactory socketFactory = SocketFactory.getDefault();//socket 工厂
	private boolean cursorFinalizerEnabled = true;

	public void setDescription(String description) {
		this.description = description;
	}

	public void setReadPreference(ReadPreference readPreference) {
		this.readPreference = readPreference;
	}

	public void setWriteConcern(WriteConcern writeConcern) {
		this.writeConcern = writeConcern;
	}

	public void setCodecRegistry(CodecRegistry codecRegistry) {
		this.codecRegistry = codecRegistry;
	}

	public void setMinConnectionsPerHost(int minConnectionsPerHost) {
		this.minConnectionsPerHost = minConnectionsPerHost;
	}

	public void setMaxConnectionsPerHost(int maxConnectionsPerHost) {
		this.maxConnectionsPerHost = maxConnectionsPerHost;
	}

	public void setThreadsAllowedToBlockForConnectionMultiplier(int threadsAllowedToBlockForConnectionMultiplier) {
		this.threadsAllowedToBlockForConnectionMultiplier = threadsAllowedToBlockForConnectionMultiplier;
	}

	public void setServerSelectionTimeout(int serverSelectionTimeout) {
		this.serverSelectionTimeout = serverSelectionTimeout;
	}

	public void setMaxWaitTime(int maxWaitTime) {
		this.maxWaitTime = maxWaitTime;
	}

	public void setMaxConnectionIdleTime(int maxConnectionIdleTime) {
		this.maxConnectionIdleTime = maxConnectionIdleTime;
	}

	public void setMaxConnectionLifeTime(int maxConnectionLifeTime) {
		this.maxConnectionLifeTime = maxConnectionLifeTime;
	}

	public void setConnectTimeout(int connectTimeout) {
		this.connectTimeout = connectTimeout;
	}

	public void setSocketTimeout(int socketTimeout) {
		this.socketTimeout = socketTimeout;
	}

	public void setSocketKeepAlive(boolean socketKeepAlive) {
		this.socketKeepAlive = socketKeepAlive;
	}

	public void setSslEnabled(boolean sslEnabled) {
		this.sslEnabled = sslEnabled;
	}

	public void setSslInvalidHostNameAllowed(boolean sslInvalidHostNameAllowed) {
		this.sslInvalidHostNameAllowed = sslInvalidHostNameAllowed;
	}

	public void setAlwaysUseMBeans(boolean alwaysUseMBeans) {
		this.alwaysUseMBeans = alwaysUseMBeans;
	}

	public void setHeartbeatFrequency(int heartbeatFrequency) {
		this.heartbeatFrequency = heartbeatFrequency;
	}

	public void setMinHeartbeatFrequency(int minHeartbeatFrequency) {
		this.minHeartbeatFrequency = minHeartbeatFrequency;
	}

	public void setHeartbeatConnectTimeout(int heartbeatConnectTimeout) {
		this.heartbeatConnectTimeout = heartbeatConnectTimeout;
	}

	public void setHeartbeatSocketTimeout(int heartbeatSocketTimeout) {
		this.heartbeatSocketTimeout = heartbeatSocketTimeout;
	}

	public void setLocalThreshold(int localThreshold) {
		this.localThreshold = localThreshold;
	}

	public void setRequiredReplicaSetName(String requiredReplicaSetName) {
		this.requiredReplicaSetName = requiredReplicaSetName;
	}

	public void setDbDecoderFactory(DBDecoderFactory dbDecoderFactory) {
		this.dbDecoderFactory = dbDecoderFactory;
	}

	public void setDbEncoderFactory(DBEncoderFactory dbEncoderFactory) {
		this.dbEncoderFactory = dbEncoderFactory;
	}

	public void setSocketFactory(SocketFactory socketFactory) {
		this.socketFactory = socketFactory;
	}

	public void setCursorFinalizerEnabled(boolean cursorFinalizerEnabled) {
		this.cursorFinalizerEnabled = cursorFinalizerEnabled;
	}

	public MongoClientOptions getMongoClientOptions() {
		Builder builder = MongoClientOptions.builder();
		builder.connectionsPerHost(maxConnectionsPerHost);
		builder.connectTimeout(connectTimeout);
		builder.description(description);
		builder.heartbeatConnectTimeout(heartbeatConnectTimeout);
		builder.heartbeatSocketTimeout(heartbeatSocketTimeout);
		builder.localThreshold(localThreshold);
		builder.maxConnectionIdleTime(maxConnectionIdleTime);
		builder.maxConnectionLifeTime(maxConnectionLifeTime);
		builder.minConnectionsPerHost(minConnectionsPerHost);
		builder.minHeartbeatFrequency(minHeartbeatFrequency);
		builder.readPreference(readPreference);
		builder.requiredReplicaSetName(requiredReplicaSetName);
		builder.serverSelectionTimeout(serverSelectionTimeout);
		builder.alwaysUseMBeans(alwaysUseMBeans);
		builder.socketFactory(socketFactory);
		builder.socketKeepAlive(socketKeepAlive);
		builder.sslEnabled(sslEnabled);
		builder.sslInvalidHostNameAllowed(sslInvalidHostNameAllowed);
		builder.threadsAllowedToBlockForConnectionMultiplier(threadsAllowedToBlockForConnectionMultiplier);
		builder.writeConcern(writeConcern);
		builder.codecRegistry(codecRegistry);
		builder.maxWaitTime(maxWaitTime);
		builder.socketTimeout(socketTimeout);
		builder.heartbeatFrequency(heartbeatFrequency);
		builder.dbDecoderFactory(dbDecoderFactory);
		builder.dbEncoderFactory(dbEncoderFactory);
		builder.cursorFinalizerEnabled(cursorFinalizerEnabled);
		return builder.build();
	}

	public boolean isAutoConnectRetry() {
		return autoConnectRetry;
	}

	public void setAutoConnectRetry(boolean autoConnectRetry) {
		this.autoConnectRetry = autoConnectRetry;
	}
}

MongoFactoryBeanmongodb初始化工厂：

package demo.dcn.mongodb;
import com.mongodb.*;

import org.springframework.beans.factory.config.AbstractFactoryBean;

import java.util.ArrayList;
import java.util.List;

public class MongoFactoryBean extends AbstractFactoryBean<Mongo> {

    // 表示服务器列表(主从复制或者分片)的字符串数组
    private String[] serverStrings;
    // 表示认证参数
    private String[] credentialStrings;
    // mongoDB配置对象
    private MongoClientOption mongoOption;
    // 是否主从分离(读取从库)，默认读写都在主库
    private boolean readSecondary = false;
    // 设定写策略(出错时是否抛异常)，默认采用SAFE模式(需要抛异常)
    @SuppressWarnings("deprecation")
	private WriteConcern writeConcern = WriteConcern.SAFE;

    @Override
    public Class<?> getObjectType() {
        return Mongo.class;
    }
    
    @Override
    protected Mongo createInstance() throws Exception {
        Mongo mongo = initMongo();

        // 设定主从分离
        if (readSecondary) {
         mongo.setReadPreference(ReadPreference.secondaryPreferred());
     }

        // 设定写策略
        mongo.setWriteConcern(writeConcern);
        return mongo;
    }

    /**
     * 初始化mongo实例
     *
     * @return
     * @throws Exception
     */
    private MongoClient initMongo() throws Exception {
        // 根据条件创建Mongo实例
        MongoClient mongo = null;
        List<ServerAddress> serverList = getServerList();
        List<MongoCredential> credentialsList = getCredentialsList();
        MongoClientOptions mongoOptions = mongoOption.getMongoClientOptions();
        if (serverList.size() == 0) {
            mongo = new MongoClient();
        } else if (serverList.size() == 1) {
            if (null != mongoOptions) {
                if (credentialsList.size() == 0) {
                    mongo = new MongoClient(serverList.get(0), mongoOptions);
                } else {
                    mongo = new MongoClient(serverList.get(0), credentialsList, mongoOptions);
                }
            } else {
                if (credentialsList.size() == 0) {
                    mongo = new MongoClient(serverList.get(0));
                } else {
                    mongo = new MongoClient(serverList.get(0), credentialsList);
                }
            }
        } else {
            if (null != mongoOptions) {
                if (credentialsList.size() == 0) {
                    mongo = new MongoClient(serverList, mongoOptions);
                } else {
                    mongo = new MongoClient(serverList, credentialsList, mongoOptions);
                }
            } else {
                if (credentialsList.size() == 0) {
                    mongo = new MongoClient(serverList);
                } else {
                    mongo = new MongoClient(serverList, credentialsList);
                }
            }
        }
        return mongo;
    }
    /**
     * 根据服务器字符串列表，解析出服务器对象列表
     * <p/>
     *
     * @return
     * @throws Exception
     * @Title: getServerList
     * </p>
     */
    private List<ServerAddress> getServerList() throws Exception {
        List<ServerAddress> serverList = new ArrayList<ServerAddress>();
        try {
            for (String serverString : serverStrings) {
                String[] temp = serverString.split(":");
                String host = temp[0];
                if (temp.length > 2) {
                    throw new IllegalArgumentException(
                            "Invalid server address string: " + serverString);
                }
                if (temp.length == 2) {
                    serverList.add(new ServerAddress(host, Integer
                            .parseInt(temp[1])));
                } else {
                    serverList.add(new ServerAddress(host));
                }
            }
            return serverList;
        } catch (Exception e) {
            throw new Exception(
                    "Error while converting serverString to ServerAddressList",
                    e);
        }
    }
    /**
     * 根据服务器认证字符串列表，解析出服务器认证对象列表
     * <p/>
     *
     * @return
     * @throws Exception
     * @Title: getCredentialList
     * </p>
     */
    private List<MongoCredential> getCredentialsList() throws Exception {
        List<MongoCredential> credentialsList = new ArrayList<MongoCredential>();
        try {
            if(null != credentialStrings) {
                for (String credentialString : credentialStrings) {
                    String[] temp = credentialString.split(":");
                    String database = temp[0];
                    if (temp.length > 3) {
                        throw new IllegalArgumentException(
                                "Invalid credential param string: " + credentialString);
                    }
                    if (temp.length == 3) {
                        MongoCredential credential = MongoCredential.createCredential(temp[1], database, temp[2].toCharArray());
                        credentialsList.add(credential);
                    } else {
                        throw new IllegalArgumentException(
                                "Invalid credential param string: " + credentialString);
                    }
                }
            }
            return credentialsList;
        } catch (Exception e) {
            throw new Exception(
                    "Error while converting credentialString to MongoCredentialsList",
                    e);
        }
    }

    public String[] getServerStrings() {
        return serverStrings;
    }

    public void setServerStrings(String[] serverStrings) {
        this.serverStrings = serverStrings;
    }

    public String[] getCredentialStrings() {
        return credentialStrings;
    }

    public void setCredentialStrings(String[] credentialStrings) {
        this.credentialStrings = credentialStrings;
    }

    
    public boolean isReadSecondary() {
        return readSecondary;
    }
    public MongoClientOption getMongoOption() {
		return mongoOption;
	}

	public void setMongoOption(MongoClientOption mongoOption) {
		this.mongoOption = mongoOption;
	}

	public void setReadSecondary(boolean readSecondary) {
        this.readSecondary = readSecondary;
    }

    public WriteConcern getWriteConcern() {
        return writeConcern;
    }

    public void setWriteConcern(WriteConcern writeConcern) {
        this.writeConcern = writeConcern;
    }
 
     /* ------------------- setters --------------------- */
}

MorphiaFactoryBean映射工厂实列：

package demo.dcn.mongodb;

import org.mongodb.morphia.Morphia;
import org.springframework.beans.factory.config.AbstractFactoryBean;

public class MorphiaFactoryBean extends AbstractFactoryBean<Morphia> {
    /**
     * 要扫描并映射的包
     */
    private String[] mapPackages;
    /**
     * 要映射的类
     */
    private String[] mapClasses;
    /**
     * 扫描包时，是否忽略不映射的类 这里按照Morphia的原始定义，默认设为false
     */
    private boolean ignoreInvalidClasses;
    /**
     * 映射Morphia实列
     */
    @Override
    protected Morphia createInstance() throws Exception {
        Morphia m = new Morphia();
        if (mapPackages != null) {
            for (String packageName : mapPackages) {
                m.mapPackage(packageName, ignoreInvalidClasses);
            }
        }
        if (mapClasses != null) {
            for (String entityClass : mapClasses) {
                m.map(Class.forName(entityClass));
            }
        }
        return m;
    }

    @Override
    public Class<?> getObjectType() {
        return Morphia.class;
    }

    public String[] getMapPackages() {
        return mapPackages;
    }

    public void setMapPackages(String[] mapPackages) {
        this.mapPackages = mapPackages;
    }

    public String[] getMapClasses() {
        return mapClasses;
    }

    public void setMapClasses(String[] mapClasses) {
        this.mapClasses = mapClasses;
    }

    public boolean isIgnoreInvalidClasses() {
        return ignoreInvalidClasses;
    }

    public void setIgnoreInvalidClasses(boolean ignoreInvalidClasses) {
        this.ignoreInvalidClasses = ignoreInvalidClasses;
    }

	/*----------------------setters-----------------------*/
}

这里自己没有搭建集群分片，读写目前用的一个mongodb数据库。另外可以MongoVUE管理工具，比较好用。当然命令用习惯了，用命令也是一样。下载地址：http://www.baidu.com/link?url=IF-yXcmW-RgoE2hPr4kNGoPwSIkRljqJhPR_gOuEwZPloaUsI9V-t-iMTFN8eAQR

mongodb下载地址：https://www.mongodb.com/download-center安装搭建什么的比较简单。百度一下都有啦。这里就不做介绍了。基本环境算是搭建起来了。现在用下morphia的增删改查方法吧。

package demo.dcn.mongodb.service;


import demo.dcn.mongodb.vo.LookerMongodb;
import demo.dcn.mongodb.vo.TestMongodb;
import demo.dcn.service.utils.demoExceptionUtil;
import demo.dcn.type.ResultMap;

/**
 * 测试mongodb服务
 * @author [email protected]
 */
public interface TestRemoteService {

	/**
	 * 保存收货人地址
	 * @param mongodb
	 * @return
	 */
	public abstract ResultMap saveTestMongodb(TestMongodb mongodb);
	
	/**
	 * 保存looker 号
	 * @param lookerMongodb
	 * @return
	 */
	public abstract ResultMap saveLooker(LookerMongodb lookerMongodb);
	/**
	 * 通过Id 查询 对象
	 * @param id
	 * @return
	 * @throws demoExceptionUtil 
	 */
	public abstract TestMongodb findTestMongodbById(Long id) throws demoExceptionUtil;
	
	
	/**
	 * 更新测试 testMongodb 
	 * @param mongodb
	 * @return
	 * @throws demoExceptionUtil 
	 */
	public abstract void updateMongodb(TestMongodb mongodb) throws demoExceptionUtil;
	
	/**
	 * 删除测试testMongodb 
	 * @param id
	 * @return
	 * @throws demoExceptionUtil 
	 */
	 
	public abstract ResultMap delMongodb(Long id) throws demoExceptionUtil;
	
}
package demo.dcn.mongodb.serviceImpl;

import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

import redis.clients.jedis.ShardedJedisPipeline;

import com.google.common.collect.Maps;

import demo.dcn.cache.JedisUtil;
import demo.dcn.cache.RedisClientBase;
import demo.dcn.common.RedisKey.TEST_MONGODB_CACHE;
import demo.dcn.mongodb.dao.TestMongodbDAO;
import demo.dcn.mongodb.service.TestRemoteService;
import demo.dcn.mongodb.vo.LookerMongodb;
import demo.dcn.mongodb.vo.TestMongodb;
import demo.dcn.service.utils.demoExceptionUtil;
import demo.dcn.type.ResultMap;
@Service
public class TestRemoteServiceImpl implements TestRemoteService {
	private final Logger logger = LoggerFactory.getLogger(TestRemoteServiceImpl.class);
	
	@Autowired
	@Qualifier("redisClientBase")
	private RedisClientBase redisClientBase;
	@Autowired
	private TestMongodbDAO testMongodbDAO;
	@Override
	public ResultMap saveTestMongodb(TestMongodb mongodb) {
		ResultMap resultMap =  ResultMap.SUCCESS;
		try{
			if(mongodb!=null){
			Integer a =	testMongodbDAO.addTestMongodb(mongodb);
			System.out.println(a);
			}
		}catch(Exception e){
			resultMap =ResultMap.FAILURE;
			logger.error(e.getMessage(), e);	
		}
		return resultMap;
	}
	@Override
	public ResultMap saveLooker(LookerMongodb lookerMongodb) {
		ResultMap resultMap =  ResultMap.SUCCESS;
		try{
			if(lookerMongodb!=null){
			Integer a =	testMongodbDAO.addLookerMongodb(lookerMongodb);
			System.out.println(a);
			}
		}catch(Exception e){
			resultMap =ResultMap.FAILURE;
			logger.error(e.getMessage(), e);	
		}
		return resultMap;
	}
	@Override
	public TestMongodb findTestMongodbById(Long id) throws demoExceptionUtil {
		TestMongodb testMongodb= null;
		try{
			String redisKey = String.format(TEST_MONGODB_CACHE.keyformat, id);
			String json =	redisClientBase.getString(redisKey);//redis 连接已经封装好了，用完了会自动关闭
			
			ShardedJedisPipeline jedisPipeline = redisClientBase.getShardedJedis().getShardedJedis().pipelined();
			testMongodb = JedisUtil.toObject(json, TestMongodb.class);//将json 转换成testMongodb 对象反序列化
			if(testMongodb==null){//如果缓存为空
				testMongodb =	testMongodbDAO.findTestMongod(id);
				if(testMongodb!=null){//存入缓存
				String jsonMongodb = JedisUtil.toJson(testMongodb);//序列化
					redisClientBase.setnx(redisKey, jsonMongodb);
					redisClientBase.expire(redisKey, TEST_MONGODB_CACHE.expire);//设置key的过期时间
				}
			}
		}catch(Exception e){
			logger.error(e.getMessage(),e);
			throw new demoExceptionUtil("查询错误",e);
		}
		return testMongodb;
	}
	@Override
	public void updateMongodb(TestMongodb mongodb) throws demoExceptionUtil {
		try{
			
			Map<String,Object> map = Maps.newHashMap();
			String redisKey = String.format(TEST_MONGODB_CACHE.keyformat, mongodb.getLid());
			map.put("lid", mongodb.getLid());
			map.put("name", mongodb.getName());
			map.put("list", mongodb.getList());
			map.put("createTime", mongodb.getCreateTime());
			testMongodbDAO.UpdateTestMongodb(map);
			redisClientBase.del(redisKey);//删除缓存
		}catch(Exception e){
			logger.error(e.getMessage(),e);
			throw new demoExceptionUtil("跟新错误",e);
		}
	}
	@Override
	public ResultMap delMongodb(Long id) throws demoExceptionUtil {
		ResultMap resultMap =  ResultMap.SUCCESS;
		try{
			String redisKey = String.format(TEST_MONGODB_CACHE.keyformat, id);
		Integer n =	testMongodbDAO.delTestMongodb(id);
		System.out.println(n);
			redisClientBase.del(redisKey);
		}catch(Exception e){
			logger.error(e.getMessage(),e);
			resultMap = ResultMap.FAILURE;
			throw new demoExceptionUtil("跟新错误",e);
		}
		return resultMap;
	}
}
package demo.dcn.mongodb.dao.impl;
import java.util.Map;
import org.mongodb.morphia.Datastore;
import org.mongodb.morphia.dao.BasicDAO;
import org.mongodb.morphia.query.Query;
import org.mongodb.morphia.query.UpdateOperations;
import org.mongodb.morphia.query.UpdateResults;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Repository;
import com.google.common.base.Preconditions;
import com.mongodb.BasicDBObject;
import com.mongodb.DBCollection;
import com.mongodb.WriteConcern;
import com.mongodb.WriteResult;
import demo.dcn.mongodb.dao.TestMongodbDAO;
import demo.dcn.mongodb.mapper.TestMongodbMapper;
import demo.dcn.mongodb.vo.LookerMongodb;
import demo.dcn.mongodb.vo.TestMongodb;


@Repository
public class TestMongodbDAOImpl extends BasicDAO<TestMongodb, String> implements TestMongodbDAO {

	@Autowired
	public TestMongodbDAOImpl(@Qualifier("datastore")Datastore ds) {//注入数据源
		super(ds);
	}

	@Override
	public Integer addTestMongodb(TestMongodb mongodb) {
		Query<TestMongodb> query = createQuery().field(TestMongodbMapper.LOOKER_ID).equal(mongodb.getLid());
		query.filter(TestMongodbMapper.LIST, mongodb.getList());
		UpdateOperations<TestMongodb> option = createUpdateOperations().set(TestMongodbMapper.LOOKER_NAME, mongodb.getName());
		UpdateResults u = getDs().update(query, option, true);
        if(u.getInsertedCount()>0)
        {
        	return u.getInsertedCount();
        }
        return 0;
	}


	@Override
	public Integer addLookerMongodb(LookerMongodb lookerMongodb) {
		ds.save("LookerMongodb", lookerMongodb);
		return 1;
	}

	@Override
	public TestMongodb findTestMongod(Long id) {
		Preconditions.checkNotNull(id);
		Query<TestMongodb> query  = createQuery().field(TestMongodbMapper.LOOKER_ID).equal(id);
		TestMongodb mongodb = findOne(query);
		return mongodb;
	}

	@Override
	public void UpdateTestMongodb(Map<String, Object> map) {
		DBCollection collection = getDs().getDB().getCollection("TEST_MONGODB");
		BasicDBObject queryObj = new BasicDBObject();
		queryObj.put(TestMongodbMapper.LOOKER_ID, map.get("lid"));
		 BasicDBObject filedObj=new BasicDBObject(map);
		 BasicDBObject update=new BasicDBObject();
		 update.put("$set", filedObj);
		collection.update(queryObj, update, true, false, WriteConcern.SAFE);//第一个true 表示 是否upsert=true， 找到这一行就 修改，没有就追加 为false 没有就不追加 第二false当找到多个只更新一个。
	}

	@Override
	public int delTestMongodb(Long id) {
		Query<TestMongodb> query = createQuery().field(TestMongodbMapper.LOOKER_ID).equal(id);
		WriteResult  wr = deleteByQuery(query);
		int n = wr.getN();
		if (n > 0) {
			return n;
		}
       return 0;
	}
}
package demo.dcn.mongodb.vo;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

import org.bson.types.ObjectId;
import org.mongodb.morphia.annotations.Embedded;
import org.mongodb.morphia.annotations.Entity;
import org.mongodb.morphia.annotations.Id;

@Entity(value="TEST_MONGODB",noClassnameStored=true)
public class TestMongodb implements Serializable {

	private static final long serialVersionUID = 1L;
	@Id
	private ObjectId id;
	
	private Long lid;
	
	private Long createTime;
	
	/**
	 * @return the lid
	 */
	public Long getLid() {
		return lid;
	}
	/**
	 * @param lid the lid to set
	 */
	public void setLid(Long lid) {
		this.lid = lid;
	}
	private String name;
	@Embedded
	private List<Address> list = new ArrayList<Address>();
	
	/**
	 * @return the id
	 */
	public ObjectId getId() {
		return id;
	}
	/**
	 * @param id the id to set
	 */
	public void setId(ObjectId id) {
		this.id = id;
	}
	/**
	 * @return the name
	 */
	public String getName() {
		return name;
	}
	/**
	 * @param name the name to set
	 */
	public void setName(String name) {
		this.name = name;
	}
	/**
	 * @return the list
	 */
	public List<Address> getList() {
		return list;
	}
	/**
	 * @param list the list to set
	 */
	public void setList(List<Address> list) {
		this.list = list;
	}
	/**
	 * @return the createTime
	 */
	public Long getCreateTime() {
		return createTime;
	}
	/**
	 * @param createTime the createTime to set
	 */
	public void setCreateTime(Long createTime) {
		this.createTime = createTime;
	}
	public TestMongodb() {
		super();
	}
}
package demo.dcn.mongodb.vo;

import java.io.Serializable;

import org.mongodb.morphia.annotations.Embedded;

@Embedded
public class Address implements Serializable {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	private String name;
	
	private String address;
	
	private String iphone;
	
	private Integer defAdd;//是否是默认地址 0 表示不是，1 表示是

	/**
	 * @return the name
	 */
	public String getName() {
		return name;
	}

	/**
	 * @param name the name to set
	 */
	public void setName(String name) {
		this.name = name;
	}

	/**
	 * @return the address
	 */
	public String getAddress() {
		return address;
	}

	/**
	 * @param address the address to set
	 */
	public void setAddress(String address) {
		this.address = address;
	}

	/**
	 * @return the iphone
	 */
	public String getIphone() {
		return iphone;
	}

	/**
	 * @param iphone the iphone to set
	 */
	public void setIphone(String iphone) {
		this.iphone = iphone;
	}

	/**
	 * @return the defAdd
	 */
	public Integer getDefAdd() {
		return defAdd;
	}

	/**
	 * @param defAdd the defAdd to set
	 */
	public void setDefAdd(Integer defAdd) {
		this.defAdd = defAdd;
	}	
}
package demo.dcn.common;
/**
 * redis key标准格式类
 * @author [email protected]
 */
public interface RedisKey {

	interface TEST_MONGODB_CACHE{
		String keyprefix ="test:mongodb";//前缀
		String keyformat =keyprefix+"%s";//后缀
		int expire = 60 * 60 * 24;//缓存存活时间1天
	}
}
package demo.dcn.mongodb.mapper;

public class TestMongodbMapper {

	
	public static final String LOOKER_ID ="lid";//looker_id
	
	public static final String LOOKER_NAME = "name";
	public static final String CREATE_TIME = "createTime";//创建时间
	
	public static final String LIST = "list";//收货地址
	
	public static final String MONGODB ="mongodb";//对象
	
	public static final String ID = "id";//id唯一标识
	
	
}
import java.util.ArrayList;
import java.util.List;

import javax.annotation.Resource;

import org.bson.types.ObjectId;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.alibaba.fastjson.JSON;
import com.mysql.fabric.xmlrpc.base.Array;

import demo.dcn.cache.JedisUtil;
import demo.dcn.cache.RedisClientBase;
import demo.dcn.mongodb.service.TestRemoteService;
import demo.dcn.mongodb.vo.Address;
import demo.dcn.mongodb.vo.LookerMongodb;
import demo.dcn.mongodb.vo.TestMongodb;
import demo.dcn.redis.service.RegisterService;
import demo.dcn.service.utils.UuidUtils;
import demo.dcn.service.utils.demoExceptionUtil;
import demo.dcn.service.utils.security.Md5Util;
import demo.dcn.type.ResultMap;
import demo.dcn.vo.Looker;
import demo.dcn.vo.LookerSalt;
/**
 * 测试
 * @author [email protected]
 *
 *
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={
		"classpath*:config/demo-spring-context.xml",
		"classpath*:config/demo-spring-datasource.xml",
		"classpath*:config/demo-spring-redis.xml",
		"classpath*:config/demo-sql-config.xml",
		"classpath*:config/demo-spring-mongodb.xml"
})
public class test {
	
	@Autowired
	private RegisterService registerService;
	@Autowired
	@Qualifier("redisClientBase")
	private RedisClientBase redisClientBase;
	@Autowired
	private TestRemoteService testRemoteService;
	@Test
	public void testMongoDB(){
		TestMongodb mongodb = new TestMongodb();
		List<Address> addList = new ArrayList<Address>();
		Address address = new Address();
		
		
		address.setName("坤坤");
		address.setIphone("18123074271");
		address.setDefAdd(0);
		address.setAddress("成都市天府大道天府新区1");
		addList.add(address);
		mongodb.setLid(103456987L);
		mongodb.setName("坤坤3");
		mongodb.setList(addList);
		ResultMap map =	testRemoteService.saveTestMongodb(mongodb);
		System.out.println(map.getDesc());
	}
	
	//@Test
	public void testLookerMongodb(){
		LookerMongodb lookerMongodb = new LookerMongodb();
		List<Address> addList = new ArrayList<Address>();
		Address address = new Address();
		address.setName("坤坤");
		address.setIphone("18123074271");
		address.setDefAdd(0);
		address.setAddress("成都市天府大道天府新区");
		addList.add(address);
		lookerMongodb.setLid(123698745l);
		lookerMongodb.setLevel(1);
		lookerMongodb.setName("萧萧");
		lookerMongodb.setAddList(addList);
		ResultMap map =testRemoteService.saveLooker(lookerMongodb);
		System.out.println(map.getDesc());
	} 
	
	@Test
	public void testFindMongodb() throws demoExceptionUtil{
		TestMongodb mongodb =testRemoteService.findTestMongodbById(103456987L);
		if(mongodb!=null){
			System.out.println(mongodb.getName());
			System.out.println(mongodb.getLid());
		}
	}
	
	@Test
	public void testUpdateMongodb() throws demoExceptionUtil{
		TestMongodb mongodb = new TestMongodb();
		List<Address> addList = new ArrayList<Address>();
		Address address = new Address();
		address.setName("坤坤1");
		address.setIphone("18123074271");
		address.setDefAdd(0);
		address.setAddress("成都市天府大道天府新区1");
		addList.add(address);
		mongodb.setLid(103456987L);
		mongodb.setName("坤坤2");
		mongodb.setList(addList);
		testRemoteService.updateMongodb(mongodb);
	}
	
	@Test
	public void testDelMongodb() throws demoExceptionUtil{
		ResultMap map =testRemoteService.delMongodb(103456987l);
		System.out.println(map.getDesc());
	}
}

这里自己用的缓存，和一些工具类的使用，结合公司的一些写法。封装了了一下公共类的使用。如果需要搭建框架的朋友直接那过去用吧

mongodb 类属性 数据库

LemonSnm

LemonSnm

0 关注 0 粉丝 0 动态

关注 关注

相关推荐

分布式文档存储数据库之MongoDB访问控制的操作方法

　　什么是访问控制？

fengzhongdengdai 2020-11-17

分布式文档存储数据库之MongoDB备份与恢复的实践详解

　　为什么要备份？　　备份的目的是对数据做冗余的一种方式，它能够让我们在某种情况下保证最少数据的丢失；之前我们对mongodb做副本集也是对数据做冗余，但是这种在副本集上做数据冗余仅仅是针对系统故障或服务异常等一些非人为的故障发生时，保证数据服务的可用性；

lbyd0 2020-11-17

Pycharm连接MongoDB数据库安装教程详解

最新版本的Pycharm搜不到Plugin插件，自己手动下载Mongo Plugin插件下载地址。我把它放在了MongoDB的安装路径下。下一节开始试用。

BigYellow 2020-11-16

分布式文档存储数据库之MongoDB分片集群的问题

　　1、什么是分片？比如用户要查询年龄大于30的用户，该怎么查询呢？而年龄大于30的用户的数据，可能server1上有一部分数据，server2上有部分数据，我们怎么才能够把所有满足条件的数据全部查询到呢？

sushuanglei 2020-11-12

MongoDB数据库用户角色和权限管理详解

使用终端命令行输入 mongo 登陆 mongodb 之后切换到 admin 库，并认证后可查看所有数据库，操作如下所示：。Implicit session: session { "id" : UUID }. 说明：1 表示认证成功，0

我心似明月 2020-11-09

MongoDB 用户管理

小小最近接触了MongoDB，所以这里开始学习MongoDB，之用户管理模块的相关内容。使用如上的命令，切换数据库到admin数据库。cusomData 字段，任意内容，可以是用户名的全民介绍。roles 字段 指定用户的角色，用于给一个空数组，给新用户设

sdmzhu 2020-09-01

利用golang驱动操作MongoDB数据库的步骤

MongoDB中的JSON文档以称为BSON的二进制表示形式存储。与其他将JSON数据存储为简单字符串和数字的数据库不同，BSON编码扩展了JSON表示形式，例如int，long，date，float point和decimal128。这使应用程序更容易可

zhushenghan 2020-11-09

ubuntu安装mongodb创建账号和库及添加坐标索引的流程分析

... roles: [ { role: "readWrite", db: "lbs" },　　4.3移除数据库和日志文件

sunnnyduan 2020-10-16

MongoDB查询之高级操作详解（多条件查询、正则匹配查询等）

MongoDB查询文档使用find()方法，同时find()方法以非结构化的方式来显示所有查询到的文档。db.collection.find -- 返回所有符合查询条件的文档。$type操作符是基于BSON类型来检索集合中匹配的数据类型，MongoDB中可

不要皱眉 2020-10-14

SpringBoot+MongoDB实现物流订单系统的代码

我们都知道MongoDB是一款非常出色的非关系型文档数据库，你肯定会想问MongoDB这么强，我们该怎么用或者有啥运用场景呢？MongoDB的应用场景非常多，无论是数据存储还是日志存储越来越多的公司在使用MongoDB，而我们今天也在SpringBoot基

xiaohai 2020-09-29

MongoDb CPU利用率过高问题如何解决

在公司的项目中，突然出现过一个情况，mongodb 的CPU利用率到达100%,导致服务器这边卡死了，请求了半天无响应，提示请求超时。因为，当时APP用户可能会在某一个时间段集中的使用，所以，请求量一下子就飙上去了，刚好APP打开请求的时候，有一个mong

songxiugongwang 2020-09-22

flask_16：通过 MongoEngine 使用 MongoDB

使用一个 MongoDB 之类的文档型数据库来代替关系 SQL 数据是很常见的。本方案演示 如何使用文档映射库MongoEngine来集成 MongoDB 。基本的配置是在app.config中定义MONGODB_SETTINGS并创建一个MongoEng

萌亖 2020-09-17

MongoDB通配符索引的用法实例

MongoDB在4.2 版本推出了Wildcard Indexes，究竟什么是Wildcard Indexes以及Wildcard Indexes适合哪些场景本文结合官方文档以及实际测试进行简单概述。因为MongoDB是dynamic schemas，所以

LuckyLXG 2020-09-08

MongoDB如何查看版本信息详解

它处理数据请求，管理数据存储，和执行后台管理操作。当我们运行mongod命令意味着正在启动MongoDB进程,并且在后台运行。mongo是一个命令行工具用于连接一个特定的mongod实例。当我们没有带参数运行mongo命令它将使用默认的端口号和localh

mkhhxxttxs 2020-09-16

Centos7 yum安装mongodb实现步骤详解

复制和高可用性：支持服务器之间的数据复制，支持主-从模式及服务器之间的相互复制。复制的主要目的是提供冗余及自动故障转移。#这里可以修改 gpgcheck=0, 省去gpg验证[root@localhost ~]# yum makecache. system

xiaohai 2020-09-16

Docker 搭建集群MongoDB的实现步骤

由于公司业务需要，我们打算自己搭建 MongoDB 的服务，因为 MongoDB 的云数据库好贵，我们这次采用副本集的方式来搭建集群，三台服务器，一主、一副、一仲裁。Replica Set 副本集：一个副本集就是一组 MongoDB 实例组成的集群，由一个

newcome 2020-09-09

mongodb的聚合操作

聚合是MongoDB的高级查询语言，它允许我们通过转化合并由多个文档的数据来生成新的在单个文档里不存在的文档信息。MongoDB中聚合主要用于处理数据，并返回计算后的数据结果，有点类似sql语句中的 count(*)。Pipeline查询速度快于MapRe

jaylong 2020-08-19

mongodb的java客户端

<artifactId>spring-boot-starter-data-mongodb</artifactId>. private Long id;private String userName;private String pa

大秦铁骑 2020-08-19

mongodb的java客户端

<artifactId>spring-boot-starter-data-mongodb</artifactId>. private Long id;private String userName;private String pa

thatway 2020-08-19

mongodb的java客户端

<artifactId>spring-boot-starter-data-mongodb</artifactId>. private Long id;private String userName;private String pa

lovecodeblog 2020-08-19
LemonSnm

LemonSnm

W3CSchool教程
HTML 教程
CSS 教程
Bootstrap 教程
Javascript 教程
jQuery 教程
后端教程
C 教程
Java 教程
PHP 教程
Python 教程
Go 教程
移动开发
Android 教程
Swift 教程
Kotlin 教程
jQuery Mobile 教程
ionic 教程
关于我们
新闻动态
联系方式
招聘英才
安科实验室
帮助与反馈

安科网(Ancii)，中国第一极客网

Copyright © 2013 - 2019 Ancii.com

京ICP备18063983号 京公网安备11010802014868号