架构之路之spring+springmvc+maven+mongodb的搭建（转载：http://blog.csdn.net/tomcat_2014/article/details/55100130）

1.前言

      最近项目开发使用到了spring+springmvc+maven+MongoDB，项目中的框架是用springboot进项开发的，对于我们中级开发人员来说，有利有弊，好处呢是springboot开发减少了很多配置文件，同时也使开发更加规范快捷，但是，不好的地方就是长此以往，我们就在码农的道路上越走越远。。。

     所以，为了抵制码农的身份，在工作之余自己亲手由零一点一点搭建了这个框架，当然框架暂时只包含基本的东西，但是千里之行始于足下，良好的开始就是成功的一半，我会在以后的道路上不断进行扩展的，如果有问题，也请大家不吝赐教，我们共同进步！

2.准备环境

    工欲善其事必先利其器，我们先做好前期准备工作，开发工具IntelliJ IDEA14，jdk版本是1.8，对于Java环境变量配置，mongodb的安装，maven的这边不做过多说明，网上也有很多详细的说明，大家可以去查询，那么下面我们就开始项目的搭建。

3.项目搭建

3.1创建maven项目

详细步骤 点击这里

3.2 配置文件

3.2.1 maven依赖

[java] view plain copy

  1. <span style="font-size:14px;"><dependencies>  
  2.         <dependency>  
  3.             <groupId>junit</groupId>  
  4.             <artifactId>junit</artifactId>  
  5.             <version>3.8.1</version>  
  6.             <scope>test</scope>  
  7.         </dependency>  
  8.   
  9.         <dependency>  
  10.             <groupId>org.springframework</groupId>  
  11.             <artifactId>spring-web</artifactId>  
  12.             <version>4.0.5.RELEASE</version>  
  13.         </dependency>  
  14.   
  15.         <dependency>  
  16.             <groupId>org.springframework</groupId>  
  17.             <artifactId>spring-webmvc</artifactId>  
  18.             <version>3.2.11.RELEASE</version>  
  19.             <scope>compile</scope>  
  20.             <!--<exclusions>-->  
  21.             <!--<exclusion>-->  
  22.             <!--<groupId>commons-logging</groupId>-->  
  23.             <!--<artifactId>commons-logging</artifactId>-->  
  24.             <!--</exclusion>-->  
  25.             <!--</exclusions>-->  
  26.         </dependency>  
  27.   
  28.         <dependency>  
  29.             <groupId>commons-logging</groupId>  
  30.             <artifactId>commons-logging</artifactId>  
  31.             <version>1.2</version>  
  32.         </dependency>  
  33.   
  34.         <dependency>  
  35.             <groupId>org.springframework</groupId>  
  36.             <artifactId>spring-jdbc</artifactId>  
  37.             <version>4.0.5.RELEASE</version>  
  38.         </dependency>  
  39.   
  40.         <dependency>  
  41.             <groupId>org.springframework</groupId>  
  42.             <artifactId>spring-test</artifactId>  
  43.             <version>3.2.11.RELEASE</version>  
  44.             <scope>test</scope>  
  45.         </dependency>  
  46.   
  47.         <dependency>  
  48.             <groupId>org.springframework</groupId>  
  49.             <artifactId>spring-core</artifactId>  
  50.             <version>4.0.5.RELEASE</version>  
  51.         </dependency>  
  52.   
  53.         <dependency>  
  54.             <groupId>org.springframework</groupId>  
  55.             <artifactId>spring-context</artifactId>  
  56.             <version>4.0.5.RELEASE</version>  
  57.         </dependency>  
  58.   
  59.         <dependency>  
  60.             <groupId>org.springframework</groupId>  
  61.             <artifactId>spring-context-support</artifactId>  
  62.             <version>3.2.3.RELEASE</version>  
  63.         </dependency>  
  64.   
  65.         <dependency>  
  66.             <groupId>org.mybatis</groupId>  
  67.             <artifactId>mybatis</artifactId>  
  68.             <version>3.2.7</version>  
  69.         </dependency>  
  70.   
  71.         <dependency>  
  72.             <groupId>org.mybatis</groupId>  
  73.             <artifactId>mybatis-spring</artifactId>  
  74.             <version>1.2.2</version>  
  75.         </dependency>  
  76.   
  77.         <dependency>  
  78.             <groupId>mysql</groupId>  
  79.             <artifactId>mysql-connector-java</artifactId>  
  80.             <version>5.1.30</version>  
  81.         </dependency>  
  82.   
  83.         <!-- mongoDB支持jar -->  
  84.         <dependency>  
  85.             <groupId>org.springframework.data</groupId>  
  86.             <artifactId>spring-data-mongodb</artifactId>  
  87.             <version>1.2.0.RELEASE</version>  
  88.         </dependency>  
  89.   
  90.         <dependency>  
  91.             <groupId>javax.servlet</groupId>  
  92.             <artifactId>javax.servlet-api</artifactId>  
  93.             <version>3.1.0</version>  
  94.             <scope>provided</scope>  
  95.         </dependency>  
  96.   
  97.         <dependency>  
  98.             <groupId>javax.servlet.jsp</groupId>  
  99.             <artifactId>jsp-api</artifactId>  
  100.             <version>2.1</version>  
  101.             <scope>provided</scope>  
  102.         </dependency>  
  103.   
  104.         <!--JSP标准标签库（JSTL）-->  
  105.         <dependency>  
  106.             <groupId>javax.servlet</groupId>  
  107.             <artifactId>jstl</artifactId>  
  108.             <version>1.2</version>  
  109.         </dependency>  
  110.   
  111.         <dependency>  
  112.             <groupId>dom4j</groupId>  
  113.             <artifactId>dom4j</artifactId>  
  114.             <version>1.6.1</version>  
  115.         </dependency>  
  116.   
  117.         <!--区别slf4j与log4j-->  
  118.         <dependency>  
  119.             <groupId>org.slf4j</groupId>  
  120.             <artifactId>jcl-over-slf4j</artifactId>  
  121.             <version>1.7.7</version>  
  122.         </dependency>  
  123.         <dependency>  
  124.             <groupId>org.slf4j</groupId>  
  125.             <artifactId>slf4j-api</artifactId>  
  126.             <version>1.7.7</version>  
  127.         </dependency>  
  128.         <dependency>  
  129.             <groupId>org.slf4j</groupId>  
  130.             <artifactId>slf4j-nop</artifactId>  
  131.             <version>1.7.5</version>  
  132.         </dependency>  
  133.         <dependency>  
  134.             <groupId>log4j</groupId>  
  135.             <artifactId>log4j</artifactId>  
  136.             <version>1.2.17</version>  
  137.         </dependency>  
  138.   
  139.     </dependencies>  
  140. </span>  

