`

Mongo的ORM框架的学习Morphia(八) morphia数据库访问接口

 
阅读更多

转自:http://topmanopensource.iteye.com/blog/1437649

 

       针对Mongo数据库访问,morphia提供了访问的基本的接口便于开发人员实现。

源代码如下:

DAO接口类:

package com.google.code.morphia.dao;

import java.util.List;

import com.google.code.morphia.Datastore;
import com.google.code.morphia.Key;
import com.google.code.morphia.query.Query;
import com.google.code.morphia.query.QueryResults;
import com.google.code.morphia.query.UpdateOperations;
import com.google.code.morphia.query.UpdateResults;
import com.mongodb.DBCollection;
import com.mongodb.WriteConcern;
import com.mongodb.WriteResult;

public interface DAO<T, K> {
	/** Starts a query for this DAO entities type*/
	public Query<T> createQuery();
	
	/** Starts a update-operations def for this DAO entities type*/
	public UpdateOperations<T> createUpdateOperations();
	
	/** The type of entities for this DAO*/
	public Class<T> getEntityClass();
	
	/** Saves the entity; either inserting or overriding the existing document */
	public Key<T> save(T entity);
	
	/** Saves the entity; either inserting or overriding the existing document */
	public Key<T> save(T entity, WriteConcern wc);
	
	/** Updates the first entity matched by the constraints with the modifiers supplied.*/
	public UpdateResults<T> updateFirst(Query<T> q, UpdateOperations<T> ops);
	
	/** Updates all entities matched by the constraints with the modifiers supplied.*/
	public UpdateResults<T> update(Query<T> q, UpdateOperations<T> ops);
	
	/** Deletes the entity */
	public WriteResult delete(T entity);
	
	/** Deletes the entity 
	 * @return */
	public WriteResult delete(T entity, WriteConcern wc);
	
	/** Delete the entity by id value */
	public WriteResult deleteById(K id);
	
	/** Saves the entities given the query*/
	public WriteResult deleteByQuery(Query<T> q);
	
	/** Loads the entity by id value*/
	public T get(K id);
	
	/** Finds the entities Key<T> by the criteria {key:value}*/
	public List<T> findIds(String key, Object value);
	
	/** Finds the entities Ts*/
	public List<T> findIds();
	
	/** Finds the entities Ts by the criteria {key:value}*/
	public List<T> findIds(Query<T> q);
	
	/** checks for entities which match criteria {key:value}*/
	public boolean exists(String key, Object value);
	
	/** checks for entities which match the criteria*/
	public boolean exists(Query<T> q);
	
	/** returns the total count*/
	public long count();
	
	/** returns the count which match criteria {key:value}*/
	public long count(String key, Object value);
	
	/** returns the count which match the criteria*/
	public long count(Query<T> q);
	
	/** returns the entity which match criteria {key:value}*/
	public T findOne(String key, Object value);
	
	/** returns the entity which match the criteria */
	public T findOne(Query<T> q);
	
	/** returns the entities */
	public QueryResults<T> find();
	
	/** returns the entities which match the criteria */
	public QueryResults<T> find(Query<T> q);

	/** ensures indexed for this DAO */
	public void ensureIndexes();

	/** gets the collection */
	public DBCollection getCollection();
	
	/** returns the underlying datastore */
	public Datastore getDatastore();
}

 

DAO底层实现类:

package com.google.code.morphia.dao;

import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.List;

import com.google.code.morphia.Datastore;
import com.google.code.morphia.DatastoreImpl;
import com.google.code.morphia.Key;
import com.google.code.morphia.Morphia;
import com.google.code.morphia.query.Query;
import com.google.code.morphia.query.QueryResults;
import com.google.code.morphia.query.UpdateOperations;
import com.google.code.morphia.query.UpdateResults;
import com.mongodb.DBCollection;
import com.mongodb.Mongo;
import com.mongodb.WriteConcern;
import com.mongodb.WriteResult;

/**
 * @author Olafur Gauti Gudmundsson
 * @author Scott Hernandez
 */
@SuppressWarnings({ "unchecked", "rawtypes" })
public class BasicDAO<T, K> implements DAO<T, K> {
	
	protected Class<T> entityClazz;
	protected DatastoreImpl ds;
	
	public BasicDAO(Class<T> entityClass, Mongo mongo, Morphia morphia, String dbName) {
		initDS(mongo, morphia, dbName);
		initType(entityClass);
	}
	
	public BasicDAO(Class<T> entityClass, Datastore ds) {
		this.ds = (DatastoreImpl) ds;
		initType(entityClass);
	}
	
	/**
	 * <p> Only calls this from your derived class when you explicitly declare the generic types with concrete classes </p>
	 * <p>
	 * {@code class MyDao extends DAO<MyEntity, String>}
	 * </p>
	 * */
	protected BasicDAO(Mongo mongo, Morphia morphia, String dbName) {
		initDS(mongo, morphia, dbName);
		initType(((Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0]));
	}
	
	protected BasicDAO(Datastore ds) {
		this.ds = (DatastoreImpl) ds;
		initType(((Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0]));
	}
	
	protected void initType(Class<T> type) {
		this.entityClazz = type;
		ds.getMapper().addMappedClass(type);
	}
	
	protected void initDS(Mongo mon, Morphia mor, String db) {
		ds = new DatastoreImpl(mor, mon, db);
	}
	
	/**
	 * Converts from a List<Key> to their id values
	 * 
	 * @param keys
	 * @return
	 */
	protected List<?> keysToIds(List<Key<T>> keys) {
		ArrayList ids = new ArrayList(keys.size() * 2);
		for (Key<T> key : keys)
			ids.add(key.getId());
		return ids;
	}
	
	/** The underlying collection for this DAO */
	public DBCollection getCollection() {
		return ds.getCollection(entityClazz);
	}

	
	/* (non-Javadoc)
	 * @see com.google.code.morphia.DAO#createQuery()
	 */
	public Query<T> createQuery() {
		return ds.createQuery(entityClazz);
	}
	
	/* (non-Javadoc)
	 * @see com.google.code.morphia.DAO#createUpdateOperations()
	 */
	public UpdateOperations<T> createUpdateOperations() {
		return ds.createUpdateOperations(entityClazz);
	}

	/* (non-Javadoc)
	 * @see com.google.code.morphia.DAO#getEntityClass()
	 */
	public Class<T> getEntityClass() {
		return entityClazz;
	}
	
	/* (non-Javadoc)
	 * @see com.google.code.morphia.DAO#save(T)
	 */
	public Key<T> save(T entity) {
		return ds.save(entity);
	}
	
	/* (non-Javadoc)
	 * @see com.google.code.morphia.DAO#save(T, com.mongodb.WriteConcern)
	 */
	public Key<T> save(T entity, WriteConcern wc) {
		return ds.save(entity, wc);
	}
	/* (non-Javadoc)
	 * @see com.google.code.morphia.DAO#updateFirst(com.google.code.morphia.query.Query, com.google.code.morphia.query.UpdateOperations)
	 */
	public UpdateResults<T> updateFirst(Query<T> q, UpdateOperations<T> ops) {
		return ds.updateFirst(q, ops);
	}
	
	/* (non-Javadoc)
	 * @see com.google.code.morphia.DAO#update(com.google.code.morphia.query.Query, com.google.code.morphia.query.UpdateOperations)
	 */
	public UpdateResults<T> update(Query<T> q, UpdateOperations<T> ops) {
		return ds.update(q, ops);
	}
	
	/* (non-Javadoc)
	 * @see com.google.code.morphia.DAO#delete(T)
	 */
	public WriteResult delete(T entity) {
		return ds.delete(entity);
	}

	/* (non-Javadoc)
	 * @see com.google.code.morphia.DAO#delete(T, com.mongodb.WriteConcern)
	 */
	public WriteResult delete(T entity, WriteConcern wc) {
		return ds.delete(entity, wc);
	}

	/* (non-Javadoc)
	 * @see com.google.code.morphia.DAO#deleteById(K)
	 */
	public WriteResult deleteById(K id) {
		return ds.delete(entityClazz, id);
	}
	
	/* (non-Javadoc)
	 * @see com.google.code.morphia.DAO#deleteByQuery(com.google.code.morphia.query.Query)
	 */
	public WriteResult deleteByQuery(Query<T> q) {
		return ds.delete(q);
	}
	
	/* (non-Javadoc)
	 * @see com.google.code.morphia.DAO#get(K)
	 */
	public T get(K id) {
		return ds.get(entityClazz, id);
	}
	
	/* (non-Javadoc)
	 * @see com.google.code.morphia.DAO#findIds(java.lang.String, java.lang.Object)
	 */
	public List<T> findIds(String key, Object value) {
		return (List<T>) keysToIds(ds.find(entityClazz, key, value).asKeyList());
	}
	
	/* (non-Javadoc)
	 * @see com.google.code.morphia.DAO#findIds()
	 */
	public List<T> findIds() {
		return (List<T>) keysToIds(ds.find(entityClazz).asKeyList());
	}
	
	/* (non-Javadoc)
	 * @see com.google.code.morphia.DAO#findIds(com.google.code.morphia.query.Query)
	 */
	public List<T> findIds(Query<T> q) {
		return (List<T>) keysToIds(q.asKeyList());
	}
	
	/* (non-Javadoc)
	 * @see com.google.code.morphia.DAO#exists(java.lang.String, java.lang.Object)
	 */
	public boolean exists(String key, Object value) {
		return exists(ds.find(entityClazz, key, value));
	}
	
	/* (non-Javadoc)
	 * @see com.google.code.morphia.DAO#exists(com.google.code.morphia.query.Query)
	 */
	public boolean exists(Query<T> q) {
		return ds.getCount(q) > 0;
	}
	
	/* (non-Javadoc)
	 * @see com.google.code.morphia.DAO#count()
	 */
	public long count() {
		return ds.getCount(entityClazz);
	}
	
	/* (non-Javadoc)
	 * @see com.google.code.morphia.DAO#count(java.lang.String, java.lang.Object)
	 */
	public long count(String key, Object value) {
		return count(ds.find(entityClazz, key, value));
	}
	
	/* (non-Javadoc)
	 * @see com.google.code.morphia.DAO#count(com.google.code.morphia.query.Query)
	 */
	public long count(Query<T> q) {
		return ds.getCount(q);
	}
	
	/* (non-Javadoc)
	 * @see com.google.code.morphia.DAO#findOne(java.lang.String, java.lang.Object)
	 */
	public T findOne(String key, Object value) {
		return ds.find(entityClazz, key, value).get();
	}
	
	/* (non-Javadoc)
	 * @see com.google.code.morphia.DAO#findOne(com.google.code.morphia.query.Query)
	 */
	public T findOne(Query<T> q) {
		return q.get();
	}
	
	/* (non-Javadoc)
	 * @see com.google.code.morphia.DAO#find()
	 */
	public QueryResults<T> find() {
		return createQuery();
	}
	
	/* (non-Javadoc)
	 * @see com.google.code.morphia.DAO#find(com.google.code.morphia.query.Query)
	 */
	public QueryResults<T> find(Query<T> q) {
		return q;
	}

	/* (non-Javadoc)
	 * @see com.google.code.morphia.DAO#getDatastore()
	 */
	public Datastore getDatastore() {
		return ds;
	}
	
	public void ensureIndexes() {
		ds.ensureIndexes(entityClazz);
	}

}

 

使用DAO如下:

package com.easyway.mongodb.morphia;

import java.util.List;

import com.easyway.mongodb.morphia.basic.Hotel;
import com.google.code.morphia.Morphia;
import com.google.code.morphia.dao.BasicDAO;
import com.google.code.morphia.query.UpdateOperations;
import com.mongodb.Mongo;
/**
 * 数据访问层类的使用
 * @Title: TODO
 * @Description: 实现TODO
 * @Copyright:Copyright (c) 2011
 * @Company:易程科技股份有限公司
 * @Date:2012-3-2
 * @author 
 * @version 1.0
 */
public class HotelDAO  extends BasicDAO<Hotel, String> {
	 public HotelDAO(Morphia morphia, Mongo mongo, String dbName) {
		super(mongo, morphia, dbName);
	 }
	/**
	 * 统计四星级以上酒店数量
	 * @return
	 */
	 public long countHotel(){
	    	return count(createQuery().field("stars").greaterThanOrEq(4));
	 }
	 /**
	  * 查询酒店
	  * @return
	  */
	 public List<Hotel> queryHotelPhone(){
		 return createQuery().field("phoneNumbers").sizeEq(1).asList();
	 }
	 
	 
	 /**
	  * 查询酒店
	  * @param hotel
	  */
	 public List<Hotel> queryHotel(Hotel hotel){
		 return find(createQuery().filter("stars", 4).order("address.address_street")).asList();
		 
	 }
	 /**
	  * 修改酒店信息
	  * @param hotel
	  */
	 public void batchUpdateHotel(){
		    UpdateOperations<Hotel> mods = createUpdateOperations().inc("stars", 1);
	        update(createQuery().filter("stars", 4), mods);
	 }

}
 
分享到:
评论

相关推荐

    Mongo的ORM框架的学习Morphia

    在本文中,我们将探讨MongoDB的ORM框架Morphia,并结合Spring Data MongoDB的使用来创建一个集成应用。ORM(对象关系映射)框架是将数据库操作转化为对象模型的方法,简化了开发过程,使得开发者可以专注于业务逻辑...

    morphia.jar和mongo.jar

    MongoDB是一个流行的开源、分布式文档型数据库,而Morphia则是Java开发人员用来操作MongoDB的一个对象数据映射(ODM)框架。 Mongo-2.7.3.jar是MongoDB Java驱动程序的特定版本,它提供了与MongoDB服务器通信所需的...

    spring-mongodb-morphia:springdata-mongo morphia mongodb 学习

    学习这个项目,你将能够掌握如何在Spring应用中集成MongoDB,使用Morphia进行数据操作,以及如何通过Spring Data接口编写灵活的查询。这将增强你处理非结构化数据的能力,对于构建基于Java的现代Web应用非常有帮助。...

    Morphia开发简介.pdf

    Morphia是一款针对MongoDB数据库的Java对象关系映射(ORM)框架,它的主要目标是让Java开发者能够以面向对象的方式处理数据库操作,从而减轻数据库设计的复杂性,使开发者能更专注于业务逻辑。Morphia以轻量级和类型...

    Morphia 操作 MongoDB.pdf

    Morphia 是一个 Java ORM(对象关系映射)库,用于简化 MongoDB 的数据操作,将数据模型与数据库文档之间的转换自动化。在本文中,我们将深入探讨如何使用 Morphia 进行 MongoDB 的操作。 首先,为了在 Java 项目中...

    play1.x连接mongodb

    Morphia是一个常见的选择,它是Google开发的一个用于MongoDB的数据映射框架,简化了在Java应用中操作MongoDB的过程。 在描述中提到"下载资源后,运行unit-tests即可",这暗示了项目可能已经包含了一套完整的测试...

    mongodb 操作基础类 封装

    Morphia一个nosql的ORM框架 对此二次封装

    基于Morphia实现MongoDB按小时、按天聚合操作方法

    Morphia是一个针对MongoDB的Java ORM(对象关系映射)工具,它简化了与MongoDB的交互,允许开发者将Java对象直接映射到MongoDB文档。在本案例中,我们有两个关键的数据模型:`RawDevStatus`和`AggregationDevStatus`...

    spring集成mongodb

    本文将详细介绍如何在 Spring 4.2 中集成 MongoDB 框架,特别是使用 Morphia 1.1 这个 ORM(对象关系映射)工具进行数据操作。 ### 1. 安装与配置 首先,确保已安装 MongoDB 服务器并运行。然后,在项目中添加以下...

    java操作mongodb时,对象bean和DBObject相互转换的方法(推荐)

    虽然Apache Commons BeanUtils库提供了一种便捷的方式进行转换,但在大规模应用中,考虑使用ORM框架如Morphia或Spring Data MongoDB,它们提供了更高级别的抽象和自动转换功能,可以简化对象与数据库之间的交互。...

    mongo1

    8. **使用 Morphia**:Morphia 是一个 ORM 库,它可以将 Kotlin 类映射到 MongoDB 文档。通过 Morphia,你可以更直观地操作数据库,例如,通过 `@Entity` 注解定义数据模型,然后使用 `Datastore` 对象进行持久化...

    MongoDB、Java与对象关系映射.pdf

    此外,还有ORM(Object-Relational Mapping)库,如Morphia和Spring Data MongoDB,它们帮助简化数据对象与数据库文档之间的转换,提高开发效率。 7. **MJORM**:Mongo-Java-ORM(MJORM)是一个专门为MongoDB设计的...

Global site tag (gtag.js) - Google Analytics