MongoDB项目搭建

最新推荐文章于 2024-05-07 03:58:10 发布

你瞅口舍灬

最新推荐文章于 2024-05-07 03:58:10 发布

阅读量1k

点赞数

分类专栏： java开发

本文链接：https://blog.csdn.net/dcj695632854/article/details/78924310

版权

java开发专栏收录该内容

8 篇文章 0 订阅

订阅专栏

新手小白初次使用博客

刚接触mongodb，为了方便自己以后随时能够学习，在此留下代码，方便以后自己参考，如果能为那些刚接触mongdb的同学提供帮助，那我还是很乐意的。

我这次的项目是使用了Spring Data MongoDB这套框架，话不多说，上代码，不足之处还希望大神轻喷，留下宝贵意见万分感谢！！！

首先是pom文件maven地址

   <properties>  
       <spring.version>4.2.5.RELEASE</spring.version>  
       <aspectj.version>1.8.9</aspectj.version>  
       <cglib.version>3.2.4</cglib.version>  
       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
   </properties>  
 
 
   <dependencies>  
       <dependency>  
           <groupId>junit</groupId>  
           <artifactId>junit</artifactId>  
           <!--<version>3.8.1</version>-->  
           <version>4.12</version>  
           <scope>test</scope>  
       </dependency>  
 
       <dependency>  
           <groupId>org.springframework</groupId>  
           <artifactId>spring-web</artifactId>  
           <version>${spring.version}</version>  
       </dependency>  
 
       <dependency>  
           <groupId>org.springframework</groupId>  
           <artifactId>spring-webmvc</artifactId>  
           <version>${spring.version}</version>  
           <scope>compile</scope>  
           <!--<exclusions>-->  
           <!--<exclusion>-->  
           <!--<groupId>commons-logging</groupId>-->  
           <!--<artifactId>commons-logging</artifactId>-->  
           <!--</exclusion>-->  
           <!--</exclusions>-->  
       </dependency>  
 
       <dependency>  
           <groupId>commons-logging</groupId>  
           <artifactId>commons-logging</artifactId>  
           <version>1.2</version>  
       </dependency>  
 
       <dependency>  
           <groupId>org.springframework</groupId>  
           <artifactId>spring-jdbc</artifactId>  
           <version>${spring.version}</version>  
       </dependency>  
 
       <dependency>  
           <groupId>org.springframework</groupId>  
           <artifactId>spring-test</artifactId>  
           <version>${spring.version}</version>  
           <scope>test</scope>  
       </dependency>  
 
       <dependency>  
           <groupId>org.springframework</groupId>  
           <artifactId>spring-core</artifactId>  
           <version>${spring.version}</version>  
       </dependency>  
 
       <dependency>  
           <groupId>org.springframework</groupId>  
           <artifactId>spring-context</artifactId>  
           <version>${spring.version}</version>  
       </dependency>  
 
       <dependency>  
           <groupId>org.springframework</groupId>  
           <artifactId>spring-context-support</artifactId>  
           <version>${spring.version}</version>  
       </dependency>  
 
       <!-- mongoDB支持jar -->  
       <dependency>  
           <groupId>org.springframework.data</groupId>  
           <artifactId>spring-data-mongodb</artifactId>  
           <version>1.8.4.RELEASE</version>  
       </dependency>  
 
       <dependency>  
           <groupId>javax.servlet</groupId>  
           <artifactId>javax.servlet-api</artifactId>  
           <version>3.1.0</version>  
           <scope>provided</scope>  
       </dependency>  
 
       <dependency>  
           <groupId>javax.servlet.jsp</groupId>  
           <artifactId>jsp-api</artifactId>  
           <version>2.1</version>  
           <scope>provided</scope>  
       </dependency> 
 
       <!--JSP标准标签库（JSTL）-->  
       <dependency>  
           <groupId>javax.servlet</groupId>  
           <artifactId>jstl</artifactId>  
           <version>1.2</version>  
       </dependency>  
 
       <dependency>  
           <groupId>dom4j</groupId>  
           <artifactId>dom4j</artifactId>  
           <version>1.6.1</version>  
       </dependency>  
 
       <dependency>  
           <groupId>log4j</groupId>  
           <artifactId>log4j</artifactId>  
           <version>1.2.17</version>  
       </dependency>  
       
       <!-- json -->
       <dependency>
	   <groupId>org.json</groupId>
	   <artifactId>json</artifactId>
	   <version>20090211</version>
	</dependency>
		
	<!-- String 工具类 -->
	<dependency>
	    <groupId>org.apache.commons</groupId>
	    <artifactId>commons-lang3</artifactId>
	    <version>3.4</version>
	</dependency>
		
	<!-- MD5加密 -->
	<dependency>
	    <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
	    <version>1.10</version>
	</dependency>
		
	<!-- httpclient -->
	<dependency>
	    <groupId>commons-httpclient</groupId>
	    <artifactId>commons-httpclient</artifactId>
	    <version>3.0.1</version>
	</dependency>
				
   </dependencies>