3.2.2 spring-context.xml

[java] view plain copy

  1. <span style="font-size:14px;"><?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans  
  5.        http://www.springframework.org/schema/beans/spring-beans.xsd">  
  6.   
  7.     <!--开启注解处理器-->  
  8.     <!--<context:annotation-config/>-->  
  9.   
  10.     <!-- 自动检测bean,启用spring mvc 注解@Autowired,@Resource,@Required等 <context:annotation-config /> 有了下面扫描配置后该项可以省掉-->  
  11.     <!--<context:component-scan base-package="com.tl.skyLine">-->  
  12.     <!--<!– 排除不扫描的 –>-->  
  13.     <!--<!–<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>–>-->  
  14.     <!--</context:component-scan>-->  
  15.   
  16.   
  17.     <!--导入mongodb的配置文件-->  
  18.     <import resource="mongodb-context.xml"/>  
  19.   
  20.     <!--仅用来测试springIoc是否成功-->  
  21.     <bean id="test" class="com.tl.skyLine.TestSpringIocController">  
  22.     </bean>  
  23.   
  24. </beans></span>  

3.2.3 springmvc-servlet.xml

[java] view plain copy

  1. <span style="font-size:14px;"><?xml version="1.0" encoding="UTF-8"?>  
  2. <beans  
  3.         xmlns="http://www.springframework.org/schema/beans"  
  4.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.         xmlns:tx="http://www.springframework.org/schema/tx"  
  6.         xmlns:context="http://www.springframework.org/schema/context"  
  7.         xmlns:mvc="http://www.springframework.org/schema/mvc"  
  8.         xsi:schemaLocation="http://www.springframework.org/schema/beans  
  9.     http://www.springframework.org/schema/beans/spring-beans-3.2.xsd  
  10.     http://www.springframework.org/schema/tx  
  11.     http://www.springframework.org/schema/tx/spring-tx-3.2.xsd  
  12.     http://www.springframework.org/schema/context  
  13.     http://www.springframework.org/schema/context/spring-context-3.2.xsd  
  14.     http://www.springframework.org/schema/mvc  
  15.     http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd">  
  16.   
  17.   
  18.     <!-- 启用spring mvc 注解 -->  
  19.     <!--<context:annotation-config />-->  
  20.   
  21.     <!--自定扫描package中的注解-->  
  22.     <!--有了这一句,上面的<context:annotation-config />可以省略-->  
  23.     <context:component-scan base-package="com.tl.skyLine"/>  
  24.   
  25.     <!-- 默认的注解映射的支持，自动注册DefaultAnnotationHandlerMapping和AnnotationMethodHandlerAdapter -->  
  26.     <!--<mvc:annotation-driven />-->  
  27.   
  28.     <!-- 将在Controller返回的ModelAndView,加上目录前缀/WEB-INF/views/, 文件名称后缀.jsp -->  
  29.     <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
  30.         <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>  
  31.         <!--<beans:property name="prefix" value="/WEB-INF/views/"/>-->  
  32.         <property name="prefix" value="/pages/"/>  
  33.         <property name="suffix" value=".jsp"/>  
  34.     </bean>  
  35.   
  36.     <!-- 对静态资源文件的访问-->  
  37.     <!--<mvc:resources mapping="/images/**" location="/WEB-INF/images/" cache-period="31556926"/>-->  
  38.     <!--<mvc:resources mapping="/js/**" location="/WEB-INF/js/" cache-period="31556926"/>-->  
  39.     <!--<mvc:resources mapping="/css/**" location="/WEB-INF/css/" cache-period="31556926"/>-->  
  40. </beans></span>  

