mongodb初成长,spring整合mongodb

pom.xml

  <properties>
    <org.springframework.version>4.3.6.RELEASE</org.springframework.version>
  </properties>

<dependencies>
    <dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-webmvc</artifactId>  
        <version>${org.springframework.version}</version>
    </dependency> 
    <dependency>
	    <groupId>log4j</groupId>
	    <artifactId>log4j</artifactId>
	    <version>1.2.17</version>
	</dependency>
	<dependency>
	    <groupId>org.slf4j</groupId>
	    <artifactId>slf4j-log4j12</artifactId>
	    <version>1.7.23</version>
	</dependency>
    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-mongodb</artifactId>
        <version>1.10.0.RELEASE</version>
    </dependency>
	<dependency>
	    <groupId>commons-fileupload</groupId>
	    <artifactId>commons-fileupload</artifactId>
	    <version>1.3</version>
	</dependency>
	<dependency>
		<groupId>commons-lang</groupId>
		<artifactId>commons-lang</artifactId>
		<version>2.6</version>
	</dependency>
	<dependency>
		<groupId>com.fasterxml.jackson.core</groupId>
		<artifactId>jackson-core</artifactId>
		<version>2.8.6</version>
	</dependency>
	<dependency>
	    <groupId>com.fasterxml.jackson.core</groupId>
	    <artifactId>jackson-databind</artifactId>
	    <version>2.8.6</version>
	</dependency>
		
    
    
    <dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-test</artifactId>
	    <version>${org.springframework.version}</version>
	    <scope>test</scope>
	</dependency>
	<dependency>
	    <groupId>junit</groupId>
	    <artifactId>junit</artifactId>
	    <version>4.12</version>
	    <scope>test</scope>
	</dependency>
</dependencies>

applicationContext.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:mongo="http://www.springframework.org/schema/data/mongo"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context" 
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:util="http://www.springframework.org/schema/util"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
						http://www.springframework.org/schema/beans/spring-beans.xsd
						http://www.springframework.org/schema/data/mongo 
						http://www.springframework.org/schema/data/mongo/spring-mongo.xsd 
						http://www.springframework.org/schema/aop 
						http://www.springframework.org/schema/aop/spring-aop.xsd
						http://www.springframework.org/schema/context 
						http://www.springframework.org/schema/context/spring-context.xsd
						http://www.springframework.org/schema/tx 
						http://www.springframework.org/schema/tx/spring-tx.xsd
						http://www.springframework.org/schema/util
						http://www.springframework.org/schema/util/spring-util.xsd"
	default-autowire="byName">
	
	<!-- 除了具有<context:annotation-config />的功能之外，还具有自动将带有@component,@service,@Repository等注解的对象注册到spring容器中的功能。排除@Controller组件，该组件由SpringMVC配置文件扫描 -->
	<context:component-scan base-package="com.hd.mamainst.app.service,com.hd.mamainst.app.dao,com.hd.mamainst.basedao">
		<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
	</context:component-scan>
	
	<context:property-placeholder location="classpath*:mongodb.properties"  />
	
	
	<!-- mongo客户端连接 -->
	<mongo:mongo-client id="mongoClient" credentials="${mongo.user}:${mongo.pwd}@${mongo.dbname}" host="${mongo.host}" port="${mongo.port}">
        <mongo:client-options
                connections-per-host="${mongo.connectionsPerHost}"
                min-connections-per-host="${mongo.minConnectionsPerHost}"
                threads-allowed-to-block-for-connection-multiplier="${mongo.threadsAllowedToBlockForConnectionMultiplier}"
                connect-timeout="${mongo.connectTimeout}"
                max-wait-time="${mongo.maxWaitTime}"
                socket-keep-alive="${mongo.socketKeepAlive}"
                socket-timeout="${mongo.socketTimeout}"
                max-connection-idle-time="${mongo.maxConnectionIdleTime}"
                max-connection-life-time="${mongo.maxConnectionLifeTime}"
        />
    </mongo:mongo-client>
    
    <!-- mongo工厂 -->
    <mongo:db-factory id="mongoDbFactory" mongo-ref="mongoClient" dbname="${mongo.dbname}" />
    
    <!-- mongo操作模板,注入了前面的mongo工厂和自定义mongo转换器 -->
    <mongo:template id="mongoTemplate" db-factory-ref="mongoDbFactory"  write-concern="NORMAL"/>
</beans>

mongodb.properties

