spring+springMVC 整合 MongoDB 实现注册登录

发现一入手 MongoDB，便无法脱离，简要说一下，MongoDB 是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。

也是在 Nosql 中我最喜欢的一种数据库，MongoDB 将数据存储为一个文档，数据结构由键值(key=>value)对组成。MongoDB 文档类似于 JSON 对象。字段值可以包含其他文档，数组及文档数组。

谈一下关系型数据库（RDBMS）与 MongoDB 的对应关系：

建立 maven 工程，需要导入与 MongoDB 相关的驱动包：

         <!--MongoDB驱动包-->
         <dependency>
             <groupId>org.mongodb</groupId>
             <artifactId>mongo-java-driver</artifactId>
             <version>3.1.0</version>
         </dependency>
         <!--MongoDB核心包-->
         <dependency>
             <groupId>org.springframework.data</groupId>
             <artifactId>spring-data-mongodb</artifactId>
             <version>1.8.2.RELEASE</version>
         </dependency>

幸运的是，spring data mongodb 提供的 MongoTemplate 模板对数据库的操作变得十分简单，在 dao 层做一个接口和实现类，创建一个 MongoTemplate 对象，就可以完成数据库一些相关操作。

话不多说，直接来干货：

先看看目录结构：

pom.xml

 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.krry</groupId>
     <artifactId>krry_mongodb</artifactId>
     <packaging>war</packaging>
     <version>1.0-SNAPSHOT</version>
     <name>krry_mongodb Maven Webapp</name>
     <url>http://maven.apache.org</url>

     <dependencies>
         <!--引入servlet -->
         <dependency>
             <groupId>javax.servlet</groupId>
             <artifactId>servlet-api</artifactId>
             <version>3.0-alpha-1</version>
             <scope>provided</scope>
         </dependency>
         <!--引入jstl的包  -->
         <dependency>
             <groupId>jstl</groupId>
             <artifactId>jstl</artifactId>
             <version>1.2</version>
             <scope>provided</scope>
          </dependency>

          <!--引入jsp的编译依赖  -->
          <dependency>
             <groupId>javax.servlet.jsp</groupId>
             <artifactId>jsp-api</artifactId>
             <version>2.2</version>
             <scope>provided</scope>
          </dependency>

          <!--引入log4j  -->
          <dependency>
             <groupId>log4j</groupId>
             <artifactId>log4j</artifactId>
             <version>1.2.17</version>
           </dependency>

           <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-lang3</artifactId>
             <version>3.3.2</version>
           </dependency>

         <!--MongoDB驱动包-->
         <dependency>
             <groupId>org.mongodb</groupId>
             <artifactId>mongo-java-driver</artifactId>
             <version>3.1.0</version>
         </dependency>
         <!--MongoDB核心包-->
         <dependency>
             <groupId>org.springframework.data</groupId>
             <artifactId>spring-data-mongodb</artifactId>
             <version>1.8.2.RELEASE</version>
         </dependency>

         <!--引入junit  -->
         <dependency>
           <groupId>junit</groupId>
           <artifactId>junit</artifactId>
           <version>4.11</version>
           <scope>test</scope>
         </dependency>

       <!--spring springmvc mybatis  -->
          <!-- spring和springmvc相关的构建  jar -->
          <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-context</artifactId>
             <version>4.0.2.RELEASE</version>
           </dependency>

           <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-jdbc</artifactId>
             <version>4.0.2.RELEASE</version>
           </dependency>

           <!-- springmvc相关 -->
          <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-webmvc</artifactId>
             <version>4.0.2.RELEASE</version>
           </dependency>

           <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-lang3</artifactId>
             <version>3.3.2</version>
           </dependency>

     </dependencies>

 </project>

applicationContext.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/beans
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/data/mongo
        http://www.springframework.org/schema/data/mongo/spring-mongo.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
      ">

     <!-- 加载mongodb的属性配置文件 -->
     <context:property-placeholder location="classpath:mongodb.properties" />  

     <!--1.开启注解-->
     <context:annotation-config/>

     <!--2.配置包扫描 -->
     <context:component-scan base-package="com.krry">
         <!--过滤掉控制层的注解  -->
         <context:exclude-filter type="annotation"
              expression="org.springframework.stereotype.Controller"/>
     </context:component-scan>

     <!--3.服务器连接信息-->
     <mongo:mongo-client host="${mongo.host}" port="${mongo.port}"></mongo:mongo-client>

     <!--4.创建mongoTemplate模板-->
     <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
         <constructor-arg ref="mongo"/>
         <!-- 设置使用的数据库 名-->
         <constructor-arg name="databaseName" value="${mongo.dbname}"/>
     </bean>

 </beans>