3.2.4 mongodb-context.xml

[java] view plain copy

  1. <span style="font-size:14px;"><?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.        xmlns:context="http://www.springframework.org/schema/context"  
  5.        xmlns:mongo="http://www.springframework.org/schema/data/mongo"  
  6.        xsi:schemaLocation="http://www.springframework.org/schema/context    
  7.           http://www.springframework.org/schema/context/spring-context-3.0.xsd    
  8.           http://www.springframework.org/schema/data/mongo    
  9.           http://www.springframework.org/schema/data/mongo/spring-mongo-1.0.xsd    
  10.           http://www.springframework.org/schema/beans    
  11.           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">  
  12.     <!-- 加载mongodb的属性配置文件 -->  
  13.     <context:property-placeholder location="classpath:config.properties"/>  
  14.   
  15.     <!-- 定义mongo对象，对应的是mongodb官方jar包中的Mongo，replica-set设置集群副本的ip地址和端口 -->  
  16.     <mongo:mongo id="mongo" replica-set="${mongo.hostport}">  
  17.         <!-- 一些连接属性的设置 -->  
  18.         <mongo:options  
  19.                 connections-per-host="${mongo.connectionsPerHost}"  
  20.                 threads-allowed-to-block-for-connection-multiplier="${mongo.threadsAllowedToBlockForConnectionMultiplier}"  
  21.                 connect-timeout="${mongo.connectTimeout}"  
  22.                 max-wait-time="${mongo.maxWaitTime}"  
  23.                 auto-connect-retry="${mongo.autoConnectRetry}"  
  24.                 socket-keep-alive="${mongo.socketKeepAlive}"  
  25.                 socket-timeout="${mongo.socketTimeout}"  
  26.                 slave-ok="${mongo.slaveOk}"  
  27.                 write-number="1"  
  28.                 write-timeout="0"  
  29.                 write-fsync="true"/>  
  30.     </mongo:mongo>  
  31.   
  32.     <!-- mongo的工厂，通过它来取得mongo实例,dbname为mongodb的数据库名，没有的话会自动创建 -->  
  33.     <mongo:db-factory dbname="skyLine" mongo-ref="mongo"/>  
  34.     <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">  
  35.         <constructor-arg ref="mongo"/>  
  36.         <constructor-arg name="databaseName" value="${mongo.database}"/>  
  37.     </bean>  
  38.   
  39.     <!-- 映射转换器，扫描back-package目录下的文件，根据注释，把它们作为mongodb的一个collection的映射 -->  
  40.     <mongo:mapping-converter base-package="com.tl.skyLine.model"/>  
  41.   
  42.     <!-- mongodb bean的仓库目录，会自动扫描扩展了MongoRepository接口的接口进行注入 -->  
  43.     <mongo:repositories base-package="com.tl.skyLine.repository"/>  
  44. </beans></span>  

