Spring整合mongdb

最新推荐文章于 2023-01-30 11:27:25 发布

u010476464

最新推荐文章于 2023-01-30 11:27:25 发布

阅读量607

点赞数

分类专栏：数据库文章标签： spring整合mo

本文链接：https://blog.csdn.net/u010476464/article/details/47833409

版权

数据库专栏收录该内容

7 篇文章 0 订阅

订阅专栏

首先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:aop="http://www.springframework.org/schema/aop"  
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:util="http://www.springframework.org/schema/util"  
    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/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd  
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd  
    http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-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.mongo" />  
    <!-- 获取配置资源 -->  
    <context:property-placeholder location="classpath:jdbc.properties" />  

    <bean class="com.mongo.DAOImpl.UserDaoImpl"></bean>  

    <mongo:mongo id="mongo"  replica-set="${mongo.replicaSet}">  
      <!--  
         connections-per-host: 每个主机答应的连接数（每个主机的连接池大小），当连接池被用光时，会被阻塞住   
         max-wait-time: 被阻塞线程从连接池获取连接的最长等待时间（ms）  
         connect-timeout:在建立（打开）套接字连接时的超时时间（ms）  
         socket-timeout:套接字超时时间;该值会被传递给Socket.setSoTimeout(int)  
         slave-ok:指明是否答应驱动从次要节点或者奴隶节点读取数据  
         -->  
    <mongo:options  
        connections-per-host="${mongo.connectionsPerHost}"  
        threads-allowed-to-block-for-connection-multiplier="${mongo.threadsAllowedToBlockForConnectionMultiplier}"  
        connect-timeout="${mongo.connectTimeout}"   
        max-wait-time="${mongo.maxWaitTime}"  
        auto-connect-retry="${mongo.autoConnectRetry}"   
        socket-keep-alive="${mongo.socketKeepAlive}"  
        socket-timeout="${mongo.socketTimeout}"  
        slave-ok="${mongo.slaveOk}"  
        write-number="${mongo.writeNumber}"  
        write-timeout="${mongo.riteTimeout}"  
        write-fsync="${mongo.writeFsync}"/>  
    </mongo:mongo>  
       <!-- 设置使用的数据库 名-->  
      <mongo:db-factory dbname="test" mongo-ref="mongo"/>  
      <!-- mongodb的模板 -->  
     <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">  
        <constructor-arg name="mongoDbFactory" ref="mongoDbFactory"/>  
     </bean>  
</beans>

jdbc.properties：

mongo.replicaSet=192.168.104.131:27017  
mongo.connectionsPerHost=8  
mongo.threadsAllowedToBlockForConnectionMultiplier=4  
mongo.connectTimeout=1000  
mongo.maxWaitTime=1500  
mongo.autoConnectRetry=true  
mongo.socketKeepAlive=true  
mongo.socketTimeout=1500  
mongo.slaveOk=true  
mongo.writeNumber=1  
mongo.riteTimeout=0  
mongo.writeFsync=true

添加的实体类：

package model;

import java.io.Serializable;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

@Document
public class User implements Serializable {

    private static final long serialVersionUID = -7351729135012380019L;
    @Id
    private String id;  
    private String name;  
    private int age;  
    private String password;  

    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
    public int getAge() {  
        return age;  
    }  
    public void setAge(int age) {  
        this.age = age;  
    }  
    public String getPassword() {  
        return password;  
    }  
    public void setPassword(String password) {  
        this.password = password;  
    }  
    public String getId() {  
        return id;  
    }  
    public void setId(String id) {  
        this.id = id;  
    }
}

方法接口：MongoBase

package DAO;

import java.io.File;
import java.util.List;
import java.util.Map;

import model.User;

import com.mongodb.gridfs.GridFSDBFile;

public interface MongoBase<T> {
    //添加  
    public void insert(T object,String collectionName);    
    //根据条件查找  
    public T findOne(Map<String,Object> params,String collectionName);    
    //查找所有  
    public List<T> findAll(Map<String,Object> params,String collectionName);    
    //修改  
    public void update(Map<String,Object> params,String collectionName);   
    //创建集合  
    public void createCollection(String collectionName);  
    //根据条件删除  
    public void remove(Map<String,Object> params,String collectionName);
    //保存文件
    public void SaveFile(String collectionName, File file, String fileid,
            String companyid, String filename);
    //取出文件
    public GridFSDBFile retrieveFileOne(String collectionName, String filename);
    //分页查询
    public List<User> findList(int skip, int limit); 
}

UserDao

package DAO;

import model.User;

public interface UserDao extends MongoBase<User> {
}

CRUD方法：

package DAOImpl;

import java.io.File;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;