mongodb.properties

 #mongoDB\u8FDE\u63A5\u914D\u7F6E
 mongo.dbname=krry_test
 mongo.host=127.0.0.1
 mongo.port=27017
 #mongo.username=root
 #mongo.password=root
 #\u4E00\u4E2A\u7EBF\u7A0B\u53D8\u4E3A\u53EF\u7528\u7684\u6700\u5927\u963B\u585E\u6570
 mongo.connectionsPerHost=8
 #\u7EBF\u7A0B\u961F\u5217\u6570,\u5B83\u4EE5\u4E0A\u9762connectionsPerHost\u503C\u76F8\u4E58\u7684\u7ED3\u679C\u5C31\u662F\u7EBF\u7A0B\u961F\u5217\u6700\u5927\u503C
 mongo.threadsAllowedToBlockForConnectionMultiplier=4
 #\u8FDE\u63A5\u8D85\u65F6\u65F6\u95F4\uFF08\u6BEB\u79D2\uFF09
 mongo.connectTimeout=1500
 #\u6700\u5927\u7B49\u5F85\u65F6\u95F4
 mongo.maxWaitTime=1500
 #\u81EA\u52A8\u91CD\u8FDE
 mongo.autoConnectRetry=true
 #scoket\u4FDD\u6301\u6D3B\u52A8
 mongo.socketKeepAlive= true
 #scoket\u8D85\u65F6\u65F6\u95F4
 mongo.socketTimeout=1500
 #\u8BFB\u5199\u5206\u79BB
 mongo.slaveOk=true

springmvc.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"
     xmlns:util="http://www.springframework.org/schema/util"
     xmlns:mvc="http://www.springframework.org/schema/mvc"
     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/util
        http://www.springframework.org/schema/util/spring-util-3.0.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
       ">

          <!-- 扫包 -->
          <context:component-scan base-package="com.krry.controller"></context:component-scan>

          <!--以下映射器和适配器的配置可以通过注解驱动来代替  -->
        <mvc:annotation-driven></mvc:annotation-driven>

          <!--对静态资源文件的访问  必须要设置，因为在springmvc的配置中配置了/匹配所有请求，
         此工程所有的请求(.do ,addUser,js/image/css)都会被springmvc解析,
         必须对所有的静态资源文件进行过滤放行 -->
       <mvc:resources mapping="/resource/**" location="/resource/" />

       <!-- 拦截器定义 -->
       <mvc:interceptors>
           <mvc:interceptor>
              <!-- 个人中心也需要登陆  以admin开头的配置都会进行拦截-->
                <mvc:mapping path="/admin/**"></mvc:mapping>
                <!-- 这个是设置不会进入拦截器的路径 -->
                <mvc:exclude-mapping path="/resource/**"/>
             <!-- 拦截器进入的类，返回false表示不会进入输入的路径 -->
             <bean class="com.krry.core.LoginInterceptor" />
           </mvc:interceptor>
       </mvc:interceptors>

        <!-- 视图渲染 jsp/freemaker/velocity-->
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
                <!-- 制定页面存放的路径 -->
                <property name="prefix" value="/WEB-INF/pages/"></property>
                <!-- 文件的后缀 -->
                <property name="suffix" value=".jsp"></property>
        </bean> 

 </beans>

