spring - data - mongo 통합

mongo 의 시작
최근 회사 의 일부 업무 확장 으로 인해 우 리 는 전통 적 인 라 이브 러 리 에서 끊임없이 수정 해 야 한다. 앞으로 의 발전 을 고려 하여 mongodb 를 도입 하여 일부 업무 모델 인 MongoDB 는 관계 데이터 베이스 와 비 관계 데이터 베이스 사이 에 있 는 제품 으로 비 관계 라 이브 러 리 에서 기능 이 가장 풍부 하고 관계 데이터 베이스 와 가장 비슷 하 다.그 가 지원 하 는 데이터 구 조 는 매우 느슨 하고 json 과 유사 한 bson 형식 이기 때문에 비교적 복잡 한 데이터 형식 을 저장 할 수 있다.Mongo 의 가장 큰 특징 은 그 가 지원 하 는 조회 언어 가 매우 강하 다 는 것 이다. 그 문법 은 대상 을 대상 으로 하 는 조회 언어 와 비슷 하고 유사 한 관계 데이터 베이스 시트 조회 의 대부분 기능 을 실현 할 수 있 으 며 데이터 에 대한 색인 도 지원 한다.
스프링 과 의 통합
spring - data - mongo 와 spring 의 통합 은 비교적 간단 합 니 다. spring - data - mongo 가 당신 을 위해 많은 일 을 해 주 었 습 니 다.

우선 우리 spring 의 xml 파일 에 주석 지원 을 추가 하고 추가 할 프로필 의 위 치 를 검색 합 니 다

데이터 계층 템 플 릿 설정 (mongoTemplate)

@Configuration
public class MongoConfig {

    private static final ResourceBundle bundle = ResourceBundle.getBundle("mongodb");

    private String uri = bundle.getString("mongo.uri");

    public
    @Bean
    MongoDbFactory mongoDbFactory() throws Exception {
        // mongo      
        MongoClientOptions.Builder mongoClientOptions =
            MongoClientOptions.builder().socketTimeout(3000).connectTimeout(3000)
                .connectionsPerHost(20);
        //      
        MongoClientURI mongoClientURI = new MongoClientURI(uri, mongoClientOptions);
        return new SimpleMongoDbFactory(mongoClientURI);
    }

    public
    @Bean
    MongoTemplate mongoTemplate() throws Exception {
        return new MongoTemplate(mongoDbFactory());
    }
}

여기 서 주의해 야 할 것 은 mongo.uri 입 니 다. 이 물건 은 무엇 입 니까?우리 의 mongo. properties 파일 에 가서 구체 적 인 설정 을 봅 시다.

mongo.uri=mongodb://userName:[email protected]:27017/DBname

맞습니다. 이것 이 핵심 설정 입 니 다. my sql 의 구동 연결 방식 처럼 spring - data - mongo 도 상기 파일 에 있 는 userName, passWord, DBname 를 url 로 연결 할 수 있 습 니 다.

기초 베이스 조작 (기본 클래스 의 집합)

다음은 린 로 베 민 학생 의 이 글 의 기본 클래스 (부분 수정) 를 참조 하여 통합 작업 을 진행 하 였 습 니 다.
나의 base 클래스

/**
 * 

 * mongo    
 * 
 *
 * @author wangguangdong
 * @version 1.0
 * @Date 16/3/8
 */
@Component
public abstract class BaseMongoDAOImpl {

    /**
     * spring mongodb　     
     */
    protected MongoTemplate mongoTemplate;

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

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

    public void update(Query query, Update update) {
        mongoTemplate.findAndModify(query, update, this.getEntityClass());
    }

    public T save(T entity) {
        mongoTemplate.insert(entity);
        return entity;
    }

    public T findById(String id) {
        return mongoTemplate.findById(id, this.getEntityClass());
    }

    //@Override
    public T findById(String id, String collectionName) {
        return mongoTemplate.findById(id, this.getEntityClass(), collectionName);
    }

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

    /**
     *           class
     *
     * @return
     */
    private Class getEntityClass() {
        return ReflectionUtils.getSuperClassGenricType(getClass());
    }

    public void remove(Query query) {
        mongoTemplate.remove(query, this.getEntityClass());
    }

    /**
     *   mongodbTemplate
     *
     * @param mongoTemplate
     */
    protected abstract void setMongoTemplate(MongoTemplate mongoTemplate);

}