接下来是配置文件：

mongodb-context.xml

<?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/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    
          http://www.springframework.org/schema/beans    
          http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">  
    <!-- 加载mongodb的属性配置文件 -->  
    <context:property-placeholder location="classpath*:mongo_config.properties"/>  
  
    <!-- 定义mongo对象，对应的是mongodb官方jar包中的Mongo，replica-set设置集群副本的ip地址和端口 -->  
    <mongo:mongo id="mongo" replica-set="${mongo.hostport}">  
        <!-- 一些连接属性的设置 -->  
        <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="1"  
                write-timeout="0"  
                write-fsync="true"/>  
    </mongo:mongo>  
  
    <!-- mongo的工厂，通过它来取得mongo实例,dbname为mongodb的数据库名，没有的话会自动创建 -->  
    <mongo:db-factory dbname="local" mongo-ref="mongo"/>  
    <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">  
        <constructor-arg ref="mongo"/>  
        <constructor-arg name="databaseName" value="${mongo.database}"/>  
    </bean>  
  
    <!-- 映射转换器，扫描back-package目录下的文件，根据注释，把它们作为mongodb的一个collection的映射 -->  
    <mongo:mapping-converter base-package="com.games.admin.model"/>  
  
    <!-- mongodb bean的仓库目录，会自动扫描扩展了MongoRepository接口的接口进行注入 -->  
    <mongo:repositories base-package="com.games.admin.dao"/>  
    <!-- 自定义注解 -->
    <bean class="com.games.admin.utils.SaveMongoEventListener"></bean>
</beans>

spring-context.xml：

<?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:aop="http://www.springframework.org/schema/aop"  
       xsi:schemaLocation="http://www.springframework.org/schema/beans  
       http://www.springframework.org/schema/beans/spring-beans.xsd  
       http://www.springframework.org/schema/context  
       http://www.springframework.org/schema/context/spring-context.xsd  
       http://www.springframework.org/schema/aop  
       http://www.springframework.org/schema/aop/spring-aop.xsd">  
  
    <!--开启注解处理器-->  
    <!--<context:annotation-config/>-->  
  
    <!-- 自动检测bean,启用spring mvc 注解@Autowired,@Resource,@Required等  
    <context:annotation-config /> 有了下面扫描配置后该项可以省掉-->  
    <context:component-scan base-package="com.games.admin">  
        <!-- 排除不扫描的,controller放在子容器springmvc的配置文件中 -->  
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>  
    </context:component-scan>  
  
  
    <!--导入mongodb的配置文件-->  
    <import resource="mongodb-context.xml"/>  
  
    <!--仅用来测试springIoc是否成功-->  
    <!-- <bean id="test" class="com.games.admin.controller.TestSpringIocController">  
    </bean> -->  
</beans>

springmvc-servlet.xml：

<?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:p="http://www.springframework.org/schema/p" 
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.games.admin.controller"/>
    <!-- 对模型视图名称的解析，即在模型视图名称添加前后缀 -->     
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"     
        p:prefix="/WEB-INF/jsp/" p:suffix=".jsp" />
    <!-- 拦截器配置  -->
	<bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping">  
     <property name="interceptors">  
         <list>  
                <bean class="com.games.admin.interceptor.LoginInterceptor" />  
         </list>  
     </property>  
    </bean>
    <!-- 总错误处理 
	<bean class="com.fly.server.logic.HandlerException" />
	-->

    
</beans>

mongo_config.properties：

#mongoDB连接配置  
mongo.hostport=127.0.0.1:27017  
mongo.connectionsPerHost=8  
mongo.threadsAllowedToBlockForConnectionMultiplier=4  
#连接超时时间  
mongo.connectTimeout=1000  
#等待时间  
mongo.maxWaitTime=1500  
mongo.autoConnectRetry=true  
mongo.socketKeepAlive=true  
#Socket超时时间  
mongo.socketTimeout=1500  
mongo.slaveOk=true  
#数据库名称  
mongo.database=local

