spring+springmvc+maven+mongodb

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依赖

1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
2. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
3. <modelVersion>4.0.0</modelVersion>
4. <groupId>com.tl.project</groupId>
5. <artifactId>skyLine</artifactId>
6. <packaging>war</packaging>
7. <version>1.0-SNAPSHOT</version>
8. <name>skyLine Maven Webapp</name>
9. <url>http://maven.apache.org</url>
10. <!--建议我所引用包的版本集中放在这里，这样比较直观-->
11. <properties>
12. <spring.version>4.2.5.RELEASE</spring.version>
13. <aspectj.version>1.8.9</aspectj.version>
14. <cglib.version>3.2.4</cglib.version>
15. <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
16. </properties>
17. <dependencies>
18. <dependency>
19. <groupId>junit</groupId>
20. <artifactId>junit</artifactId>
21. <!--<version>3.8.1</version>-->
22. <version>4.12</version>
23. <scope>test</scope>
24. </dependency>
25. <dependency>
26. <groupId>org.springframework</groupId>
27. <artifactId>spring-web</artifactId>
28. <version>${spring.version}</version>
29. </dependency>
30. <dependency>
31. <groupId>org.springframework</groupId>
32. <artifactId>spring-webmvc</artifactId>
33. <version>${spring.version}</version>
34. <scope>compile</scope>
35. <!--<exclusions>-->
36. <!--<exclusion>-->
37. <!--<groupId>commons-logging</groupId>-->
38. <!--<artifactId>commons-logging</artifactId>-->
39. <!--</exclusion>-->
40. <!--</exclusions>-->
41. </dependency>
42. <dependency>
43. <groupId>commons-logging</groupId>
44. <artifactId>commons-logging</artifactId>
45. <version>1.2</version>
46. </dependency>
47. <dependency>
48. <groupId>org.springframework</groupId>
49. <artifactId>spring-jdbc</artifactId>
50. <version>${spring.version}</version>
51. </dependency>
52. <dependency>
53. <groupId>org.springframework</groupId>
54. <artifactId>spring-test</artifactId>
55. <version>${spring.version}</version>
56. <scope>test</scope>
57. </dependency>
58. <dependency>
59. <groupId>org.springframework</groupId>
60. <artifactId>spring-core</artifactId>
61. <version>${spring.version}</version>
62. </dependency>
63. <dependency>
64. <groupId>org.springframework</groupId>
65. <artifactId>spring-context</artifactId>
66. <version>${spring.version}</version>
67. </dependency>
68. <dependency>
69. <groupId>org.springframework</groupId>
70. <artifactId>spring-context-support</artifactId>
71. <version>${spring.version}</version>
72. </dependency>
73. <dependency>
74. <groupId>org.mybatis</groupId>
75. <artifactId>mybatis</artifactId>
76. <version>3.2.7</version>
77. </dependency>
78. <dependency>
79. <groupId>org.mybatis</groupId>
80. <artifactId>mybatis-spring</artifactId>
81. <version>1.2.2</version>
82. </dependency>
83. <dependency>
84. <groupId>mysql</groupId>
85. <artifactId>mysql-connector-java</artifactId>
86. <version>5.1.30</version>
87. </dependency>
88. <!-- mongoDB支持jar -->
89. <dependency>
90. <groupId>org.springframework.data</groupId>
91. <artifactId>spring-data-mongodb</artifactId>
92. <version>1.8.4.RELEASE</version>
93. </dependency>
94. <dependency>
95. <groupId>javax.servlet</groupId>
96. <artifactId>javax.servlet-api</artifactId>
97. <version>3.1.0</version>
98. <scope>provided</scope>
99. </dependency>
100. <dependency>
101. <groupId>javax.servlet.jsp</groupId>
102. <artifactId>jsp-api</artifactId>
103. <version>2.1</version>
104. <scope>provided</scope>
105. </dependency>
106. <!--JSP标准标签库（JSTL）-->
107. <dependency>
108. <groupId>javax.servlet</groupId>
109. <artifactId>jstl</artifactId>
110. <version>1.2</version>
111. </dependency>
112. <dependency>
113. <groupId>dom4j</groupId>
114. <artifactId>dom4j</artifactId>
115. <version>1.6.1</version>
116. </dependency>
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. </dependencies>
139. <build>
140. <finalName>skyLine</finalName>
141. <plugins>
142. <!-- 编码和编译和JDK版本 -->
143. <!--解决@Override not allowed when implementing interface method报错问题-->
144. <plugin>
145. <groupId>org.apache.maven.plugins</groupId>
146. <artifactId>maven-compiler-plugin</artifactId>
147. <version>2.3.2</version>
148. <configuration>
149. <source>1.8</source>
150. <target>1.8</target>
151. <encoding>utf8</encoding>
152. </configuration>
153. </plugin>
154. </plugins>
155. </build>
156. </project>