ReflectionUtils 반사 도구 류

/**
 * 

 *      
 * 
 *
 * @author wangguangdong
 * @version 1.0
 * @Date 16/3/8
 */
public class ReflectionUtils {

    private static Logger logger = Logger.getLogger(ReflectionUtils.class);

    /**
     *   Getter  .
     */
    public static Object invokeGetterMethod(Object obj, String propertyName) {
        String getterMethodName = "get" + StringUtils.capitalize(propertyName);
        return invokeMethod(obj, getterMethodName, new Class[] {}, new Object[] {});
    }

    /**
     *   Setter  .  value Class   Setter  .
     */
    public static void invokeSetterMethod(Object obj, String propertyName, Object value) {
        invokeSetterMethod(obj, propertyName, value, null);
    }

    /**
     *   Setter  .
     *
     * @param propertyType     Setter  ,     value Class  .
     */
    public static void invokeSetterMethod(Object obj, String propertyName, Object value,
        Class> propertyType) {
        Class> type = propertyType != null ? propertyType : value.getClass();
        String setterMethodName = "set" + StringUtils.capitalize(propertyName);
        invokeMethod(obj, setterMethodName, new Class[] {type}, new Object[] {value});
    }

    /**
     *          ,   private/protected   ,    getter  .
     */
    public static Object getFieldValue(final Object obj, final String fieldName) {
        Field field = getAccessibleField(obj, fieldName);

        if (field == null) {
            throw new IllegalArgumentException(
                "Could not find field [" + fieldName + "] on target [" + obj + "]");
        }

        Object result = null;
        try {
            result = field.get(obj);
        } catch (IllegalAccessException e) {
            logger.error("        " + e.getMessage());
        }
        return result;
    }

    /**
     *          ,   private/protected   ,    setter  .
     */
    public static void setFieldValue(final Object obj, final String fieldName, final Object value) {
        Field field = getAccessibleField(obj, fieldName);

        if (field == null) {
            throw new IllegalArgumentException(
                "Could not find field [" + fieldName + "] on target [" + obj + "]");
        }

        try {
            field.set(obj, value);
        } catch (IllegalAccessException e) {
            logger.error("        " + e.getMessage());
        }
    }

    /**
     *       ,      DeclaredField,            .
     * 

     *       Object     ,   null.
     */
    public static Field getAccessibleField(final Object obj, final String fieldName) {
        Assert.notNull(obj, "object    ");
        Assert.hasText(fieldName, "fieldName");
        for (Class> superClass = obj.getClass();
             superClass != Object.class; superClass = superClass.getSuperclass()) {
            try {
                Field field = superClass.getDeclaredField(fieldName);
                field.setAccessible(true);
                return field;
            } catch (NoSuchFieldException e) {//NOSONAR
                // Field       ,      
            }
        }
        return null;
    }

    /**
     *         ,   private/protected   .
     *           .
     */
    public static Object invokeMethod(final Object obj, final String methodName,
        final Class>[] parameterTypes, final Object[] args) {
        Method method = getAccessibleMethod(obj, methodName, parameterTypes);
        if (method == null) {
            throw new IllegalArgumentException(
                "Could not find method [" + methodName + "] on target [" + obj + "]");
        }

        try {
            return method.invoke(obj, args);
        } catch (Exception e) {
            throw convertReflectionExceptionToUnchecked(e);
        }
    }

    /**
     *       ,      DeclaredMethod,         .
     *       Object     ,   null.
     * 

     *               .          Method,    Method.invoke(Object obj, Object... args)
     */
    public static Method getAccessibleMethod(final Object obj, final String methodName,
        final Class>... parameterTypes) {
        Assert.notNull(obj, "object    ");

        for (Class> superClass = obj.getClass();
             superClass != Object.class; superClass = superClass.getSuperclass()) {
            try {
                Method method = superClass.getDeclaredMethod(methodName, parameterTypes);

                method.setAccessible(true);

                return method;

            } catch (NoSuchMethodException e) {//NOSONAR
                // Method       ,      
            }
        }
        return null;
    }