web.xml

 <?xml version="1.0" encoding="UTF-8"?>
 <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">  

    <display-name>krry_mongodb</display-name>

   <welcome-file-list>
     <welcome-file>index/index</welcome-file>
   </welcome-file-list>

   <!-- 加载Spring IOC容器 -->
   <context-param>
     <param-name>contextConfigLocation</param-name>
     <param-value>classpath:applicationContext.xml</param-value>
   </context-param>

   <!-- spring上下文监听器 -->
   <listener>
     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
   </listener>

   <!-- Introspector缓存清除监听器 -->
   <listener>
     <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
   </listener>

   <filter>
     <filter-name>encoding</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>
   </filter>

   <filter-mapping>
     <filter-name>encoding</filter-name>
     <url-pattern>/*</url-pattern>
   </filter-mapping>

   <!-- 配置DispatcherServlet -->
   <servlet>
     <servlet-name>krry_mongodb</servlet-name>
     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
     <!-- 配置springMVC的配置文件 -->
     <!-- 如果不配置下面选项，系统默认加载classpath下面名为[servlet-name]-servlet.xml的文件 springmvc01-servlet.xml -->
     <init-param>
       <param-name>contextConfigLocation</param-name>
       <param-value>classpath:springmvc.xml</param-value>
     </init-param>
   </servlet>

    <!-- 这里再配一次，才可以使用欢迎页
     标签里面一定要以/开头，与欢迎页的区别就是这里
    <url-pattern>/...</url-pattern> -->
   <servlet-mapping>
       <servlet-name>krry_mongodb</servlet-name>
       <url-pattern>/index/index</url-pattern>
   </servlet-mapping>

   <!-- 可以配*.do, *.action(了解) / (重点): 所有的请求都会被spring mvc解析，但必须对静态资源文件进行过滤放行，建议大家使用这种方式
         /* : 不建议大家使用  -->
   <servlet-mapping>
     <servlet-name>krry_mongodb</servlet-name>
     <url-pattern>/</url-pattern>
   </servlet-mapping>

 </web-app>

dao 层：IUserDao.java

 package com.krry.dao;

 import java.util.List;

 import com.krry.entity.User;

 /**
  *
  * @author
  */
 public interface IUserDao {

     /**
      * 添加
      * @param User
      */
     public void addUser(User User);

     /**
      * 删除
      * @param id
      */
     public void removeUser(String id);

     /**
      * 保存或修改
      * @param User
      */
     public void saveOrUpdateUser(User User);

     /**
      * 根据id查询单个
      * @param id
      * @return
      */
     public User findById(String id);

     /**
      * 根据用户名查询
      * @param id
      * @return
      */
     public User findByUsername(String username);

     /**
      * 查询所有
      * @return
      */
     public List<User> findAll();

 }

UserDaoImpl.java

 package com.krry.dao.impl;

 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.mongodb.core.MongoTemplate;
 import org.springframework.data.mongodb.core.query.Criteria;
 import org.springframework.data.mongodb.core.query.Query;
 import org.springframework.stereotype.Repository;

 import com.krry.dao.IUserDao;
 import com.krry.entity.User;

 import java.util.List;

 /**
  * @author
  */
 @Repository
 public class UserDaoImpl implements IUserDao {

     @Autowired
     private MongoTemplate mongoTemplate;

     public void addUser(User User) {
         //1.如果没有指定集合，则默认添加到和对象名称相同的集合中，没有则创建一个
         //2.也可以指定集合 mongoTemplate.save(User, "User_db");
         mongoTemplate.save(User);
     }

     public void removeUser(String id) {

         User User = findById(id);
         mongoTemplate.remove(User);
     }

     public void saveOrUpdateUser(User User) {

         mongoTemplate.save(User);
     }

     public User findById(String id) {

         return mongoTemplate.findById(id, User.class);
     }

     public List<User> findAll() {

         return mongoTemplate.findAll(User.class);
     }

     public User findByUsername(String username) {
         //根据username查询
         Query sql = new Query(Criteria.where("username").is(username));

         return mongoTemplate.findOne(sql,User.class);
     }
 }

实体类：User.java

 package com.krry.entity;

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

 /**
  * @Document(collection = "user")这个注解和Hibernate的注解Entiry非常相似，
  * 就是定义一个文档，对象MongoDB存储的Collection（表）的名称是user
  * @Id指该字段是主键，不能缺少
  * @Field("username")指该字段映射MongoDB的实际字段，如果一致可以省略、
  *
  * User
  * @author krry
  * @version 1.0.0
  *
  */
 @Document(collection = "user")
 public class User {

     //主键
     @Id
     private String id;
     //用户名
     @Field("username")
     private String username;
     //密码
     private String password;
     //建时间
     private String createTime;

     public User() {

     }

     public User(String username,String password,String createTime) {
         this.username = username;
         this.password = password;
         this.createTime = createTime;
     }

     public String getCreateTime() {
         return createTime;
     }

     public void setCreateTime(String createTime) {
         this.createTime = createTime;
     }

      public String getId() {
          return id;
      }

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

      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;
      }

     @Override
     public String toString() {
         return "User [id=" + id + ", username=" + username + ", password="
                 + password + ", createTime=" + createTime + "]";
     }

 }