#正式环境
mongo.host=127.0.0.1
mongo.user=mongouser
mongo.pwd=mongpwd
mongo.dbname=test
mongo.port=27017
#每个主机的连接数 
mongo.connectionsPerHost=10
#每个主机的最小连接数
mongo.minConnectionsPerHost=5
#线程队列数，它以上面connectionsPerHost值相乘的结果就是线程队列最大值。如果连接线程排满了队列就会抛出“Out of semaphores to get db”错误
mongo.threadsAllowedToBlockForConnectionMultiplier=5
#连接超时的毫秒。0是默认和无限
mongo.connectTimeout=10000
#最大等待连接的线程阻塞时间
mongo.maxWaitTime=120000
#此参数表示socket I/O读写超时时间,推荐为不超时，即 0    Socket.setSoTimeout(int)
mongo.socketTimeout=0
#该标志用于控制socket保持活动的功能，通过防火墙保持连接活着
mongo.socketKeepAlive=false
#最大连接空闲时间
mongo.maxConnectionIdleTime=1500
#最大连接存留时间
mongo.maxConnectionLifeTime=0


#mongo slave
#mongo.heartbeatSocketTimeout=1000
#mongo.heartbeatConnectTimeout=1500
#mongo.minHeartbeatFrequency=5
#mongo.heartbeatFrequency=10

编写测试类进行测试

MongDbTest.java

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class MongoDbTest {
	@Resource
    private MongoTemplate mongoTemplate;
	private static List<String> deleteList;

	@Before
	public void beforeTest() {
		deleteList=new ArrayList<>();
	}
	
	@After
	public void afterTest() {
		for (String id : deleteList) {
			mongoTemplate.remove(new Query(Criteria.where("_id").is(id)), "user");
		}
	}
    
    @Test
    public void saveTest() {
    	//准备
    	AccountDocument user1 = new AccountDocument();
		user1.setCreatedate(new Date());
		user1.setIssigneddelete(false);
		user1.setLabel("测试用户");
		
		//测试
		mongoTemplate.insert(user1);
		
		//记录删除
		deleteList.add(user1.getId());
		
		//验证
        Assert.assertNotNull(user1.getId());
    }
    
    @Test
    public void findTest() {
    	//准备
		AccountDocument user1 = new AccountDocument();
		user1.setCreatedate(new Date());
		user1.setIssigneddelete(false);
		user1.setAccountmobile("18080147050");
		user1.setLabel("测试用户");
		mongoTemplate.insert(user1);
		deleteList.add(user1.getId());
    	
		//测试
		Query query = new Query(Criteria.where("accountmobile").is("18080147050"));
		List<AccountDocument> list = mongoTemplate.find(query, AccountDocument.class);
		
		//验证
        Assert.assertTrue(list!=null&&list.size()>0);
    }
    
    @Test
    public void updateTest() {
    	//准备
		AccountDocument user1 = new AccountDocument();
		user1.setCreatedate(new Date());
		user1.setIssigneddelete(false);
		user1.setAccountmobile("18888888888");
		user1.setLabel("测试用户");
		mongoTemplate.insert(user1);
		deleteList.add(user1.getId());
    	
		//测试
    	Query query = new Query(Criteria.where("_id").is(user1.getId()));
		mongoTemplate.updateFirst(query, new Update().set("accountmobile", "18080147050"), AccountDocument.class);
		
		//验证
        Assert.assertTrue("18080147050".equals(mongoTemplate.findOne(query, AccountDocument.class).getAccountmobile()));
    }
    
    @Test
    public void deleteTest() {
    	//准备
		AccountDocument user1 = new AccountDocument();
		user1.setCreatedate(new Date());
		user1.setIssigneddelete(false);
		user1.setLabel("测试用户");
		mongoTemplate.insert(user1);
		deleteList.add(user1.getId());
    	
		//测试
		Query query = new Query(Criteria.where("_id").is(user1.getId()));
		mongoTemplate.remove(query, AccountDocument.class);
		
		//验证
        Assert.assertTrue(mongoTemplate.findOne(query, AccountDocument.class)==null);
    }
}

baseDaoImpl(接口略):

/**
 * Dao实现
 * @author 
 *
 * @param <T>
 */
@Repository
public class BaseDaoImpl<T extends BaseDocument> implements  BaseDao<T> {

	@Autowired
    protected MongoTemplate mongoTemplate;

    public T add(T entity) {
    	if(entity.getIssigneddelete()==null){
    		entity.setIssigneddelete(false);
    	}
    	entity.setCreatedate(new Date());
        mongoTemplate.insert(entity);
        return entity;
    }
    public T queryById(String id) {
        return mongoTemplate.findById(id, this.getEntityClass());
    }

    public List<T> queryList() {
        return mongoTemplate.findAll(this.getEntityClass());
    }