3.2.5 config.properties

[java] view plain copy

  1. <span style="font-size:14px;">#mongoDB连接配置  
  2. mongo.hostport=127.0.0.1:27017  
  3. mongo.connectionsPerHost=8  
  4. mongo.threadsAllowedToBlockForConnectionMultiplier=4  
  5. #连接超时时间  
  6. mongo.connectTimeout=1000  
  7. #等待时间  
  8. mongo.maxWaitTime=1500  
  9. mongo.autoConnectRetry=true  
  10. mongo.socketKeepAlive=true  
  11. #Socket超时时间  
  12. mongo.socketTimeout=1500  
  13. mongo.slaveOk=true  
  14. #数据库名称  
  15. mongo.database=skyLine</span>  

3.2.6 web.xml

[java] view plain copy

  1. <span style="font-size:14px;"><?xml version="1.0" encoding="UTF-8"?>  
  2. <web-app version="2.5"  
  3.          xmlns="http://java.sun.com/xml/ns/javaee"  
  4.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.          xsi:schemaLocation="http://java.sun.com/xml/ns/javaee  
  6.          http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">  
  7.   
  8.     <!--指定欢迎页面-->  
  9.     <welcome-file-list>  
  10.         <welcome-file>index.jsp</welcome-file>  
  11.     </welcome-file-list>  
  12.   
  13.     <!--真正的加载顺序为：context-param -> listener -> filter -> servlet-->  
  14.   
  15.     <!--<listener>-->  
  16.     <!--<listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>-->  
  17.     <!--</listener>-->  
  18.   
  19.   
  20.     <!--1、在web.xml配置监听器ContextLoaderListener-->  
  21.     <!--ContextLoaderListener的作用（一句话）：初始化BeanFactory，并将BeanFactory设置到application中。-->  
  22.     <listener>  
  23.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
  24.     </listener>  
  25.   
  26.     <!--Spring log4j Config loader-->  
  27.     <listener>  
  28.         <listener-class>  
  29.             org.springframework.web.util.Log4jConfigListener  
  30.         </listener-class>  
  31.     </listener>  
  32.   
  33.     <!--2、部署applicationContext的xml文件,默认的路径是"/WEB-INF/applicationContext.xml，  
  34.     如果是要自定义文件名可以在web.xml里加入contextConfigLocation这个context参数：  
  35.     在<param-value> </param-value>里指定相应的xml文件名，如果有多个xml文件，可以写在一起并以“,”号分隔。  
  36.     也可以这样applicationContext-*.xml采用通配符，-->  
  37.     <context-param>  
  38.         <param-name>contextConfigLocation</param-name>  
  39.         <param-value>classpath:spring-context.xml</param-value>  
  40.     </context-param>  
  41.   
  42.     <context-param>  
  43.         <param-name>log4jConfigLocation</param-name>  
  44.         <param-value>classpath:log4j.properties</param-value>  
  45.     </context-param>  
  46.   
  47.     <!-- 防止Spring内存溢出监听器 -->  
  48.     <!--<listener>-->  
  49.     <!--<listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>-->  
  50.     <!--</listener>-->  
  51.   
  52.     <!--使用Spring MVC,配置DispatcherServlet是第一步。DispatcherServlet是一个Servlet,  
  53.     所以可以配置多个DispatcherServlet-->  
  54.     <servlet>  
  55.         <servlet-name>springMVC</servlet-name>  
  56.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
  57.         <init-param>  
  58.             <param-name>contextConfigLocation</param-name>  
  59.             <param-value>classpath:springmvc-servlet.xml</param-value>  
  60.         </init-param>  
  61.         <!--是启动顺序，让这个Servlet随Servletp容器一起启动。-->  
  62.         <load-on-startup>1</load-on-startup>  
  63.     </servlet>  
  64.     <servlet-mapping>  
  65.         <servlet-name>springMVC</servlet-name>  
  66.         <url-pattern>/</url-pattern>  
  67.     </servlet-mapping>  
  68.   
  69.     <!-- 在Spring框架中是如何解决从页面传来的字符串的编码问题的呢？  
  70.     下面我们来看看Spring框架给我们提供过滤器CharacterEncodingFilter  
  71.      这个过滤器就是针对于每次浏览器请求进行过滤的，然后再其之上添加了父类没有的功能即处理字符编码。  
  72.       其中encoding用来设置编码格式，forceEncoding用来设置是否理会 request.getCharacterEncoding()方法，设置为true则强制覆盖之前的编码格式。-->  
  73.     <filter>  
  74.         <filter-name>encodingFilter</filter-name>  
  75.         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  
  76.         <init-param>  
  77.             <param-name>encoding</param-name>  
  78.             <param-value>UTF-8</param-value>  
  79.         </init-param>  
  80.         <init-param>  
  81.             <param-name>forceEncoding</param-name>  
  82.             <param-value>true</param-value>  
  83.         </init-param>  
  84.     </filter>  
  85.     <filter-mapping>  
  86.         <filter-name>encodingFilter</filter-name>  
  87.         <url-pattern>/*</url-pattern>  
  88.     </filter-mapping>  
  89.   
  90.   
  91.     <servlet-mapping>  
  92.         <servlet-name>default</servlet-name>  
  93.         <url-pattern>*.html</url-pattern>  
  94.     </servlet-mapping>  
  95.   
  96.     <error-page> <!--当系统出现404错误，跳转到页面nopage.html-->  
  97.         <error-code>404</error-code>  
  98.         <location>/noPage.jsp</location>  
  99.     </error-page>  
  100.   
  101.     <session-config><!--会话超时配置，单位分钟-->  
  102.         <session-timeout>360</session-timeout>  
  103.     </session-config>  
  104.   
  105. </web-app>  
  106. </span>  

3.3 User类

[java] view plain copy

  1. <span style="font-size:14px;">package com.tl.skyLine.model;  
  2.   
  3. import org.springframework.data.annotation.Id;  
  4. import org.springframework.data.mongodb.core.mapping.Document;  
  5.   
  6. /** 
  7.  * 系统操作人员 
  8.  */  
  9. @Document(collection = "sky.user")  
  10. public class User {  
  11.   
  12.     @Id  
  13.     private String id;  
  14.   
  15.     private String username;  
  16.   
  17.     private String password;  
  18.   
  19.     public String getId() {  
  20.         return id;  
  21.     }  
  22.   
  23.     public void setId(String id) {  
  24.         this.id = id;  
  25.     }  
  26.   
  27.     public String getUsername() {  
  28.         return username;  
  29.     }  
  30.   
  31.     public void setUsername(String username) {  
  32.         this.username = username;  
  33.     }  
  34.   
  35.     public String getPassword() {  
  36.         return password;  
  37.     }  
  38.   
  39.     public void setPassword(String password) {  
  40.         this.password = password;  
  41.     }  
  42. }  
  43.   
  44. </span>  