web.xml:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.lc</welcome-file>
  </welcome-file-list>
  <session-config>
        <session-timeout>10</session-timeout>
    </session-config>
  <error-page>
    <error-code>404</error-code>
    <location>/WEB-INF/jsp/main/error.jsp</location>
  </error-page>
  <display-name>mongodb_redis</display-name>
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath*:spring-context.xml</param-value>
  </context-param>
  <listener>
    <listener-class>com.games.admin.init.InitListener</listener-class>
  </listener>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener
		</listener-class>
  </listener>
  <filter>
    <filter-name>characterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter
		</filter-class>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
      <param-name>forceEncoding</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  <servlet>
    <servlet-name>spring-mvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet
		</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath*:springmvc-servlet.xml</param-value>
    </init-param>
    <load-on-startup>2</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>spring-mvc</servlet-name>
    <url-pattern>*.lc</url-pattern>
  </servlet-mapping>
  <servlet-mapping>
    <servlet-name>spring-mvc</servlet-name>
    <url-pattern>/index</url-pattern>
  </servlet-mapping>
  <display-name>mongodb_gmtools</display-name>
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>
</web-app>

以上这些基本上框架就算搭建好了，接下来按照配置文件的内容创建包名，然后分别创建实体类、接口、实现类

实体类（对应mongodb表），这里面主要列出一些用到的注解

@Document(collection = "admin_user") //对应数据库表名

@GeneratedValue//自定义注解，自增规则

@Id//主键，配合上面的注解，可以做到主键自增

自定义注解代码如下：

GeneratedValue：

package com.games.admin.utils;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 注解来标识此字段要自动增长ID
 * @Title:  GeneratedValue.java   
 * @date:   
 * @version V1.0
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.FIELD })
public @interface GeneratedValue {
 
}

SequenceId：

package com.games.admin.model;

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

/**
 * 用于存储每个集合的ID记录，记录每个集合的自增ID到了多少。
 * @Title:  SequenceId.java   
 * @date:  
 * @version V1.0
 */
@Document(collection = "sequence")
public class SequenceId {

	@Id
    private String id;

    @Field("seq_id")
    private long seqId;
 
    @Field("coll_name")
    private String collName;

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public long getSeqId() {
		return seqId;
	}

	public void setSeqId(long seqId) {
		this.seqId = seqId;
	}

	public String getCollName() {
		return collName;
	}

	public void setCollName(String collName) {
		this.collName = collName;
	}
    
    
}

SaveMongoEventListener：

package com.games.admin.utils;

import java.lang.reflect.Field;

import javax.annotation.Resource;

import org.springframework.data.mongodb.core.FindAndModifyOptions;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.mapping.event.AbstractMongoEventListener;
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.util.ReflectionUtils;

import com.games.admin.model.SequenceId;

/**
 * 获取自增id工具类
 * @Title:  SaveMongoEventListener.java   
 * @date:   
 * @version V1.0
 */
public class SaveMongoEventListener extends AbstractMongoEventListener<Object> {
    
	@Resource
    private MongoTemplate mongoTemplate;

	/**
	 * 通过反射获取需要自增的实体类，并实现id自增
	 */
    @Override
    public void onBeforeConvert(final Object source) {
        if(source != null) {
            ReflectionUtils.doWithFields(source.getClass(), new ReflectionUtils.FieldCallback() {
                public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
                    ReflectionUtils.makeAccessible(field);
                    if (field.isAnnotationPresent(GeneratedValue.class)) {
                		//设置自增ID
                		field.set(source, getNextId(source.getClass().getSimpleName()));
                    }
                 }
            });
        }
   }
   
	/**
	 * 获取下一个自增ID
	 * @author yinjihuan
	 * @param collName  集合名
	 * @return
	 */
	private Long getNextId(String collName) {
	
		Query query = new Query(Criteria.where("collName").is(collName));
		Update update = new Update();
		update.inc("seqId", 1);
		FindAndModifyOptions options = new FindAndModifyOptions();
		options.upsert(true);
		options.returnNew(true);
		SequenceId seqId = mongoTemplate.findAndModify(query, update, options, SequenceId.class);
		return seqId.getSeqId();
	}
}