3.2.2 spring-context.xml

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

3.2.3 springmvc-servlet.xml

1. <?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:mvc="http://www.springframework.org/schema/mvc"
6. xmlns:context="http://www.springframework.org/schema/context"
7. xsi:schemaLocation="http://www.springframework.org/schema/beans
8. http://www.springframework.org/schema/beans/spring-beans.xsd
9. http://www.springframework.org/schema/mvc
10. http://www.springframework.org/schema/mvc/spring-mvc.xsd
11. http://www.springframework.org/schema/context
12. http://www.springframework.org/schema/context/spring-context.xsd">
13. <!--只在springmvc容器中配置controller的扫描-->
14. <context:component-scan base-package="com.tl.skyLine" use-default-filters="false">
15. <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
16. </context:component-scan>
17. <!--这个是SpringMVC必须要配置的，因为它声明了@RequestMapping、@RequestBody、@ResponseBody等。并且，该配置默认加载很多的参数绑定方法，比如json转换解析器等。-->
18. <mvc:annotation-driven/>
19. <!-- 将在Controller返回的ModelAndView,加上目录前缀/WEB-INF/views/, 文件名称后缀.jsp -->
20. <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
21. <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
22. <!--<beans:property name="prefix" value="/WEB-INF/views/"/>-->
23. <property name="prefix" value="/pages/"/>
24. <property name="suffix" value=".jsp"/>
25. </bean>
26. <!-- 对静态资源文件的访问-->
27. <!--<mvc:resources mapping="/images/**" location="/WEB-INF/images/" cache-period="31556926"/>-->
28. <!--<mvc:resources mapping="/js/**" location="/WEB-INF/js/" cache-period="31556926"/>-->
29. <!--<mvc:resources mapping="/css/**" location="/WEB-INF/css/" cache-period="31556926"/>-->
30. <!--由于父子容器的关系,@controller注解扫描配置在mvc中,所以启动shiro注解也需要在子容器中引用一次-->
31. <import resource="shiro-context.xml"/>
32. </beans>

3.2.4 mongodb-context.xml

1. <?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. <!-- 定义mongo对象，对应的是mongodb官方jar包中的Mongo，replica-set设置集群副本的ip地址和端口 -->
15. <mongo:mongo id="mongo" replica-set="${mongo.hostport}">
16. <!-- 一些连接属性的设置 -->
17. <mongo:options
18. connections-per-host="${mongo.connectionsPerHost}"
19. threads-allowed-to-block-for-connection-multiplier="${mongo.threadsAllowedToBlockForConnectionMultiplier}"
20. connect-timeout="${mongo.connectTimeout}"
21. max-wait-time="${mongo.maxWaitTime}"
22. auto-connect-retry="${mongo.autoConnectRetry}"
23. socket-keep-alive="${mongo.socketKeepAlive}"
24. socket-timeout="${mongo.socketTimeout}"
25. slave-ok="${mongo.slaveOk}"
26. write-number="1"
27. write-timeout="0"
28. write-fsync="true"/>
29. </mongo:mongo>
30. <!-- mongo的工厂，通过它来取得mongo实例,dbname为mongodb的数据库名，没有的话会自动创建 -->
31. <mongo:db-factory dbname="skyLine" mongo-ref="mongo"/>
32. <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
33. <constructor-arg ref="mongo"/>
34. <constructor-arg name="databaseName" value="${mongo.database}"/>
35. </bean>
36. <!-- 映射转换器，扫描back-package目录下的文件，根据注释，把它们作为mongodb的一个collection的映射 -->
37. <mongo:mapping-converter base-package="com.tl.skyLine.model"/>
38. <!-- mongodb bean的仓库目录，会自动扫描扩展了MongoRepository接口的接口进行注入 -->
39. <mongo:repositories base-package="com.tl.skyLine.repository"/>
40. </beans>