3.4 数据层操作dao

userDao

[java] view plain copy

  1. <span style="font-size:14px;">package com.tl.skyLine.repository;  
  2.   
  3. import com.tl.skyLine.model.User;  
  4.   
  5. import java.util.List;  
  6.   
  7. /** 
  8.  * UserDao 
  9.  * Created by tl on 17/2/13. 
  10.  */  
  11. public interface UserDao {  
  12.   
  13.     /** 
  14.      * 查询所有数据 
  15.      * 
  16.      * @return 
  17.      */  
  18.     List<User> findAll();  
  19.   
  20.     /** 
  21.      * 用于分页查询 
  22.      * 
  23.      * @param skip(第一个坐标为0) 
  24.      * @param limit 
  25.      * @return 
  26.      */  
  27.     List<User> findList(int skip, int limit);  
  28.   
  29.     /** 
  30.      * 保存用户 
  31.      * 
  32.      * @param user 
  33.      */  
  34.     void store(User user);  
  35.   
  36.     /** 
  37.      * 根据id查询 
  38.      * 
  39.      * @param id 
  40.      * @return 
  41.      */  
  42.     User findOne(String id);  
  43.   
  44.     /** 
  45.      * 根据用户名查询 
  46.      * 
  47.      * @param username 
  48.      * @return 
  49.      */  
  50.     User findOneByUsername(String username);  
  51.   
  52.     /** 
  53.      * 更新 
  54.      * 
  55.      * @param user 
  56.      */  
  57.     void updateFirst(User user);  
  58.   
  59.     /** 
  60.      * 删除 
  61.      * 
  62.      * @param ids 
  63.      */  
  64.     void delete(String... ids);  
  65. }  
  66. </span>  

