spring调用mongodb

1.环境

     Jdk：1.6.0_10-rc2

     Spring3.1.2  下载

     依赖jar文件：

  

2.相关配置

①.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/context   
            http://www.springframework.org/schema/context/spring-context-3.0.xsd  
            http://www.springframework.org/schema/data/mongo  
            http://www.springframework.org/schema/data/mongo/spring-mongo-1.0.xsd">  
          
        <mongo:mongo id="mongo"  host="127.0.0.1" port="27017"   />  
          
        <bean id="userCredentials" class="org.springframework.data.authentication.UserCredentials">  
            <constructor-arg name="username"  value="userName"/>  
            <constructor-arg name="password"  value="password"/>  
        </bean>  
          
        <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">  
            <constructor-arg ref="mongo" />  
            <constructor-arg value="test-mongo" />  
            <constructor-arg ref="userCredentials" />  
        </bean>  
          
        <bean id="userDao" class="com.x.mongodb.dao.impl.UserDao" />  
    </beans>  

 

②.MongoTemplate  Api

 

    package com.x.mongodb.dao.support;  
      
    import org.springframework.beans.BeansException;  
    import org.springframework.context.ApplicationContext;  
    import org.springframework.context.ApplicationContextAware;  
    import org.springframework.data.mongodb.core.MongoTemplate;  
      
     
    public abstract class AbstractBaseMongoTemplete implements ApplicationContextAware {  
          
        protected MongoTemplate mongoTemplate;  
      
        /** 
         * 设置mongoTemplate 
         * @param mongoTemplate the mongoTemplate to set 
         */  
        public void setMongoTemplate(MongoTemplate mongoTemplate) {  
            this.mongoTemplate = mongoTemplate;  
        }  
          
        public void setApplicationContext(ApplicationContext applicationContext)  
                throws BeansException {  
            MongoTemplate mongoTemplate = applicationContext.getBean("mongoTemplate", MongoTemplate.class);  
            setMongoTemplate(mongoTemplate);  
        }  
    }  



    package com.x.mongodb.dao.impl;  
      
    import java.util.List;  
      
    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 com.x.mongodb.dao.IUserDao;  
    import com.x.mongodb.dao.support.AbstractBaseMongoTemplete;  
    import com.x.mongodb.entity.User;  
   
    public class UserDao extends AbstractBaseMongoTemplete implements IUserDao {  
      
        /** 
         * 新增 
         * <br>------------------------------<br> 
         * @param user 
         */  
        public void insert(User user) {  
            mongoTemplate.insert(user);  
        }  
          
        /** 
         * 批量新增 
         * <br>------------------------------<br> 
         * @param users 
         */  
        public void insertAll(List<User> users) {  
            mongoTemplate.insertAll(users);  
        }  
          
        /** 
         * 删除,按主键id, 如果主键的值为null,删除会失败 
         * <br>------------------------------<br> 
         * @param id 
         */  
        public void deleteById(String id) {  
            User user = new User(id, null, 0);  
            mongoTemplate.remove(user);  
        }  
          
        /** 
         * 按条件删除 
         * <br>------------------------------<br> 
         * @param criteriaUser 
         */  
        public void delete(User criteriaUser) {  
            Criteria criteria = Criteria.where("age").gt(criteriaUser.getAge());;  
            Query query = new Query(criteria);  
            mongoTemplate.remove(query, User.class);  
        }  
          
        /** 
         * 删除全部 
         * <br>------------------------------<br> 
         */  
        public void deleteAll() {  
            mongoTemplate.dropCollection(User.class);  
        }  
          
        /** 
         * 按主键修改, 
         * 如果文档中没有相关key 会新增 使用$set修改器 
         * <br>------------------------------<br> 
         * @param user 
         */  
        public void updateById(User user) {  
            Criteria criteria = Criteria.where("id").is(user.getId());  
            Query query = new Query(criteria);  
            Update update = Update.update("age", user.getAge()).set("name", user.getName());  
            mongoTemplate.updateFirst(query, update, User.class);  
        }  
          
        /** 
         * 修改多条 
         * <br>------------------------------<br> 
         * @param criteriaUser 
         * @param user 
         */  
        public void update(User criteriaUser, User user) {  
            Criteria criteria = Criteria.where("age").gt(criteriaUser.getAge());;  
            Query query = new Query(criteria);  
            Update update = Update.update("name", user.getName()).set("age", user.getAge());  
            mongoTemplate.updateMulti(query, update, User.class);  
        }  
          
        /** 
         * 根据主键查询 
         * <br>------------------------------<br> 
         * @param id 
         * @return 
         */  
        public User findById(String id) {  
            return mongoTemplate.findById(id, User.class);  
        }  
          
        /** 
         * 查询全部 
         * <br>------------------------------<br> 
         * @return 
         */  
        public List<User> findAll() {  
            return mongoTemplate.findAll(User.class);  
        }  
          
        /** 
         * 按条件查询, 分页 
         * <br>------------------------------<br> 
         * @param criteriaUser 
         * @param skip 
         * @param limit 
         * @return 
         */  
        public List<User> find(User criteriaUser, int skip, int limit) {  
            Query query = getQuery(criteriaUser);  
            query.skip(skip);  
            query.limit(limit);  
            return mongoTemplate.find(query, User.class);  
        }  
          
        /** 
         * 根据条件查询出来后 再去修改 
         * <br>------------------------------<br> 
         * @param criteriaUser  查询条件 
         * @param updateUser    修改的值对象 
         * @return 
         */  
        public User findAndModify(User criteriaUser, User updateUser) {  
            Query query = getQuery(criteriaUser);  
            Update update = Update.update("age", updateUser.getAge()).set("name", updateUser.getName());  
            return mongoTemplate.findAndModify(query, update, User.class);  
        }  
          
        /** 
         * 查询出来后 删除 
         * <br>------------------------------<br> 
         * @param criteriaUser 
         * @return 
         */  
        public User findAndRemove(User criteriaUser) {  
            Query query = getQuery(criteriaUser);  
            return mongoTemplate.findAndRemove(query, User.class);  
        }  
          
        /** 
         * count 
         * <br>------------------------------<br> 
         * @param criteriaUser 
         * @return 
         */  
        public long count(User criteriaUser) {  
            Query query = getQuery(criteriaUser);  
            return mongoTemplate.count(query, User.class);  
        }  
      
        /** 
         * 
         * <br>------------------------------<br> 
         * @param criteriaUser 
         * @return 
         */  
        private Query getQuery(User criteriaUser) {  
            if (criteriaUser == null) {  
                criteriaUser = new User();  
            }  
            Query query = new Query();  
            if (criteriaUser.getId() != null) {  
                Criteria criteria = Criteria.where("id").is(criteriaUser.getId());  
                query.addCriteria(criteria);  
            }  
            if (criteriaUser.getAge() > 0) {  
                Criteria criteria = Criteria.where("age").gt(criteriaUser.getAge());  
                query.addCriteria(criteria);  
            }  
            if (criteriaUser.getName() != null) {  
                Criteria criteria = Criteria.where("name").regex("^" + criteriaUser.getName());  
                query.addCriteria(criteria);  
            }  
            return query;  
        }  
    }  

    package com.x.mongodb.dao;  
      
    import java.util.List;  
      
    import com.x.mongodb.entity.User;  

    public interface IUserDao {  
          
        /** 
         * 新增 
         * <br>------------------------------<br> 
         * @param user 
         */  
        void insert(User user);  
          
        /** 
         * 新增 
         * <br>------------------------------<br> 
         * @param users 
         */  
        void insertAll(List<User> users);  
          
        /** 
         * 删除,主键id, 如果主键的值为null,删除会失败 
         * <br>------------------------------<br> 
         * @param id 
         */  
        void deleteById(String id);  
          
        /** 
         * 按条件删除 
         * <br>------------------------------<br> 
         * @param criteriaUser 
         */  
        void delete(User criteriaUser);  
          
        /** 
         * 删除全部 
         * <br>------------------------------<br> 
         */  
        void deleteAll();  
          
        /** 
         * 修改 
         * <br>------------------------------<br> 
         * @param user 
         */  
        void updateById(User user);  
          
        /** 
         * 更新多条 
         * <br>------------------------------<br> 
         * @param criteriaUser 
         * @param user 
         */  
        void update(User criteriaUser, User user);  
          
        /** 
         * 根据主键查询 
         * <br>------------------------------<br> 
         * @param id 
         * @return 
         */  
        User findById(String id);  
          
        /** 
         * 查询全部 
         * <br>------------------------------<br> 
         * @return 
         */  
        List<User> findAll();  
          
        /** 
         * 按条件查询 
         * <br>------------------------------<br> 
         * @param criteriaUser 
         * @param skip 
         * @param limit 
         * @return 
         */  
        List<User> find(User criteriaUser, int skip, int limit);  
          
        /** 
         * 根据条件查询出来后 在去修改 
         * <br>------------------------------<br> 
         * @param criteriaUser  查询条件 
         * @param updateUser    修改的值对象 
         * @return 
         */  
        User findAndModify(User criteriaUser, User updateUser);  
          
        /** 
         * 查询出来后 删除 
         * <br>------------------------------<br> 
         * @param criteriaUser 
         * @return 
         */  
        User findAndRemove(User criteriaUser);  
          
        /** 
         * count 
         * <br>------------------------------<br> 
         * @param criteriaUser 
         * @return 
         */  
        long count(User criteriaUser);  
    }  