controller 层：KrryController.java

 package com.krry.controller;

 import java.text.SimpleDateFormat;
 import java.util.Date;

 import javax.servlet.http.HttpServletRequest;

 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;

 import com.krry.dao.IUserDao;
 import com.krry.entity.User;
 import com.krry.util.TmStringUtils;

 /**
  * Controller层，作为请求转发
  * 页面所有路径的访问方法:控制层的命名空间+@RequestMapping的value
  * */
 @Controller
 @RequestMapping("/index")
 public class KrryController {

     @Autowired
     private IUserDao userDao;

     /**
      * 进入首页
      * @return
      */
     @RequestMapping("/index")
     public String index(){

         return "index/index";   //默认是转发，不会显示转发路径
     }

     /**
      * 进入登录界面
      * @return
      */
     @RequestMapping("/login")
     public String login(){

         return "index/login";   //默认是转发，不会显示转发路径
     }

     /**
      * 点击登录
      * com.krry.controller.login
      * 方法名：login
      * @author krry
      * @param request
      * @return String
      * @exception
      * @since  1.0.0
      */
     @RequestMapping(method=RequestMethod.POST,value="/logined")
     public String login(HttpServletRequest request){
         //获取用户和密码
         String username = request.getParameter("username");
         String password = request.getParameter("password");

         //如果邮箱和密码为null,那么就返回已null标识
         if(TmStringUtils.isEmpty(username)) return "index/allError";
         if(TmStringUtils.isEmpty(password)) return "index/allError";

         //根据邮箱或昵称查询，用户是否存在
         User user = userDao.findByUsername(username);

         //如果存在
         if(user!=null){

             if(password.equals(user.getPassword())){
                 //如果密码正确
                 //将用户信息放入到会话中...
                 request.getSession().setAttribute("user", user);

                 //这里使用重定向 ,重定向到当前命名空间下@RequestMapping是index的方法
                 return "redirect:index";
             }else{
                 //如果密码错误
                 System.out.println("密码错误");
                 return "index/error";
             }
         }else{
             //如果不存在，代码邮箱和密码输入有误
             System.out.println("用户不存在");
             return "index/error";
         }
     }

     /**
      * 退出登录控制层
      * com.krry.controller.login
      * 方法名：logout
      * @author krry
      * @param request
      * @return String
      * @exception
      * @since  1.0.0
      */
     @RequestMapping(method=RequestMethod.GET,value="/logout")
     public String logout(HttpServletRequest request){
         request.getSession().invalidate(); //清空session值
         return "index/index";
     }

     /**
      * 打开注册界面层
      * @return
      */
     @RequestMapping("/rege")
     public String rege(){

         return "index/resgi";
     }

     /**
      * 注册控制层
      * com.krry.controller.login
      * 方法名：resig
      * @author krry
      * @param request
      * @return String
      * @exception
      * @since  1.0.0
      */
     @RequestMapping(method=RequestMethod.POST,value="/resig")
     public String resig(HttpServletRequest request){
         //获取用户和密码
         String username = request.getParameter("username");
         String password = request.getParameter("password");

         //如果邮箱和密码为null,那么就返回已null标识
         if(TmStringUtils.isEmpty(username) )return "index/allError";
         if(TmStringUtils.isEmail(password))return "index/allError";

         //根据昵称查询，用户是否存在
         User user = userDao.findByUsername(username);

         //若存在
         if(user != null){ //昵称重复
             return "index/allError";
         }

         //格式化时间类型
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
         String nowTime = sdf.format(new Date());

         //执行到这里，说明可以注册
         User newUser = new User(username, password, nowTime);
         //调用注册方法
         userDao.saveOrUpdateUser(newUser);

         //将信息设置session作用域
         request.getSession().setAttribute("user", newUser);

         return "redirect:index";
     }

 }

上面的文件，关键代码均有注释。

细心，总结，也不要死坑于一点，善于转化

相关链接：

GitHub：https://github.com/Krryxa

音乐博客：https://www.ainyi.com