userDaoImpl

[java] view plain copy

  1. <span style="font-size:14px;">package com.tl.skyLine.repository;  
  2.   
  3. import com.tl.skyLine.model.User;  
  4. import org.springframework.beans.factory.annotation.Autowired;  
  5. import org.springframework.data.domain.Sort;  
  6. import org.springframework.data.domain.Sort.Direction;  
  7. import org.springframework.data.domain.Sort.Order;  
  8. import org.springframework.data.mongodb.core.MongoTemplate;  
  9. import org.springframework.data.mongodb.core.query.Criteria;  
  10. import org.springframework.data.mongodb.core.query.Query;  
  11. import org.springframework.data.mongodb.core.query.Update;  
  12. import org.springframework.stereotype.Service;  
  13.   
  14. import java.util.List;  
  15.   
  16. /** 
  17.  * UserDaoImpl 
  18.  * Created by tl on 17/2/13. 
  19.  */  
  20. @Service  
  21. public class UserDaoImpl implements UserDao {  
  22.   
  23.     //MongoTemplate是数据库和代码之间的接口，对数据库的操作都在它里面  
  24.     @Autowired  
  25.     private MongoTemplate mongoTemplate;  
  26.   
  27.     @Override  
  28.     public List<User> findAll() {  
  29.         return this.mongoTemplate.find(new Query(), User.class);  
  30.     }  
  31.   
  32.     @Override  
  33.     public List<User> findList(int skip, int limit) {  
  34.         Query query = new Query();  
  35.         query.with(new Sort(new Order(Direction.ASC, "_id")));  
  36.         query.skip(skip).limit(limit);  
  37.         return this.mongoTemplate.find(query, User.class);  
  38.     }  
  39.   
  40.     @Override  
  41.     public void store(User user) {  
  42.         mongoTemplate.save(user);  
  43.     }  
  44.   
  45.     /** 
  46.      * Criteria.where("username").is(username) 
  47.      * 前一个是数据库的字段,后一个是java类的字段 
  48.      * 
  49.      * @param username 
  50.      * @return 
  51.      */  
  52.     @Override  
  53.     public User findOneByUsername(String username) {  
  54.         Query query = new Query();  
  55.         Criteria criteria = Criteria.where("username").is(username);  
  56.         query.addCriteria(criteria);  
  57.         return this.mongoTemplate.findOne(query, User.class);  
  58.     }  
  59.   
  60.     @Override  
  61.     public User findOne(String id) {  
  62.         Query query = new Query();  
  63.         Criteria criteria = Criteria.where("_id").is(id);  
  64.         query.addCriteria(criteria);  
  65.         return this.mongoTemplate.findOne(query, User.class);  
  66.     }  
  67.   
  68.     @Override  
  69.     public void updateFirst(User user) {  
  70.         Update update = new Update();  
  71.         Query query = new Query();  
  72.         update.set("username", user.getUsername());  
  73.         update.set("password", user.getPassword());  
  74.         this.mongoTemplate.updateFirst(query.addCriteria(Criteria.where("_id").is(user.getId())), update, User.class);  
  75.     }  
  76.   
  77.     @Override  
  78.     public void delete(String... ids) {  
  79.         if (ids == null || ids.length == 0) {  
  80.             return;  
  81.         }  
  82.         for (String id : ids) {  
  83.             Query query = new Query(Criteria.where("_id").is(id));  
  84.             this.mongoTemplate.remove(query, User.class);  
  85.         }  
  86.     }  
  87.   
  88. }  
  89. </span>  