3.2.5 config.properties

1. #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

3.2.7 logging.properties

这个主要是为tomcat在控制台增加报错日志信息，方便项目搭建的时候调试用的：

1. handlers = org.apache.juli.FileHandler, java.util.logging.ConsoleHandler
2. ############################################################
3. # Handler specific properties.
4. # Describes specific configuration info for Handlers.
5. ############################################################
6. org.apache.juli.FileHandler.level = FINE
7. org.apache.juli.FileHandler.directory = ${catalina.base}/logs
8. org.apache.juli.FileHandler.prefix = error-debug.
9. java.util.logging.ConsoleHandler.level = FINE
10. java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter

3.2.8 log4j.properties

这个是项目打印日志信息用的，也可配置打印在控制台，或者打印在硬盘某个路径下的文档里：

1. #rootCategory:默认是对整个工程生效
2. log4j.rootCategory=INFO, stdout
3. #日志输出级别,日志信息的优先级从高到低有ERROR、WARN、 INFO、DEBUG
4. log4j.rootLogger=info, stdout
5. ### stdout ###
6. #设置stdout的日志输出控制台
7. log4j.appender.stdout=org.apache.log4j.ConsoleAppender
8. #输出日志到控制台的方式，默认为System.out
9. log4j.appender.stdout.Target=System.out
10. #设置使用灵活布局
11. log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
12. #灵活定义输出格式
13. log4j.appender.stdout.layout.ConversionPattern=[%p][%d{yyyy-MM-dd HH:mm:ss}] %l %m %n
14. #设置other的日志输出控制台
15. log4j.appender.other=org.apache.log4j.RollingFileAppender
16. #设置other的输出日志
17. log4j.appender.other.File=${webapp.root}/WEB-INF/logs/log.log
18. #设置other的日志最大限制
19. log4j.appender.other.MaxFileSize=1024KB
20. #最多只保存20个备份文件
21. log4j.appender.other.MaxBackupIndex=1000
22. #输出INFO级别以上的日志
23. og4j.appender.other.Threshold=INFO
24. #设置使用灵活布局
25. log4j.appender.other.layout=org.apache.log4j.PatternLayout
26. #灵活定义输出格式
27. log4j.appender.other.layout.ConversionPattern=[%p][%d{yyyy-MM-dd HH:mm:ss}] %l %t %m %n

输出格式可以自己定义，我们上面定义的比较多，如果觉得控制台打印内容过于繁琐，可以根据需求修改，比如如果把%l去掉，这样就不会显示日志发生的位置，不会打印类名，方法名了；

1. %m   输出代码中指定的消息
2. 　　%p   输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL
3. 　　%r   输出自应用启动到输出该log信息耗费的毫秒数
4. 　　%c   输出所属的类目，通常就是所在类的全名
5. 　　%t   输出产生该日志事件的线程名
6. 　　%n   输出一个回车换行符，Windows平台为“/r/n”，Unix平台为“/n”
7. 　　%d   输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyy MMM dd HH:mm:ss , SSS}，输出类似：2002年10月18日  22 ： 10 ： 28 ， 921
8. 　　%l   输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。举例：Testlog4.main(TestLog4.java: 10 )

3.2.9 web.xml

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

3.3 User类

1. package com.tl.skyLine.model;
2. import org.springframework.data.annotation.Id;
3. import org.springframework.data.mongodb.core.mapping.Document;
4. /**
5. * 系统操作人员
6. */
7. @Document(collection = "sky.user")
8. public class User {
9. @Id
10. private String id;
11. private String username;
12. private String password;
13. public String getId() {
14. return id;
15. }
16. public void setId(String id) {
17. this.id = id;
18. }
19. public String getUsername() {
20. return username;
21. }
22. public void setUsername(String username) {
23. this.username = username;
24. }
25. public String getPassword() {
26. return password;
27. }
28. public void setPassword(String password) {
29. this.password = password;
30. }
31. }

3.4 数据层操作dao

userDao

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

userDaoImpl

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

3.5单元测试

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

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

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

另附整个项目的结构：