`
LynBazinga
  • 浏览: 11522 次
社区版块
存档分类
最新评论

spring与mongodb的泛型Dao整合

Mongodb入门 spring 
阅读更多

在前人的基础上，进行了spring与mongodb的初期整合，如果有什么不对的地方，请指正

Maven的pom.xml(部分jar多余，可考虑删除)

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>springForMongo</groupId>
  <artifactId>springForMongo</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
  <name/>
  <description/>
  <properties>
		<!-- spring版本号 -->
		<spring.version>3.2.4.RELEASE</spring.version>
		<!-- log4j日志文件管理包版本 -->
		<slf4j.version>1.6.6</slf4j.version>
		<log4j.version>1.2.9</log4j.version>
	</properties>
	<dependencies>
		<!-- spring核心包 -->
		<!-- springframe start -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-oxm</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context-support</artifactId>
			<version>${spring.version}</version>
		</dependency>


		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<!-- springframe end -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>servlet-api</artifactId>
			<version>2.5</version>
			<type>jar</type>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>org.mongodb</groupId>
			<artifactId>mongo-java-driver</artifactId>
			<version>2.10.1</version>
			<type>jar</type>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-mongodb</artifactId>
			<version>1.2.1.RELEASE</version>
			<type>jar</type>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-mongodb-cross-store</artifactId>
			<version>1.2.1.RELEASE</version>
			<type>jar</type>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-mongodb-log4j</artifactId>
			<version>1.2.1.RELEASE</version>
			<type>jar</type>
			<scope>compile</scope>
		</dependency>
		<!-- junit测试包 -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.11</version>
			<scope>test</scope>
		</dependency>

		<!-- 日志文件管理包 -->
		<!-- log start -->
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>${log4j.version}</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>${slf4j.version}</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>${slf4j.version}</version>
		</dependency>
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
			<version>3.3.2</version>
		</dependency>
		<!-- log end -->
	</dependencies>
  <build>
    <plugins>
      <plugin>
        <artifactId>maven-war-plugin</artifactId>
      </plugin>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>1.6</source>
          <target>1.6</target>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

 spring.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:context="http://www.springframework.org/schema/context"  
    xmlns:mongo="http://www.springframework.org/schema/data/mongo"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans  
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
        http://www.springframework.org/schema/data/mongo       
        http://www.springframework.org/schema/data/mongo/spring-mongo-1.0.xsd   
        http://www.springframework.org/schema/context  
        http://www.springframework.org/schema/context/spring-context-3.0.xsd">  
  
    <context:component-scan base-package="com.mongodb" />  
  
    <mongo:mongo host="127.0.0.1" port="27017" />  
  
    <!-- mongo的工厂，通过它来取得mongo实例,dbname为mongodb的数据库名，没有的话会自动创建 -->  
    <mongo:db-factory dbname="test_mongodb" mongo-ref="mongo" />  
  
    <!-- mongodb的主要操作对象，所有对mongodb的增删改查的操作都是通过它完成 -->  
    <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">  
        <constructor-arg name="mongoDbFactory" ref="mongoDbFactory" />  
    </bean>  
  
    <!-- 映射转换器，扫描back-package目录下的文件，根据注释，把它们作为mongodb的一个collection的映射 -->  
    <mongo:mapping-converter base-package="com.mongodb.model" />  
  
    <!-- mongodb bean的仓库目录，会自动扫描扩展了MongoRepository接口的接口进行注入 -->  
    <mongo:repositories base-package="com.mongodb.dao.impl" />  
  
    <context:annotation-config />  
  
</beans>

 BaseDaoI

@Transactional
public interface BaseDaoI<T> {
	

	    public abstract void _test();  
	  
	    public abstract void createCollection(T object);  
	  
	    public abstract List<T> findList(int skip, int limit);  
	  
	    public abstract T findOneByItems(Map<String, Object> params);  
	  
	    public abstract void insert(T t);  
	  
	    public abstract void update(String id,Map<String, Object> params,T t);
	    
	    public abstract long count(Map<String, Object> params);
	    
	    public abstract List<T> findByItems(Map<String, Object> params);

		public abstract List<T> findListByPageAndItems(int skip, int rows, Map<String, Object> params);
		
		public abstract void deleteById(String id);
		
		public abstract void saveFile(File file,String fileUrl);
		
		public abstract GridFSDBFile retrieveFileOne(String filename); 
}

 StaffDaoI

import org.springframework.transaction.annotation.Transactional;

import com.mongodb.model.Staff;

@Transactional
public interface StaffDaoI extends BaseDaoI<Staff> {

}

 BaseDaoImpl.class

import java.io.File;
import java.io.IOException;
import java.lang.reflect.ParameterizedType;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.data.domain.Sort.Order;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Repository;

import com.mongodb.DB;
import com.mongodb.dao.BaseDaoI;
import com.mongodb.gridfs.GridFS;
import com.mongodb.gridfs.GridFSDBFile;
import com.mongodb.gridfs.GridFSInputFile;

@Repository
public class BaseDaoImpl<T> implements BaseDaoI<T> {
	
	public static final Logger logger = LoggerFactory.getLogger(BaseDaoImpl.class);
	
	public static final String FILEURL="imgRespository"; 

	@Autowired
	private MongoTemplate mongoTemplate;
	
	private Class<?> clz;
	
	public Class<?> getClz() {
		if(clz==null) {
			//获取泛型的Class对象
			clz = ((Class<?>)
					(((ParameterizedType)(this.getClass().getGenericSuperclass())).getActualTypeArguments()[0]));
		}
		return clz;
	}
	public BaseDaoImpl() {
		
	}

	@Override
	public void _test() {
		Set<String> colls = this.mongoTemplate.getCollectionNames();
		for (String coll : colls) {
			logger.info("CollectionName=" + coll);
		}
		DB db = this.mongoTemplate.getDb();
		logger.info("db=" + db.toString());
	}

	@Override
	public void createCollection(T object) {
		if (!this.mongoTemplate.collectionExists(getClz())) {
			this.mongoTemplate.createCollection(getClz());
		}
		
	}

	@Override
	public List<T> findList(int skip, int limit) {
		Query query = new Query();
		query.with(new Sort(new Order(Direction.ASC, "_id")));
		query.skip(skip).limit(limit);
		return (List<T>)this.mongoTemplate.find(query, getClz());
	}

	@Override
	public T findOneByItems(Map<String, Object> params) {
		Query query = new Query();
		if ((params != null) && (!(params.isEmpty()))) {
		      for (String key : params.keySet()) {
		    	  query.addCriteria(new Criteria(key).is(params.get(key)));
		      }
		 }
		return (T)mongoTemplate.findOne(query, getClz());
	}

	@Override
	public void insert(T t) {
		this.mongoTemplate.insert(t);
	}


	@Override
	public long count(Map<String, Object> params) {
		Query query = new Query();
		if ((params != null) && (!(params.isEmpty()))) {
		      for (String key : params.keySet()) {
		    	  query.addCriteria(new Criteria(key).is(params.get(key)));
		      }
		    }
		return (long)mongoTemplate.find(query, getClz()).size();
	}

	@Override
	public List<T> findByItems(Map<String, Object> params) {
		Query query = new Query();
		if ((params != null) && (!(params.isEmpty()))) {
		      for (String key : params.keySet()) {
		    	  query.addCriteria(new Criteria(key).is(params.get(key)));
		      }
		    }
		return (List<T>)this.mongoTemplate.find(query, getClz());
	}

	@Override
	public List<T> findListByPageAndItems(int skip, int rows,
			Map<String, Object> params) {
		Query query = new Query();
		if ((params != null) && (!(params.isEmpty()))) {
		      for (String key : params.keySet()) {
		    	  query.addCriteria(new Criteria(key).is(params.get(key)));
		      }
		 }
		query.skip(skip).limit(rows);
		return (List<T>)this.mongoTemplate.find(query, getClz());
	}

	@Override
	public void update(String id, Map<String, Object> params,T t) {
		Query query = new Query();
		query.addCriteria(new Criteria("_id").is(id));
		Update update = new Update();
		if ((params != null) && (!(params.isEmpty()))) {
		      for (String key : params.keySet()) {
		    	  update.set(key, params.get(key));
		      }
		 }
		this.mongoTemplate.updateFirst(query, update,getClz());
	}
	@Override
	public void deleteById(String id) {
		mongoTemplate.remove(new Query(Criteria.where("_id").is(id)), getClz());
	}
	
	
	@Override
	public void saveFile(File file, String fileUrl) {
		  try {  
	            DB db = mongoTemplate.getDb();  
	            GridFS fs = new GridFS(db, FILEURL);  
	            GridFSInputFile inputFile = fs.createFile(file);  
	            inputFile.setFilename(fileUrl);  
	            inputFile.setContentType(fileUrl.substring(fileUrl.lastIndexOf(".")));  
	            inputFile.save();  
	        } catch (IOException e) {  
	            e.printStackTrace();  
	        } 
	}
	
	@Override
	public GridFSDBFile retrieveFileOne(String filename) {
		 try {  
	            DB db = mongoTemplate.getDb();  
	            // 获取fs的根节点  
	            GridFS gridFS = new GridFS(db, FILEURL);  
	            GridFSDBFile dbfile = gridFS.findOne(filename);  
	            if (dbfile != null) {  
	                return dbfile;  
	            }  
	        } catch (Exception e) {  
	        	e.printStackTrace();  
	        }  
	        return null; 
	}

}

 StaffDaoImpl

import org.springframework.stereotype.Repository;

import com.mongodb.dao.StaffDaoI;
import com.mongodb.model.Staff;

@Repository
public class StaffDaoImpl extends BaseDaoImpl<Staff> implements StaffDaoI{

}

 Entity Staff.java(@Id是import org.springframework.data.annotation.Id)

@Document(collection = "staff") 
public class Staff {

	@Id
	private String id;
	
	/**
	 * 姓名
	 */
	private String name;
	
	/**
	 * 邮箱
	 */
	private String[] email;
	
	/**
	 * 出身日期
	 */
	private Date birthday;
	
	/**
	 * 部门名称
	 */
	private String department;
	
	/**
	 * 毕业学校
	 */
	private String school;
	
	/**
	 * 现居地
	 */
	private String location;
	
	/**
	 * 年龄
	 */
	private int age;
	
	/**
	 * 员工评论
	 */
	private List<Comment> comments;

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String[] getEmail() {
		return email;
	}

	public void setEmail(String[] email) {
		this.email = email;
	}

	public Date getBirthday() {
		return birthday;
	}

	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}


	public String getDepartment() {
		return department;
	}

	public void setDepartment(String department) {
		this.department = department;
	}

	public String getSchool() {
		return school;
	}

	public void setSchool(String school) {
		this.school = school;
	}

	public String getLocation() {
		return location;
	}

	public void setLocation(String location) {
		this.location = location;
	}

	public List<Comment> getComments() {
		return comments;
	}

	public void setComments(List<Comment> comments) {
		this.comments = comments;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "Staff [id=" + id + ", name=" + name + ", email="
				+ Arrays.toString(email) + ", birthday=" + birthday
				+ ", department=" + department + ", school=" + school
				+ ", location=" + location + ", age=" + age + ", comments="
				+ comments + "]";
	}
}

 Comment.class(员工评论与员工一对多)

@Document
public class Comment {

	@Id
	private String id;

	/**
	 * 评论内容
	 */
	private String content;

	/**
	 * 评论日期
	 */
	private Date conDate;
	
	public Comment() {
		
	}
	
	public Comment(String content, Date conDate) {
		this.content = content;
		this.conDate = conDate;
	}
	
	

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getContent() {
		return content;
	}

	public void setContent(String content) {
		this.content = content;
	}

	public Date getConDate() {
		return conDate;
	}

	public void setConDate(Date conDate) {
		this.conDate = conDate;
	}

}

 测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:spring.xml" })
public class TestMongoDb {

	@Autowired
	public StaffDaoI staffDao;

	/**
	 * 在数据库test_mongodb中创建一个collection集合staff
	 */
	@Test
	public void test1() {
		Staff staff = new Staff();
		staffDao.createCollection(staff);
	}
	
	/**
	 * 保存一条数据
	 */
	@Test
	public void test2() {
		Staff staff = new Staff();
		staff.setName("chenjunfeng");
		staff.setAge(35);
		staff.setDepartment("1-4-4");
		staff.setLocation("sanshanjie");
		staff.setBirthday(new Date());
		staff.setId("000111");
		staff.setSchool("nanjingdaxue");
		Comment comment=new Comment();
		comment.setConDate(new Date());
		comment.setContent("good leader");
		Comment comment1=new Comment();
		comment.setConDate(new Date());
		comment.setContent("a very good leader");
		List<Comment> comments=new ArrayList<Comment>();
		comments.add(comment);
		comments.add(comment1);
		staff.setComments(comments);
		staff.setEmail(new String[]{"cjf@123.com","smile@163.com"});
		staffDao.insert(staff);
	}
	
	/**
	 * 根据检索条件返回检索个数
	 */
	@Test
	public void test3() {
		Map<String,Object> params=new HashMap<String, Object>();
		params.put("age", 35);
		System.out.println(staffDao.count(params));
	}
	
	/**
	 * 根据条件返回数据的集合
	 */
	@Test
	public void test5() {
		Map<String,Object> params=new HashMap<String, Object>();
		params.put("age", 35);
		System.out.println(staffDao.findByItems(params).get(0).toString());
	}
	
	/**
	 * 存储图片
	 */
	@Test
	public void test6() {
		 File file=new File("D:\\cloud.jpg");
		 String fileUrl="cloud.jpg";
		 staffDao.saveFile(file, fileUrl);
	}
	
	/**
	 * 	取出图片
	 * @throws IOException
	 */
	@Test
	public void test7() throws IOException {
		 String fileUrl="cloud.jpg";
		 GridFSDBFile file=staffDao.retrieveFileOne(fileUrl);
		 System.out.println(file.getId());
		 System.out.println(file.getContentType());
		 System.out.println(file.getChunkSize());
		 file.writeTo(new File("E:\\cloud.jpg"));
	}
	
	//TODO
	//分页就不做测试了，有兴趣的可以尝试一下
}

 有不对的可以指正一下，或者dao层实现方式有不妥的地方请提出

分享到：
| java反射基本知识和应用
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Spring Data MongoDB中文文档

    - **Spring Data MongoDB** 是 **Spring Data** 家族的一员，它提供了一种简单的方式来与 MongoDB 数据库进行交互。通过 Spring Data MongoDB，开发者可以利用 Spring 的强大功能轻松地进行 NoSQL 数据库的操作。 - ...

    Spring Data MongoDB API（Spring Data MongoDB 开发文档）.CHM

    Spring Data MongoDB API。 Spring Data MongoDB 开发文档。

    源码-spring+MongoDB的整合

    当我们需要将Spring与MongoDB整合时，目的是利用Spring的优秀管理和组织能力来操作MongoDB的数据存储。 首先，我们要了解Spring Data MongoDB项目，这是Spring框架对MongoDB支持的一部分。Spring Data MongoDB提供...

    SpringMongodb参考文档.docx

    1.了解Spring ...将存储库与多个Spring Data模块一起使用 7.4。定义查询方法 7.4.1。查询查询策略 7.4.2。查询创建 7.4.3。属性表达式 7.4.4。特殊参数处理 7.4.5。限制查询结果 7.4.6。流式查询结果

    spring 整合mongodb

    在整合Spring与MongoDB时，我们首先需要在`application.properties`或`application.yml`配置文件中设置MongoDB的相关属性，如数据库URL、端口、用户名和密码。例如： ```properties spring.data.mongodb.uri=...

    Spring3.1 MongoDB整合实例（含jar包）已测

    总的来说，Spring 3.1与MongoDB的整合使得Java开发者能以一种声明式的方式处理NoSQL数据库，降低了学习曲线，提高了开发效率。通过掌握这些知识，你将能够构建出灵活、可扩展的后端系统，充分利用MongoDB的强大功能...

    springdata mongodb api文档

    通过这些内容，可以看出SpringData MongoDB API文档是一个功能全面且内容丰富的资源，它不仅包括了API的使用，还包括了最佳实践和设计指南，旨在帮助开发者高效地使用Spring框架与MongoDB数据库进行交互。

    Spring-Mongodb例子

    Spring与MongoDB的整合主要涉及以下几个关键组件： 1. **MongoTemplate**：这是Spring Data MongoDB提供的核心模板类，用于执行MongoDB的各种操作，如查询、更新、插入等。MongoTemplate提供了对数据库操作的抽象，...

    Spring+MongoDB整合 项目

    【Spring+MongoDB整合项目详解】 在现代软件开发中，Spring框架和MongoDB数据库的结合是常见的技术选型，尤其适用于需要快速开发、高可扩展性的应用。...总之，本项目是学习和掌握Spring与MongoDB整合的宝贵资源。

    spring-mongodb整合

    至此，我们已经完成了Spring与MongoDB的基本整合。现在，我们的应用可以使用定义的Repository接口进行CRUD操作，或者通过MongoTemplate进行更复杂的数据库交互。 此外，Spring Data MongoDB还支持更多高级特性，如...

    JAVA操作MongoDB之spring整合

    在本文中，我们将深入探讨如何使用Java操作MongoDB并结合Spring框架进行整合。MongoDB是一个流行的NoSQL数据库，它以JSON格式存储数据，适合处理大量非结构化或半结构化数据。Spring框架则是一个强大的Java企业级...

    Spring-Data-MongoDB3.2

    Spring Data MongoDB 1.9.3与MongoDB 3.2的整合，为开发人员提供了强大的工具集，简化了与非关系型数据库的交互，同时也充分利用了MongoDB 3.2的特性。通过深入理解和实践，可以构建出高效、可扩展的现代应用程序。

    spring-data-mongodb-1.8.0.RELEASE(含源码)

    《Spring Data MongoDB 1.8.0.RELEASE：深度解析与源码剖析》 Spring Data MongoDB 是 Spring 框架中的一个模块，专门用于简化与 MongoDB 数据库的交互。MongoDB 是一个流行的分布式文档数据库，以其灵活性和高性能...

    spring mvc + spring + mongodb 整合

    使用spring mvc + spring data mongodb + mongodb +spring 整合，支持html压缩，支持mongodb用户登录，重写了spring的MongoTemplate支持更多方式，重写MongoTemplate支持切换数据库，支持mongodb集群。spring版本为...

    Spring集成Mongodb配置含jar包

    当我们将Spring与MongoDB结合使用时，可以构建高效、可扩展的数据驱动的应用程序。下面将详细介绍Spring集成MongoDB的相关知识点。 1. **Spring Data MongoDB**: Spring Data项目提供了一套统一的API，使得操作各种...

    spring data mongodb代码参考

    Spring Data MongoDB负责将Java对象与MongoDB文档之间的类型转换。它使用MongoDB Java驱动程序的Document类作为中间表示，确保数据在Java对象和BSON文档之间正确地序列化和反序列化。 9. **索引管理** 通过Spring...

    spring-mongodb整合源码 注释

    在本文中，我们将深入探讨如何将Spring框架与MongoDB数据库进行整合，并且会结合源码进行分析，以帮助你理解其工作原理。Spring是Java领域广泛使用的轻量级框架，而MongoDB则是一种非关系型数据库（NoSQL），两者...

    Spring3+Spring-data-mongodb1.5.6示例

    在本示例中，我们将深入探讨如何在Spring 3框架中集成Spring Data MongoDB 1.5.6，以便高效地处理MongoDB数据库。...通过学习这些示例，你可以更好地理解和掌握Spring 3与Spring Data MongoDB 1.5.6的整合技巧。

Magicbox
Global site tag (gtag.js) - Google Analytics