接口和实现类这里列举一些常用的方法，满足增删改查，实现类添加注解@service：

	@Resource
	private MongoTemplate mongoTemplate;

	/**
	 * 查询全部
	 */
	@Override
	public List<AdminGroup> select() {
		
		List<AdminGroup> adminGroups = new ArrayList<AdminGroup>();
	try{
    		Query query = new Query(); 
    		class= mongoTemplate.find(query, Class.class);//Class 实体类名
    	}catch(Exception e){
    		e.printStackTrace();
    	}
        return adminGroups;
	}

	/**
	 * id查询
	 */
	@Override
	public AdminGroup getGroupByGroupId(long groupId) {
		
		AdminGroup adminGroup = new AdminGroup();
    	try{
    	    Query query = new Query();  
            Criteria criteria = Criteria.where("_id").is(groupId);  
            query.addCriteria(criteria);  
            class= mongoTemplate.findOne(query, Class.class);
    	}catch(Exception e){
    		e.printStackTrace();
    	}
        return adminGroup;
	}

	/**
	 * 更新
	 */
	@Override
	public int update(Class group) {
		int result = 0;
		
		Update update = new Update();
		update.set("groupName", group.getGroupName());
		update.set("permission", group.getPermission());
		
		Query query = new Query();
		
		try{
			mongoTemplate.updateFirst(query.addCriteria(Criteria.where("_id").is(group.getGroupId())), update, Class.class);  
            		result = 1;
		}catch(Exception e){
			e.printStackTrace();
		}
		return result;
	}

	/**
	 * 添加
	 */
	@Override
	public int insert(Class group) {
		int result = 0;
    	try{
    		mongoTemplate.save(group);  
    		result = 1;
    	}catch(Exception e){
    		e.printStackTrace();
    	}
    	return result;
	}

	/**
	 * 查询操作日志---分页
	 * @Title: adminLogList   
	 * @param request
	 * @param response
	 * @return ModelAndView
	 */
	@RequestMapping("adminLogList.lc")
	public ModelAndView adminLogPageList(HttpServletRequest request ,HttpServletResponse response){
		ModelAndView m = new ModelAndView("adminLog/adminLogList");
		//查询条件
		String queryDate = request.getParameter("queryDate");
		//当前页
		int pageNum = UtilTools.getParameterInt(request, "pageNum", 0);
		//查询条件
		Query query = new Query();  
		try{
			//模糊查询
//			criteria.and("title").regex(".*?"+"fileName"+".*");
			//日期查询
			if(null != queryDate && !queryDate.equals("")){
				query.addCriteria(Criteria.where("actionTime").gte(TimeUtils.parseStringToTime(queryDate + " 00:00:00")));
			}
			//排序--倒叙
			List<Order> orders = new ArrayList<Order>();
			orders.add(new Order(Direction.DESC, "_id"));
			Sort sort = new Sort(orders);  
			if (null != sort){
				query.with(sort);
			}
			
			SpringDataPageable pageable = new SpringDataPageable();
			//开始页  
			pageable.setPagenumber(pageNum);
			//每页条数  
			pageable.setPagesize(num);
			//排序  
			pageable.setSort(sort);
			
			//查询出一共的条数  
			Long count =  template.count(query, AdminLog.class);  
			//查询  
			List<AdminLog> adminLogs = template.find(query.with(pageable), AdminLog.class);


			// 返回页面
			m.addObject("adminLogs", adminLogs);
			m.addObject("pageInfo",PageOut.outPageing(pageNum,count));
			
		}catch(Exception e){
			e.printStackTrace();
		}
		m.addObject("queryDate", queryDate);
		return m;
	}



SpringDataPageable:

package com.games.admin.utils;
import java.io.Serializable;

import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;

/**
 * 分页类
 * @Title:  SpringDataPageable.java   
 * @version V1.0
 */
public class SpringDataPageable implements Serializable , Pageable{
    
	/**
	 * 序列号
	 */
	private static final long serialVersionUID = -6004494058461939700L;
	// 当前页
    private Integer pagenumber;
    // 当前页面条数
    private Integer pagesize;
    //排序条件
    private Sort sort;
	
	public Integer getPagenumber() {
		return pagenumber;
	}

	public void setPagenumber(Integer pagenumber) {
		this.pagenumber = pagenumber;
	}

	public Integer getPagesize() {
		return pagesize;
	}

	public void setPagesize(Integer pagesize) {
		this.pagesize = pagesize;
	}

	public Sort getSort() {
		return sort;
	}

	public void setSort(Sort sort) {
		this.sort = sort;
	}
	
	//当前页面
	@Override
	public int getPageNumber() {
		 return getPagenumber();
	}

	// 每一页显示的条数  
	@Override
	public int getPageSize() {
		return getPagesize();  
	}

	// 第二页所需要增加的数量  
	@Override
	public int getOffset() {
		return getPagenumber() * getPagesize();  
	}

	@Override
	public Pageable next() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Pageable previousOrFirst() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Pageable first() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public boolean hasPrevious() {
		// TODO Auto-generated method stub
		return false;
	}
    
}


这个分页方法应该只能针对小数据量查询，看源码里面有用到skip，对于大数据查询性能降低。

好了，以上的代码基本上构成了项目的基本框架，如果有问题，欢迎留言。

你瞅口舍灬

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
MongoDB项目搭建

新手小白初次使用博客刚接触mongodb，为了方便自己以后随时能够学习，在此留下代码，方便以后自己参考，如果能为那些刚接触mongdb的同学提供帮助，那我还是很乐意的。我这次的项目是使用了Spring Data MongoDB这套框架，话不多说，上代码，不足之处还希望大神轻喷，留下宝贵意见万分感谢！！！
复制链接

扫一扫