3.5单元测试

[java] view plain copy

  1. <span style="font-size:14px;">package com.tl.skyLine.controller;  
  2.   
  3. import com.tl.skyLine.TestSpringIocController;  
  4. import com.tl.skyLine.model.User;  
  5. import com.tl.skyLine.repository.UserDao;  
  6. import org.apache.log4j.Logger;  
  7. import org.junit.Test;  
  8. import org.junit.runner.RunWith;  
  9. import org.springframework.context.ApplicationContext;  
  10. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  11. import org.springframework.test.context.ContextConfiguration;  
  12. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  
  13.   
  14. import javax.annotation.Resource;  
  15. import java.util.List;  
  16.   
  17. /** 
  18.  * 测试springIoc是否成功 
  19.  * Created by tl on 17/2/11. 
  20.  * <p/> 
  21.  * 注解@ContextConfiguration表示将ApplicationContext对象注入进来，就不用像以往那样在测试程序里先new了，直接使用 
  22.  */  
  23. @RunWith(SpringJUnit4ClassRunner.class)  
  24. //@ContextConfiguration(locations = "classpath:spring-context.xml")  
  25. @ContextConfiguration(locations = {"classpath:spring-context.xml", "classpath:springmvc-servlet.xml"})  
  26. public class UserDaoTestController {  
  27.   
  28.     // 在任何需要记录日志的类中  
  29.     private static Logger logger = Logger.getLogger(UserDaoTestController.class);  
  30.   
  31.     @Resource  
  32.     private UserDao userDao;  
  33.   
  34.     /** 
  35.      * 测试Spring IOC的开发环境 
  36.      */  
  37.     @Test  
  38.     public void springIoc() {  
  39.         ApplicationContext context = new ClassPathXmlApplicationContext("classpath:spring-context.xml");  
  40.         TestSpringIocController test = (TestSpringIocController) context.getBean("test");  
  41.         test.print();  
  42.     }  
  43.   
  44.     @Test //测试Spring IOC的开发环境  
  45.     public void save() {  
  46.         User user = new User();  
  47.         user.setUsername("skyLine2");  
  48.         user.setPassword("7777777");  
  49.         userDao.store(user);  
  50.   
  51.         User user2 = userDao.findOneByUsername("skyLine2");  
  52.         logger.info("-------获取账户密码:-------" + user2.getPassword());  
  53.     }  
  54.   
  55.     @Test  
  56.     public void update() {  
  57.         User user = userDao.findOneByUsername("skyLine2");  
  58.         logger.info("-------更新之前账户密码:-------" + user.getPassword());  
  59.   
  60.         user.setPassword("9999888");  
  61.         userDao.updateFirst(user);  
  62.   
  63.         logger.info("-------更新之后账户密码:-------" + user.getPassword());  
  64.     }  
  65.   
  66.     @Test //测试Spring IOC的开发环境  
  67.     public void findAll() {  
  68. //        List<User> lists = userDao.findAll();  
  69. //        for (User user : lists) {  
  70. //            logger.info("-------user遍历:-------" + user.getUsername());  
  71. //        }  
  72.   
  73.         List<User> lists2= userDao.findList(1,2);  
  74.         for (User user : lists2) {  
  75.             logger.info("-------user遍历:-------" + user.getUsername());  
  76.         }  
  77.     }  
  78.   
  79.     @Test  
  80.     public void delete() {  
  81.         userDao.delete(userDao.findOneByUsername("skyLine2").getId());  
  82.     }  
  83.   
  84. }  
  85. </span>  

至此，基本的项目骨架就搭成了！

整个过程有些很多东西也是参考网上的博客，也结合自己的项目搭建起来的，万丈高楼平地起，再大的项目也是一点点的搭建，不断的测试，完善才完成的，在搭建项目的过程中收获了很多，当然这个项目只是第一步，自己会不断的完善！

另附整个项目的结构：

时间： 2024-10-01 19:06:57

架构之路之spring+springmvc+maven+mongodb的搭建（转载：http://blog.csdn.net/tomcat_2014/article/details/55100130）的相关文章

4种方法让SpringMVC接收多个对象（转：http://blog.csdn.net/lutinghuan/article/details/46820023）