    public List<T> queryList(Query query) {
        return mongoTemplate.find(query, this.getEntityClass());
    }

    public T queryFirst(Query query) {
        return mongoTemplate.findOne(query, this.getEntityClass());
    }

    public Page<T> queryPage(Page<T> page, Query query) {
        //如果没有条件 则所有全部
        query=query==null?new Query(Criteria.where("_id").exists(true)):query;
        long count = this.queryCount(query);
        // 总数
        page.setTotalCount((int) count);
        int currentPage = page.getCurrentPage();
        int pageSize = page.getPageSize();
        query.skip((currentPage - 1) * pageSize).limit(pageSize);
        List<T> rows = this.queryList(query);
        page.build(rows);
        return page;
    }

    public long queryCount(Query query) {
        return mongoTemplate.count(query, this.getEntityClass());
    }

    public WriteResult update(Query query, Update update) {
        if (update==null) {
            return null;
        }
        return mongoTemplate.updateMulti(query, update, this.getEntityClass());
    }

    public T updateOne(Query query, Update update) {
        if (update==null) {
            return null;
        }
        return mongoTemplate.findAndModify(query, update, this.getEntityClass());
    }

    public WriteResult update(T entity) {
        Field[] fields = entity.getClass().getSuperclass().getDeclaredFields();
        if (fields == null || fields.length <= 0) {
            return null;
        }
        Field idField = null;
        // 查找ID的field
        for (Field field : fields) {
            if (field.getName() != null
                    && "id".equals(field.getName().toLowerCase())) {
                idField = field;
                break;
            }
        }
        if (idField == null) {
            return null;
        }
        idField.setAccessible(true);
        String id=null;
        try {
            id = (String) idField.get(entity);
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        if (id == null || "".equals(id.trim()))
            return null;
        // 根据ID更新
        Query query = new Query(Criteria.where("_id").is(id));
        
        
        fields = entity.getClass().getDeclaredFields();
        Update update = new Update();
        for (Field field : fields) {
            field.setAccessible(true);
            try {
                Object value = field.get(entity);
                if (value != null) {
                    if ("id".equals(field.getName().toLowerCase())){
                        continue;
                    } else {
                        update = update.set(field.getName(), value);
                    }
                }
            } catch (Exception e) {
               continue;
            }
        }
        return mongoTemplate.updateFirst(query, update, getEntityClass());
    }

    public void deleteObjectByLogic(T t) {
    	mongoTemplate.updateMulti(new Query(Criteria.where("_id").is(t.getId())), Update.update("issigneddelete", true).set("deletedate", new Date()), this.getEntityClass());
    }
    
    public void deleteByLogic(Query query) {
    	mongoTemplate.updateMulti(query, Update.update("issigneddelete", true).set("deletedate", new Date()), this.getEntityClass());
    }
    
    public void deleteObjectByPhysics(T t) {
    	mongoTemplate.remove(new Query(Criteria.where("_id").is(t.getId())), this.getEntityClass());
    }
    
    public void deleteByPhysics(Query query) {
    	mongoTemplate.remove(query, this.getEntityClass());
    }
    /**
     * 获得泛型类
     */
    @SuppressWarnings("unchecked")
	private Class<T> getEntityClass() {
    	Type genType = getClass().getGenericSuperclass();
        if (genType instanceof ParameterizedType) {
        	Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
            if(params!=null&¶ms.length>0){
            	return (Class<T>) params[0];
            }
        }
        return null;
    }
}

Page.java

public class Page<T> implements Serializable {
	private static final long serialVersionUID = 5760097915453738435L;
	public static final int DEFAULT_PAGE_SIZE = 10;
	/**
	 * 每页显示个数
	 */
	private int pageSize;
	/**
	 * 当前页数
	 */
	private int currentPage;
	/**
	 * 总页数
	 */
	private int totalPage;
	/**
	 * 总记录数
	 */
	private int totalCount;
	/**
	 * 结果列表
	 */
	private List<T> rows;
	
	public Page(){
		 this.currentPage = 1;
	     this.pageSize = DEFAULT_PAGE_SIZE;
	}
	public Page(int currentPage,int pageSize){
		this.currentPage=currentPage<=0?1:currentPage;
		this.pageSize=pageSize<=0?1:pageSize;
	}
	public int getPageSize() {
		return pageSize;
	}
	public void setPageSize(int pageSize) {
		this.pageSize = pageSize;
	}
	public int getCurrentPage() {
		return currentPage;
	}
	public void setCurrentPage(int currentPage) {
		this.currentPage = currentPage;
	}
	public int getTotalPage() {
		return totalPage;
	}
	public void setTotalPage(int totalPage) {
		this.totalPage = totalPage;
	}
	public int getTotalCount() {
		return totalCount;
	}
	public void setTotalCount(int totalCount) {
		this.totalCount = totalCount;
	}