    /**
     *     ,   Class                .
     *      ,   Object.class.
     * eg.
     * public UserDao extends HibernateDao
     *
     * @param clazz The class to introspect
     * @return the first generic declaration, or Object.class if cannot be determined
     */
    @SuppressWarnings({"unchecked", "rawtypes"})
    public static  Class getSuperClassGenricType(final Class clazz) {
        return getSuperClassGenricType(clazz, 0);
    }

    /**
     *     ,   Class                .
     *      ,   Object.class.
     * 

     *  public UserDao extends HibernateDao
     *
     * @param clazz clazz The class to introspect
     * @param index the Index of the generic ddeclaration,start from 0.
     * @return the index generic declaration, or Object.class if cannot be determined
     */
    @SuppressWarnings("rawtypes")
    public static Class getSuperClassGenricType(final Class clazz, final int index) {

        Type genType = clazz.getGenericSuperclass();

        if (!(genType instanceof ParameterizedType)) {
            logger.warn(clazz.getSimpleName() + "'s superclass not ParameterizedType");
            return Object.class;
        }

        Type[] params = ((ParameterizedType) genType).getActualTypeArguments();

        if (index >= params.length || index < 0) {
            logger.warn(
                "Index: " + index + ", Size of " + clazz.getSimpleName() + "'s Parameterized Type: "
                    + params.length);
            return Object.class;
        }
        if (!(params[index] instanceof Class)) {
            logger.warn(clazz.getSimpleName()
                + " not set the actual class on superclass generic parameter");
            return Object.class;
        }

        return (Class) params[index];
    }

    /**
     *      checked exception   unchecked exception.
     */
    public static RuntimeException convertReflectionExceptionToUnchecked(Exception e) {
        if (e instanceof IllegalAccessException || e instanceof IllegalArgumentException
            || e instanceof NoSuchMethodException) {
            return new IllegalArgumentException("Reflection Exception.", e);
        } else if (e instanceof InvocationTargetException) {
            return new RuntimeException("Reflection Exception.",
                ((InvocationTargetException) e).getTargetException());
        } else if (e instanceof RuntimeException) {
            return (RuntimeException) e;
        }
        return new RuntimeException("Unexpected Checked Exception.", e);
    }
}

어떻게 사용 하 는 지 먼저 우리 의 실체 류 를 bean 으로 합 니 다. 예 를 들 어 우리 의 user 류

    class User implements Serializable{
        private String userName;
        private String passWord;
        public String getUserName() {
            return userName;
        }
        public void setUserName(String userName) {
            this.userName = userName;
        }
        public String getPassWord() {
            return passWord;
        }
        public void setPassWord(String passWord) {
            this.passWord = passWord;
        }
        
    }

우 리 는 사용자 가 mongo 데이터베이스 에서 의 조작 을 실현 하기 위해 UserDao 가 필요 하 다.

@Repository
public class UserDAO extends BaseMongoDAOImpl {

    @Autowired
    @Override
    protected void setMongoTemplate(MongoTemplate mongoTemplate) {
        this.mongoTemplate = mongoTemplate;
    }
}

이때 우 리 는 UserDAO 를 사용 하고 자 하 는 곳 에서 이 속성 을 설명 하고 주입 하면 baseDao 의 기본 방법 을 사용 할 수 있 습 니 다. 다른 방법 을 실현 하려 면 스스로 확장 할 수 있 습 니 다.
예 를 들 어 사용자 이름 이 NB 인 사람 을 조회 할 때 우리 의 것 은 이렇게 할 수 있다.

    
    Query query = new Query();
    query.addCriteria(Criteria.where("userName").is("NB"));
    User user = userDAO.findOne(query);

또 예 를 들 어 제 가 NB 라 는 사람 이 비밀 번 호 를 123 으로 바 꿔 야 돼 요.

    Query query = new Query();
    query.addCriteria(Criteria.where("userName").is("NB"));
    Update update = Update.update("passWord", "123");
    userDAO.update(query, update);

참조 링크
mongodb - java - driver 기본 용법 Spring 통합 - mongodb Spring Data 통합 MongoDB 방문 spring 통합 mongodb 패키지 의 간단 한 CRUD spring - data - mongo 공식 wiki Spring Data MongoDB hello World 예제 Mongodb 와 spring 통합 (1) - spring data mongodb 를 설정 하거나 하위 요 소 를 배열 로 삭제 하 는 데이터 spring 통합 mongodb 패키지 의 간단 한 CRUD