import model.User;

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.gridfs.GridFS;
import com.mongodb.gridfs.GridFSDBFile;
import com.mongodb.gridfs.GridFSInputFile;

import DAO.UserDao;

@Repository("userDaoImpl")
public class UserDaoImpl implements UserDao {

    @Resource  
    private MongoTemplate mongoTemplate;

    @Override
    public void insert(User object, String collectionName) {
        mongoTemplate.insert(object, collectionName);
    }

    @Override
    public User findOne(Map<String, Object> params, String collectionName) {
        return mongoTemplate.findOne(new Query(Criteria.where("id").is(params.get("id"))), User.class,collectionName);  
    }

    @Override
    public List<User> findAll(Map<String, Object> params, String collectionName) {
        List<User> result = mongoTemplate.find(new Query(Criteria.where("age").lt(params.get("maxAge"))), User.class,collectionName);  
        return result;
    }

    @Override
    public void update(Map<String, Object> params, String collectionName) {
         mongoTemplate.upsert(new Query(Criteria.where("id").is(params.get("id"))), new Update().set("name", params.get("name")), User.class,collectionName);    
    }

    @Override
    public void createCollection(String collectionName) {
        mongoTemplate.createCollection(collectionName);
    }

    @Override
    public void remove(Map<String, Object> params, String collectionName) {
        mongoTemplate.remove(new Query(Criteria.where("id").is(params.get("id"))),User.class,collectionName);
    }

    @Override
    public void SaveFile(String collectionName, File file, String fileid,
            String companyid, String filename) {
        try {
            //获取连接数据库
            DB db = this.mongoTemplate.getDb();
            // 存储fs的根节点，文件操作是在DB的基础上实现的，与表和文档没有关系
            GridFS gridFS = new GridFS(db, collectionName);
            GridFSInputFile gfs = gridFS.createFile(file);
            gfs.put("aliases", companyid);
            gfs.put("filename", fileid);
            gfs.put("contentType", filename.substring(filename.lastIndexOf(".")));
            gfs.save();
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("存储文件时发生错误！！！");
        }
    }

    @Override
    public GridFSDBFile retrieveFileOne(String collectionName, String filename) {
        try {
            DB db = this.mongoTemplate.getDb();
            // 获取fs的根节点
            GridFS gridFS = new GridFS(db, collectionName);
            GridFSDBFile dbfile = gridFS.findOne(filename);
            if (dbfile != null) {
                return dbfile;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public List<User> 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, User.class);
    }   
}

测试类：

package test;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import model.User;

import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import DAO.UserDao;

public class TestUser {

    private static UserDao userDaoImpl;  
    private static  ClassPathXmlApplicationContext  app;  
    private static String collectionName;

    public static void initSpring() {   
        try {         
         app = new ClassPathXmlApplicationContext(new String[] { "classpath:applicationContext-mongo.xml",    
                "classpath:spring-dispatcher.xml" });    
        userDaoImpl = (UserDao) app.getBean("userDaoImpl");   
        collectionName ="users";  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
           }   

        @Test
        public void testAdd()  
        {  

            //添加一百个user  
            for(int i=0;i<100;i++){  
                User user =new User();  
                user.setId(""+i);  
                user.setAge(i);  
                user.setName("zcy"+i);  
                user.setPassword("zcy"+i);  
                userDaoImpl.insert(user,collectionName);  
            }  
            Map<String,Object> params=new HashMap<String,Object>();  
            params.put("maxAge", 50);  
            List<User> list=userDaoImpl.findAll(params,collectionName);  
            System.out.println("user.count()=="+list.size());  
        }

        @Test
        public void testUdate(){  
            Map<String,Object> params=new HashMap<String,Object>();  
            params.put("id", "1");  
            User user=userDaoImpl.findOne(params, collectionName);  
            System.out.println("user.name==="+user.getName());  
            System.out.println("=============update==================");  
            params.put("name", "hello");  
            userDaoImpl.update(params, collectionName);  
             user=userDaoImpl.findOne(params, collectionName);  
            System.out.println("user.name==="+user.getName());
        }
}

所需jar包：
log4j-1.2.14.jar
org.springframework.beans-3.0.5.RELEASE.jar
org.springframework.core-3.0.5.RELEASE.jar
slf4j-api-1.5.6.jar
slf4j-log4j12-1.5.6.jar
spring-aop-3.0.5.RELEASE.jar
spring-beans-3.0.5.RELEASE.jar
spring-context-3.0.5.RELEASE.jar
spring-context-support-3.0.5.RELEASE.jar
spring-data-commons-1.10.2.RELEASE.jar
spring-data-mongodb-1.7.2.RELEASE.jar
spring-tx-3.0.5.RELEASE.jar
mongo-java-driver-2.10.1.jar
junit.jar