[java] view plain copy print?

    package com.x.mongodb.entity;  
      
    import java.io.Serializable;  
    import java.util.HashMap;  
    import java.util.Map;  
      
    public class User implements Serializable {  
      
        private static final long serialVersionUID = -5785857960597910259L;  
          
        private String id;  
          
        private String name;  
          
        private int age;  
          
        /** 
         * <br>------------------------------<br> 
         */  
        public User() {  
        }  
      
        /** 
         *  
         * <br>------------------------------<br> 
         * @param id 
         * @param name 
         * @param age 
         */  
        public User(String id, String name, int age) {  
            super();  
            this.id = id;  
            this.name = name;  
            this.age = age;  
        }  
      
        /** 
         * 获得id 
         * @return the id 
         */  
        public String getId() {  
            return id;  
        }  
      
        /** 
         * 设置id 
         * @param id the id to set 
         */  
        public void setId(String id) {  
            this.id = id;  
        }  
      
        /** 
         * 获得name 
         * @return the name 
         */  
        public String getName() {  
            return name;  
        }  
      
        /** 
         * 设置name 
         * @param name the name to set 
         */  
        public void setName(String name) {  
            this.name = name;  
        }  
      
        /** 
         * 获得age 
         * @return the age 
         */  
        public int getAge() {  
            return age;  
        }  
      
        /** 
         * 设置age 
         * @param age the age to set 
         */  
        public void setAge(int age) {  
            this.age = age;  
        }  
          
        /** 
         * toString 
         */  
        public String toString() {  
            Map<String, String> map = new HashMap<String, String>();  
            map.put("id", id);  
            map.put("name", name);  
            map.put("age", String.valueOf(age));  
            return map.toString();  
        }  
    }  

        import java.util.ArrayList;  
        import java.util.Collection;  
        import java.util.List;  
          
        import org.junit.Test;  
        import org.springframework.context.ApplicationContext;  
        import org.springframework.context.support.ClassPathXmlApplicationContext;  
          
        import com.x.mongodb.dao.IUserDao;  
        import com.x.mongodb.entity.User;  
 
        public class UserDaoTest {  
              
            /** 
             * 新增  
             * <br>------------------------------<br> 
             */  
            @Test  
            public void testInsert() {  
                getUserDao().insert(new User(null, "testUser", 21));  
            }  
              
            /** 
             * 批量新增  
             * <br>------------------------------<br> 
             */  
            @Test  
            public void testInsertAll() {  
                List<User> list = new ArrayList<User>();  
                for (int i = 0; i < 10; i++) {  
                    list.add(new User(null, "testUser" + i, 21 + i));  
                }  
                getUserDao().insertAll(list);  
            }  
              
            /** 
             * 根据主键删除  
             * <br>------------------------------<br> 
             */  
            @Test  
            public void testDeleteById() {  
                String id = "5058184ec85607e42c4bfad8";  
                getUserDao().deleteById(id);  
            }  
              
            /** 
             * 条件删除  
             * <br>------------------------------<br> 
             */  
            @Test  
            public void testDelete() {  
                //删除年龄大于25的  
                getUserDao().delete(new User(null, null, 25));  
            }  
              
            /** 
             * 删除全部 
             * <br>------------------------------<br> 
             */  
            @Test  
            public void testDeleteAll() {  
                getUserDao().deleteAll();  
            }  
              
            /** 
             * 修改  根据id修改 
             * <br>------------------------------<br> 
             */  
            @Test  
            public void testUpdateById() {  
                getUserDao().updateById(new User("50581c08c856346f02e9842c", "张三", 100));  
            }  
              
            /** 
             * 修改多个 
             * <br>------------------------------<br> 
             */  
            @Test  
            public void update() {  
                //修改年龄大于29岁的 姓名为“王五“  
                User criteriaUser = new User(null, null, 29);  
                User user = new User(null, "王五", 39);  
                getUserDao().update(criteriaUser, user);  
            }  
              
            /** 
             * 按主键查询, 如果不存在 返回null 
             * <br>------------------------------<br> 
             */  
            @Test  
            public void testFindById() {  
                User user = getUserDao().findById("50581c08c856346f02e98425");  
                print(user);  
            }  
              
            /** 
             * 查询全部 
             * <br>------------------------------<br> 
             */  
            @Test  
            public void testFindAll() {  
                List<User> list = getUserDao().findAll();  
                print(list);  
            }  
              
            /** 
             * 按条件查询 
             * <br>------------------------------<br> 
             */  
            @Test  
            public void testFind() {  
                //查询25岁以上的, 分页  
                User criteriaUser = new User(null, null, 20);  
                List<User> list = getUserDao().find(criteriaUser, 1, 10);  
                print(list);  
            }  
              
            /** 
             * 查询出来后  修改 
             * <br>------------------------------<br> 
             */  
            @Test  
            public void testFindAndModify() {  
                User criteriaUser = new User("50581c08c856346f02e9842d", null, 0);  
                User updateUser = new User(null, "张三", 100);  
                updateUser = getUserDao().findAndModify(criteriaUser, updateUser);  
                print(updateUser);  
            }  
              
            /** 
             * 查询出来后 删除 
             * <br>------------------------------<br> 
             */  
            @Test  
            public void testFindAndRemove() {  
                User criteriaUser = new User("50581c08c856346f02e9842d", null, 0);  
                criteriaUser = getUserDao().findAndRemove(criteriaUser);  
                print(criteriaUser);  
            }  
              
            /** 
             * count 
             * <br>------------------------------<br> 
             */  
            @Test  
            public void testCount() {  
                User criteriaUser = new User(null, "test", 0);  
                long count = getUserDao().count(criteriaUser);  
                print(count);  
            }  
              
            public void print(Object object) {  
                if (object == null || !(object instanceof Collection)) {  
                    System.out.println(object);  
                    return;  
                }  
                List<?> list = (List<?>) object;  
                for (Object obj : list) {  
                    System.out.println(obj);  
                }  
            }  
              
            public IUserDao getUserDao() {  
                String configLocations = "applicationContext.xml";  
                ApplicationContext applicationContext = new ClassPathXmlApplicationContext(configLocations);  
                IUserDao userDao = applicationContext.getBean("userDao", IUserDao.class);  
                return userDao;  
            }  
        }