问题背景: 我要在一个表单里同时一次性提交多名乘客的个人信息到SpringMVC,前端HTML和SpringMVC Controller里该如何处理? 第1种方法:表单提交,以字段数组接收: 第2种方法:表单提交,以BeanListModel接收: 第3种方法:将Json对象序列化成Json字符串提交,以List接收: 第4种方法:将表单对象序列化成Json字符串提交,以List接收: 第4种方法其实是第3种方法的升级,就是将表单转成Json对象,再转成Json字符串提交: 然而,第4种方法还不

Spring+SpringMVC+MongoDB案例

---------------------------------------------------------------------------------------------[版权申明:本文系作者原创,转载请注明出处] 文章出处:http://blog.csdn.net/sdksdk0/article/details/64948728作者:朱培      ID:sdksdk0     --------------------------------------------------

Spirng+SpringMVC+Maven+Mybatis+MySQL项目搭建

版权声明:本文为博主原创文章,转载注明出处http://blog.csdn.net/u013142781 目录(?)[+] 这篇文章主要讲解使用eclipse对Spirng+SpringMVC+Maven+Mybatis+MySQL项目搭建过程,包括里面步骤和里面的配置文件如何配置等等都会详细说明. 如果还没有搭建好环境(主要是Maven+MySQL的配置)的猿友可以参考博主以前的一篇文章: http://blog.csdn.net/u013142781/article/details/5030

Spring+SpringMVC+MyBatis整合

1.基本概念 1.1.Spring         Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来.它是为了解决企业应用开发的复杂性而创建的.Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情.然而,Spring的用途不仅限于服务器端的开发.从简单性.可测试性和松耦合的角度而

Spirng+SpringMVC+Maven+Mybatis+MySQL项目搭建（转）

这篇文章主要讲解使用eclipse对Spirng+SpringMVC+Maven+Mybatis+MySQL项目搭建过程,包括里面步骤和里面的配置文件如何配置等等都会详细说明. 如果还没有搭建好环境(主要是Maven+MySQL的配置)的猿友可以参考博主以前的一篇文章: http://blog.csdn.net/u013142781/article/details/50300233 接下来马上进入项目搭建过程: 1.创建表,并插入数据: CREATE DATABASE `ssi` /*!4010

spring+springmvc+springdata+jpa框架怎么连接两个不同的数据库

问题描述 spring+springmvc+springdata+jpa框架怎么连接两个不同的数据库 一个是本地mysql数据库,一个是orcale数据库 有没有demo看一下 解决方案 http://blog.csdn.net/jaune161/article/details/44014937 解决方案二: springmvc多数据源的配置和使用,可以参考:http://my.oschina.net/wangjiankui/blog/49107

uploadify在火狐下上传不了的解决方案，java版（Spring+SpringMVC+MyBatis）详细解决方案

 由于技术选型的原因,在一个产品中,我选择了uploadify,选择它的原因是它有完善的技术文档说明(http://www.uploadify.com/documentation/),唯一不足的是官方文档上的例子是用php写的.而对与我们这些使用Java语言的小生们而言,在遇到问题后发现找到一个适合自己的例子很不好找.特别是当遇到浏览器兼容问题的时候,找了好久最终发现按照网上的方式进行编写了,最终还是会出现莫名其妙的问题,而继续查找资料的时候,发现讲解的并不详细. 下面我就把我遇到的这些问题

spring + springMVC + mybatis 存取 blob

问题描述 spring + springMVC + mybatis 存取 blob spring + springMVC + mybatis 存取 blob 大神指导 解决方案 http://blog.csdn.net/evankaka/article/details/45790533 看看我写的吧 解决方案二: Spring+SpringMVC+MyBatis 解决方案三: 代码中将blob属性的元素转为byte[]输入 mybaits中插入表明这个元素为blob 比如: insert int

SSH(spring+springmvc+hibernate)框架快速上手

目录框架 目录框架如图所示.java代码包名即所存放代码的分类. - controller->处理请求 - dao->数据访问层接口 - dao.impl->数据访问层接口实现(实现数据库操作) - entity->实体类(数据库中的表) - service->业务层接口 - service.impl->业务层接口实现(主要代码编写区域) - util->工具集 配置文件 - hibernate.properties->hibernate相关配置(数据库驱动