`

MongoDB整合Spring

mongoDB 
阅读更多 
<dependencies>   
    <dependency>   
        <groupId>javax.servlet</groupId>   
        <artifactId>servlet-api</artifactId>   
        <version>2.5</version>   
        <type>jar</type>   
        <scope>provided</scope>   
    </dependency>   
    <dependency>   
        <groupId>org.slf4j</groupId>   
        <artifactId>slf4j-api</artifactId>   
        <version>1.6.1</version>   
        <type>jar</type>   
        <scope>compile</scope>   
    </dependency>   
    <dependency>   
        <groupId>org.slf4j</groupId>   
        <artifactId>slf4j-log4j12</artifactId>   
        <version>1.7.5</version>   
        <type>jar</type>   
        <scope>runtime</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>   
</dependencies>


添加spring配置文件 
<?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="liming.mongodb.example" />   
  
    <mongo:mongo host="127.0.0.1" port="27017" />   
  
    <!-- mongo的工厂，通过它来取得mongo实例,dbname为mongodb的数据库名，没有的话会自动创建 -->   
    <mongo:db-factory dbname="student" 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="climing.mongodb.example.data.model" />   
  
    <!-- mongodb bean的仓库目录，会自动扫描扩展了MongoRepository接口的接口进行注入 -->   
    <mongo:repositories base-package="liming.mongodb.example.data.impl" />   
  
    <context:annotation-config />   
  
</beans>





增删改查 
package liming.mongodb.example.data.model;   
  
import java.util.Date;   
  
import org.springframework.data.annotation.Id;   
import org.springframework.data.mongodb.core.mapping.Document;   
  
@Document(collection = "user")   
public class UserEntity {   
  
    @Id  
    private String id;   
    private NameEntity name;   
    private int age;   
    private int works;   
    private Date birth;   
    private String password;   
    private String regionName;   
    private String[] special;   
  
    public String getId() {   
        return id;   
    }   
  
    public void setId(String id) {   
        this.id = id;   
    }   
  
    public NameEntity getName() {   
        return name;   
    }   
  
    public void setName(NameEntity name) {   
        this.name = name;   
    }   
  
    public int getAge() {   
        return age;   
    }   
  
    public void setAge(int age) {   
        this.age = age;   
    }   
  
    public int getWorks() {   
        return works;   
    }   
  
    public void setWorks(int works) {   
        this.works = works;   
    }   
  
    public Date getBirth() {   
        return birth;   
    }   
  
    public void setBirth(Date birth) {   
        this.birth = birth;   
    }   
  
    public String getPassword() {   
        return password;   
    }   
  
    public void setPassword(String password) {   
        this.password = password;   
    }   
  
    public String getRegionName() {   
        return regionName;   
    }   
  
    public void setRegionName(String regionName) {   
        this.regionName = regionName;   
    }   
  
    public String[] getSpecial() {   
        return special;   
    }   
  
    public void setSpecial(String[] special) {   
        this.special = special;   
    }   
  
}  




package liming.mongodb.example.data.model;   
  
public class NameEntity {   
  
    private String username;   
  
    private String nickname;   
  
    public String getUsername() {   
        return username;   
    }   
  
    public void setUsername(String username) {   
        this.username = username;   
    }   
  
    public String getNickname() {   
        return nickname;   
    }   
  
    public void setNickname(String nickname) {   
        this.nickname = nickname;   
    }   
  
}  





package liming.mongodb.example.data;   
  
import java.util.List;   
  
import liming.mongodb.example.data.model.UserEntity;   
  
import org.springframework.transaction.annotation.Transactional;   
  
@Transactional  
public interface UserDao {   
  
    public abstract void _test();   
  
    public abstract void createCollection();   
  
    public abstract List<UserEntity> findList(int skip, int limit);   
  
    public abstract List<UserEntity> findListByAge(int age);   
  
    public abstract UserEntity findOne(String id);   
  
    public abstract UserEntity findOneByUsername(String username);   
  
    public abstract void insert(UserEntity entity);   
  
    public abstract void update(UserEntity entity);   
  
}  





package liming.mongodb.example.data.impl;   
  
import java.util.List;   
import java.util.Set;   
  
import liming.mongodb.example.data.UserDao;   
import liming.mongodb.example.data.model.UserEntity;   
  
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;   
  
@Repository  
public class UserDaoImpl implements UserDao {   
  
    public static final Logger logger = LoggerFactory.getLogger(UserDaoImpl.class);   
  
    @Autowired  
    private MongoTemplate mongoTemplate;   
  
    @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() {   
        if (!this.mongoTemplate.collectionExists(UserEntity.class)) {   
            this.mongoTemplate.createCollection(UserEntity.class);   
        }   
    }   
  
    @Override  
    public List<UserEntity> findList(int skip, int limit) {   
        Query query = new Query();   
        query.with(new Sort(new Order(Direction.ASC, "_id")));   
        query.skip(skip).limit(limit);   
        return this.mongoTemplate.find(query, UserEntity.class);   
    }   
  
    @Override  
    public List<UserEntity> findListByAge(int age) {   
        Query query = new Query();   
        query.addCriteria(new Criteria("age").is(age));   
        return this.mongoTemplate.find(query, UserEntity.class);   
    }   
  
    @Override  
    public UserEntity findOne(String id) {   
        Query query = new Query();   
        query.addCriteria(new Criteria("_id").is(id));   
        return this.mongoTemplate.findOne(query, UserEntity.class);   
    }   
  
    @Override  
    public UserEntity findOneByUsername(String username) {   
        Query query = new Query();   
        query.addCriteria(new Criteria("name.username").is(username));   
        return this.mongoTemplate.findOne(query, UserEntity.class);   
    }   
  
    @Override  
    public void insert(UserEntity entity) {   
        this.mongoTemplate.insert(entity);   
  
    }   
  
    @Override  
    public void update(UserEntity entity) {   
        Query query = new Query();   
        query.addCriteria(new Criteria("_id").is(entity.getId()));   
        Update update = new Update();   
        update.set("age", entity.getAge());   
        update.set("password", entity.getPassword());   
        update.set("regionName", entity.getRegionName());   
        update.set("special", entity.getSpecial());   
        update.set("works", entity.getWorks());   
        update.set("name", entity.getName());   
        this.mongoTemplate.updateFirst(query, update, UserEntity.class);   
  
    }   
  
}  






package liming.mongodb.example;   
  
import java.util.Arrays;   
import java.util.Date;   
import java.util.List;   
  
import liming.mongodb.example.data.UserDao;   
import liming.mongodb.example.data.impl.UserDaoImpl;   
import liming.mongodb.example.data.model.UserEntity;   
  
import org.springframework.context.ConfigurableApplicationContext;   
import org.springframework.context.support.ClassPathXmlApplicationContext;   
  
public class ApplicationSpring {   
  
    public static void main(String[] args) {   
  
        System.out.println("Bootstrapping HelloMongo");   
  
        ConfigurableApplicationContext context = null;   
        context = new ClassPathXmlApplicationContext("applicationContext.xml");   
  
        UserDao userDao = context.getBean(UserDaoImpl.class);   
            userDao._test();   
        UserEntity entity1 = new UserEntity();   
        entity1.setId("5");   
        entity1.setAge(1);   
        entity1.setBirth(new Date());   
        entity1.setPassword("asdfasdf");   
        entity1.setRegionName("北京");   
        entity1.setWorks(1);   
        userDao.insert(entity1);   
        userDao.update(entity1);   
        userDao.createCollection();   
       
        List<UserEntity> list = userDao.findList(0, 10);   
        for (UserEntity e : list) {   
            System.out.println("all - id=" + e.getId() + ", age=" + e.getAge() + ", password=" + e.getPassword() + ", regionName=" + e.getRegionName() + ", special=" + Arrays.toString(e.getSpecial())   
                    + ", name=" + e.getName().getUsername() + "-" + e.getName().getNickname() + ", birth=" + e.getBirth());   
        }   
  
        list = userDao.findListByAge(1);   
        for (UserEntity e : list) {   
            System.out.println("age=1 - id=" + e.getId() + ", age=" + e.getAge() + ", password=" + e.getPassword() + ", regionName=" + e.getRegionName() + ", special="  
                    + Arrays.toString(e.getSpecial()) + ", name=" + e.getName().getUsername() + "-" + e.getName().getNickname() + ", birth=" + e.getBirth());   
        }   
  
        UserEntity e = userDao.findOne("1");   
        System.out.println("id=1 - id=" + e.getId() + ", age=" + e.getAge() + ", password=" + e.getPassword() + ", regionName=" + e.getRegionName() + ", special=" + Arrays.toString(e.getSpecial())   
                + ", name=" + e.getName().getUsername() + "-" + e.getName().getNickname() + ", birth=" + e.getBirth());   
  
        e = userDao.findOneByUsername("limingnihao");   
        System.out.println("username=limingnihao - id=" + e.getId() + ", age=" + e.getAge() + ", password=" + e.getPassword() + ", regionName=" + e.getRegionName() + ", special="  
                + Arrays.toString(e.getSpecial()) + ", name=" + e.getName().getUsername() + "-" + e.getName().getNickname() + ", birth=" + e.getBirth());   
  
           
        System.out.println("DONE!");   
    }   
  
}
分享到：
| MQ消息接收接口
评论
发表评论

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

相关推荐

    mongodb整合spring、hibernate、mysql

    在这个项目中，“mongodb整合spring、hibernate、mysql”意味着开发者将MongoDB作为NoSQL数据库，Spring作为应用的管理和数据访问层，而Hibernate则用于处理MySQL的关系型数据库操作。这样的集成允许应用同时利用两...

    mongodb整合spring文档

    ### Spring 整合 MongoDB 数据库配置详解 #### 一、前言 在现代软件开发过程中，集成NoSQL数据库如MongoDB已成为一种趋势，特别是在需要处理大量非结构化数据的应用场景中。Spring框架作为Java领域中非常流行的...

    JAVA操作MongoDB之spring整合

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

    spring 整合mongodb

    本文将深入探讨如何整合Spring框架与MongoDB，以实现高效的数据存储和检索。 首先，Spring Data MongoDB是Spring框架的一个模块，它提供了与MongoDB集成的简单API和ORM（对象关系映射）功能。Spring Data MongoDB...

    mongodb&spring&struts&springdatamongodb整合，带所有jar,需要的拿走

    本项目整合了这四个技术，使得开发者可以在Java Web应用程序中高效地利用MongoDB作为非关系型数据库，Spring作为依赖注入和管理容器，Struts作为前端控制器，Spring Data MongoDB则简化了对MongoDB的操作。...

    MongoDB与Spring整合

    当我们将MongoDB与Spring整合时，可以充分利用Spring的依赖注入和数据访问抽象，简化MongoDB在Java应用中的使用。 首先，整合MongoDB与Spring的关键在于Spring Data MongoDB模块，它提供了对MongoDB的数据访问支持...

    mongodb-spring 整合包

    当我们将MongoDB与Spring整合时，可以利用Spring的强大功能来简化MongoDB的使用，提高开发效率。本整合包正是针对这一需求而准备的，它包含了实现MongoDB与Spring集成所需的所有组件。 首先，我们需要了解MongoDB-...

    MongoDB整合Spring实例详细讲解(含代码)

    总之，MongoDB与Spring的整合涉及配置MongoDB连接、创建MongoTemplate实例，以及利用Spring Data MongoDB的Repository模式进行数据访问。正确配置和使用这些组件，可以帮助开发者快速构建高效、灵活的MongoDB驱动的...

    Spring+MongoDB整合 项目

    项目整合Spring和MongoDB，主要涉及以下几个核心模块： 1. **数据访问层**：Spring Data MongoDB模块提供了与MongoDB的集成，包括MongoTemplate和MongoRepository接口，使得操作MongoDB就像操作传统JDBC一样简单。...

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

    在整合Spring和MongoDB时，你需要以下核心组件： 1. **MongoDB Java驱动**：这是与MongoDB服务器通信的基础，提供了连接、查询、更新等操作。在本实例中，包含的jar包应包含此驱动。 2. **Spring Data MongoDB**：...

    spring mvc + spring + mongodb 整合

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

    spring-springMVC-mongodb整合例子

    这个例子中的"spring-springMVC-mongodb整合"是一个很好的学习和实践项目，可以帮助开发者深入理解这些技术的结合使用。通过这样的整合，开发者能够构建出更加灵活、适应现代互联网需求的应用程序。

    springboot-mongodb整合源码

    在IT行业中，Spring Boot和MongoDB的整合是一个常见的任务，特别是在构建微服务或者快速开发Web应用时。Spring Boot简化了Spring应用的初始设置，而MongoDB则作为一个强大的NoSQL数据库，提供非结构化数据的存储解决...

    spring-mongodb整合

    当我们谈论“Spring-MongoDB整合”时，这意味着我们要将Spring框架与MongoDB数据库集成，以便在Java应用中充分利用MongoDB的优势。 首先，我们需要理解Spring Data MongoDB项目，它是Spring Data模块的一部分，旨在...

    spring-mongodb整合源码 注释

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

    maven(jersey+redis+mongodb+spring)集成

    【标题】：“maven(jersey+redis+mongodb+spring)集成” 在现代软件开发中，集成多种技术栈是常见的需求。"maven(jersey+redis+mongodb+spring)集成"指的是使用Maven作为项目构建工具，将Jersey用于RESTful API开发...

    Spring-Mongodb例子

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

    spring-data-mongodb

    自己开发能跑的项目 spring-data-mongodb整合spring-boot

    源码-spring+MongoDB的整合

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

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