	/**
	 * 设置结果 及总页数
	 * @param list
	 */
	 public void build(List<T> rows) {  
	        this.setRows(rows);  
	        int count =  this.getTotalCount();  
	        int divisor = count / this.getPageSize();  
	        int remainder = count % this.getPageSize();  
	        this.setTotalPage(remainder == 0 ? divisor == 0 ? 1 : divisor : divisor + 1);  
	    }
	public List<T> getRows() {
		return rows;
	}
	public void setRows(List<T> rows) {
		this.rows = rows;
	}  
}

AccountDao.java

@Repository
public class AccountDao extends BaseDaoImpl<AccountDocument>{
}

编写测试类进行测试

BaseDaoImplTest.java

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class BaseDaoImplTest{
	@Autowired
	private AccountDao userDao;
	@Autowired
	private MongoTemplate mongoTemplate;
	private static List<String> deleteList;

	@Before
	public void beforeTest() {
		deleteList=new ArrayList<>();
	}
	
	@After
	public void afterTest() {
		for (String id : deleteList) {
			mongoTemplate.remove(new Query(Criteria.where("_id").is(id)), "accountDocument");
		}
	}
	
	
	@Test
	public void addTest() {
		//准备
		AccountDocument user = new AccountDocument();
		user.setAccountmobile("18080147050");
		user.setAccountpassword("654321");
		
		//测试
		userDao.add(user);
		
		//记录删除
		deleteList.add(user.getId());
				
		//验证
		Assert.assertNotNull(user);
	}

	@Test
	public void findTest() {
		//准备
		AccountDocument user = new AccountDocument();
		user.setAccountmobile("18080147050");
		userDao.add(user);
		deleteList.add(user.getId());
		
		//测试
		Query query = new Query(Criteria.where("_id").is(user.getId()));
		user = userDao.queryFirst(query);
		
		//验证
		Assert.assertTrue(user!=null);
	}

	@Test
	public void updateTest() {
		//准备
		AccountDocument user = new AccountDocument();
		user.setAccountmobile("18080147050");
		userDao.add(user);
		deleteList.add(user.getId());
		
		//测试
		user.setAccountsex("man");
		user.setAccountmobile("18080147050");
		userDao.update(user);
		
		//验证
		user = userDao.queryFirst(new Query(Criteria.where("_id").is(user.getId())));
		Assert.assertTrue(user!= null && "man".equals(user.getAccountsex()));
	}

	@Test
	public void deleteByLogicTest() {
		//准备
		AccountDocument user = new AccountDocument();
		user.setAccountmobile("18080147050");
		userDao.add(user);
		deleteList.add(user.getId());
		
		//测试
		Query query = new Query(Criteria.where("_id").is(user.getId()));
		userDao.deleteByLogic(query);
		
		//验证
		user = userDao.queryFirst(query);
		Assert.assertTrue(user.getIssigneddelete()&&user.getDeletedate()!=null);
	}
	
	@Test
	public void deleteByPhysics() {
		//准备
		AccountDocument user = new AccountDocument();
		user.setAccountmobile("18080147050");
		userDao.add(user);
		deleteList.add(user.getId());
		
		//测试
		Query query = new Query(Criteria.where("_id").is(user.getId()));
		userDao.deleteByPhysics(query);
		
		//验证
		user = userDao.queryFirst(query);
		Assert.assertTrue(user==null);
	}
	@Test
	public void deleteObjectByLogic() {
		//准备
		AccountDocument user = new AccountDocument();
		user.setAccountmobile("18080147050");
		userDao.add(user);
		deleteList.add(user.getId());
		
		//测试
		userDao.deleteObjectByLogic(user);
		
		//验证
		Query query = new Query(Criteria.where("_id").is(user.getId()));
		user = userDao.queryFirst(query);
		Assert.assertTrue(user.getIssigneddelete()&&user.getDeletedate()!=null);
	}
	@Test
	public void deleteObjectByPhysics() {
		//准备
		AccountDocument user = new AccountDocument();
		user.setAccountmobile("18080147050");
		userDao.add(user);
		deleteList.add(user.getId());
		
		//测试
		userDao.deleteObjectByPhysics(user);
		
		//验证
		Query query = new Query(Criteria.where("_id").is(user.getId()));
		user = userDao.queryFirst(query);
		Assert.assertTrue(user==null);
	}
}