SpringMVC入门+Mybatis实践demo

系统管理员 2022-05-31 06:39 232阅读 0赞

看了几天的SpringMVC，换了很多视频，看了很多博客也不是特别懂，直到看到b站上有人分享出了付费版的极客学院的讲解视频我才大致了解了这个框架，结合一篇博客，花了一天写代码，一天debug，总算是成功运行了，学一个框架一开始给你讲大道理讲细节是很难懂的（可能是我太笨），只有跟着几个简单的demo一起做一遍，边做边查相关的资料，debug的时候也能学会很多，几天下来终于明白了学习的方法。

做完demo之后，SpringMVC是将一个web项目的所有东西粘合起来成一个整体的粘合剂，这个比喻再恰当不过了。一个web项目涉及许多的东西，比如jsp文件，各种xml配置，一堆servlet，还有就是配合spring框架使用的各种POJO类，已经我们要写的与数据库相连的DAO层，在SpringMVC的作用就是将这些整合起来，更方便得互相调用。

下面分享一个demo，写了一个简单的登录界面，注册功能，期间用mybatis来操作数据库（当然jdbc也可以，但是会更复杂，mybatis也很好学的），用的ide是idea，maven进行管理，junit进行数据库DAO层测试。

本次项目代码已经上传到github了，有需要的可以下载：https://github.com/iunique/IdeaProject

先看一下大致的骨架，注意一开始初始生成的那个index.jsp要删掉！！这个坑了我好久，因为它的优先级比springMVC设置的更高。

一张图还放不下要放两张。

20180209193358231 20180209193404306

注意摆放的位置。

然后是maven管理jar包的配置文件pom.xml：

  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.springMVC</groupId>
  5.   <artifactId>springMVC</artifactId>
  6.   <packaging>war</packaging>
  7.   <version>1.0-SNAPSHOT</version>
  8.   <name>springMVC Maven Webapp</name>
  9.   <url>http://maven.apache.org</url>
  10.   <dependencies>
  11.     <dependency>
  12.       <groupId>javax.servlet</groupId>
  13.       <artifactId>javax.servlet-api</artifactId>
  14.       <version>4.0.0</version>
  15.       <scope>provided</scope>
  16.     </dependency>
  17.     <dependency>
  18.       <groupId>junit</groupId>
  19.       <artifactId>junit</artifactId>
  20.       <version>4.9</version>
  21.       <scope>test</scope>
  22.     </dependency>
  23.     <!--springMVCjar包-->
  24.     <dependency>
  25.       <groupId>org.springframework</groupId>
  26.       <artifactId>spring-webmvc</artifactId>
  27.       <version>5.0.2.RELEASE</version>
  28.     </dependency>
  29.     <!--mybatis所需jar包配置-->
  30.     <dependency>
  31.       <groupId>mysql</groupId>
  32.       <artifactId>mysql-connector-java</artifactId>
  33.       <version>5.1.29</version>
  34.     </dependency>
  35.     <dependency>
  36.       <groupId>org.mybatis</groupId>
  37.       <artifactId>mybatis-spring</artifactId>
  38.       <version>1.3.1</version>
  39.     </dependency>
  40.     <dependency>
  41.       <groupId>org.mybatis</groupId>
  42.       <artifactId>mybatis</artifactId>
  43.       <version>3.3.0</version>
  44.     </dependency>
  45.     <!--spring所需jar包-->
  46.     <dependency>
  47.       <groupId>org.springframework</groupId>
  48.       <artifactId>spring-web</artifactId>
  49.       <version>5.0.2.RELEASE</version>
  50.     </dependency>
  51.     <dependency>
  52.       <groupId>org.springframework</groupId>
  53.       <artifactId>spring-core</artifactId>
  54.       <version>5.0.2.RELEASE</version>
  55.     </dependency>
  56.     <dependency>
  57.       <groupId>org.springframework</groupId>
  58.       <artifactId>spring-context</artifactId>
  59.       <version>5.0.2.RELEASE</version>
  60.     </dependency>
  61.     <dependency>
  62.       <groupId>org.springframework</groupId>
  63.       <artifactId>spring-context-support</artifactId>
  64.       <version>5.0.2.RELEASE</version>
  65.     </dependency>
  66.     <dependency>
  67.       <groupId>org.springframework</groupId>
  68.       <artifactId>spring-beans</artifactId>
  69.       <version>5.0.2.RELEASE</version>
  70.     </dependency>
  71.     <dependency>
  72.       <groupId>org.springframework</groupId>
  73.       <artifactId>spring-expression</artifactId>
  74.       <version>5.0.2.RELEASE</version>
  75.     </dependency>
  76.     <dependency>
  77.       <groupId>org.springframework</groupId>
  78.       <artifactId>spring-aop</artifactId>
  79.       <version>5.0.2.RELEASE</version>
  80.     </dependency>
  81.   </dependencies>
  82.   <build>
  83.     <finalName>springMVC</finalName>
  84.   </build>
  85. </project>

首先准备一份数据，进入mysql数据库，我的数据库名称叫mybatis,然后建一张叫user的表

  1. itcreate table user(
  2.     id int auto_increment primary key,
  3.     name varchar(20) not null,
  4.     age tinyint not null,
  5.     password varchar(20) not null
  6. )engine=innoDB;
  8. insert into user(name,age,password) values("hjy",18,"123456");
  9. insert into user(name,age,password) values("unique",19,"666666");

我喜欢先从java代码开始写起，那么就先写一个POJO类吧，叫做User.java:

  1. package domain;
  3. public class User {
  4.     private int id;
  5.     private String name;
  6.     private int age;
  7.     private String password;
  9.     public int getId() {
  10.         return id;
  11.     }
  13.     public void setId(int id) {
  14.         this.id = id;
  15.     }
  17.     public String getName() {
  18.         return name;
  19.     }
  21.     public void setName(String name) {
  22.         this.name = name;
  23.     }
  25.     public int getAge() {
  26.         return age;
  27.     }
  29.     public void setAge(int age) {
  30.         this.age = age;
  31.     }
  33.     public String getPassword() {
  34.         return password;
  35.     }
  37.     public void setPassword(String password) {
  38.         this.password = password;
  39.     }
  40. }

然后我会写mybatis的配置文件config.xml：

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE configuration
  3.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
  5. <configuration>
  6.     <!-- 和Spring整合后environment配置都会被干掉 -->
  7.     <environments default="development">
  8.         <environment id="development">
  9.             <!-- 使用jdbc事务管理，目前由mybatis来管理 -->
  10.             <transactionManager type="JDBC" />
  11.             <!-- 数据库连接池，目前由mybatis来管理 -->
  12.             <dataSource type="POOLED"><!--有关于mysql数据库的各种信息-->
  13.                 <property name="driver" value="com.mysql.jdbc.Driver" />
  14.                 <property name="url" value="jdbc:mysql://localhost:3306/mybatis" />
  15.                 <property name="username" value="root" />
  16.                 <property name="password" value="123456" />
  17.             </dataSource>
  18.         </environment>
  19.     </environments>
  20.     <mappers>
  21.         <!--将操作配置文件User.xml系添加进mapper-->
  22.         <mapper resource="User.xml" />
  23.     </mappers>
  24. </configuration>

和打算对数据库进行的操作mybatis的配置文件User.xml：

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  6. <mapper namespace="test">
  7.     <!-- 通过id查询用户 -->
  8.     <select id="findUserById" parameterType="int" resultType="domain.User">
  9.         select * from user where id = #{id}
  10.     </select>
  11.     <!--通过name用户-->
  12.     <select id="findUserByName" parameterType="java.lang.String" resultType="domain.User">
  13.         select * from user where name like '${value}'
  14.     </select>
  15.     <!--根据name和password查询User-->
  16.     <select id="checkLogin" parameterType="domain.User" resultType="domain.User">
  17.         select * from user where name=#{name} and password=#{password}
  18.     </select>
  19.     <!--插入用户信息-->
  20.     <insert id="insertUser" parameterType="domain.User">
  21.         insert into user(name,age,password) values(#{name},#{age},#{password})
  22.         <selectKey keyProperty="id" order="AFTER" resultType="java.lang.Integer">
  23.             select last_insert_id()
  24.             --             这里是对于主键属性的id进行赋值
  25.         </selectKey>
  26.     </insert>
  27.     <!--删除用户信息-->
  28.     <delete id="deleteUser" parameterType="java.lang.Integer">
  29.         delete from user where id=#{id}
  30.     </delete>
  31.     <!--更新用户信息-->
  32.     <update id="updateUser" parameterType="domain.User">
  33.         update user set name=#{name},age=#{age},password=#{password} where id=#{id}
  34.     </update>
  35. </mapper>

然后是获得mybatis的session的工具类SessionBean.xml:

  1. package tools;
  3. import org.apache.ibatis.io.Resources;
  4. import org.apache.ibatis.session.*;
  6. import java.io.IOException;
  7. import java.io.InputStream;
  9. public class SessionBean {
  10.     private final static SqlSessionFactory sqlSessionFactory;
  11.     static {
  12.         String resource = "config.xml";
  13.         InputStream inputStream=null;
  14.         try {
  15.             inputStream = Resources.getResourceAsStream(resource);
  16.         } catch (IOException e) {
  17.             e.printStackTrace();
  18.         }
  19.         sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  20.     }
  21.     public static SqlSession getSession()
  22.     {
  23.         return sqlSessionFactory.openSession(true);//这里设置成true表示支持事务，就是会更新数据库的意思，mybatis默认不支持事务
  24.     }
  25. }

然后是与数据库相交互的DAO层，UserDao.java:

  1. package dao;
  3. import domain.User;
  4. import org.apache.ibatis.session.SqlSession;
  5. import tools.SessionBean;
  8. public class UserDao {
  9.     private static SqlSession session;
  10.     static {
  11.         session= SessionBean.getSession();
  12.     }
  13.     public static User findUserById(int id)//通过id来查找User
  14.     {
  15.         return session.selectOne("test.findUserById",1);
  16.     }
  17.     public static User findUserByName(String n)//通过name来查找User
  18.     {
  19.         return session.selectOne("test.findUserByName",n);
  20.     }
  21.     public static User checkLogin(String name,String password)
  22.     {
  23.         User user=new User();
  24.         user.setName(name);
  25.         user.setPassword(password);
  26.         return session.selectOne("test.checkLogin",user);
  27.     }
  28.     public static void insertUser(User user)//插入一个User
  29.     {
  30.         session.insert("test.insertUser",user);
  31.     }
  32.     public static void deleteUser(int i)//删除id为i的User
  33.     {
  34.         session.delete("test.deleteUser",i);
  35.     }
  36.     public static void updateUser(User user)//根据id更新User信息
  37.     {
  38.         session.update("test.updateUser",user);
  39.         session.commit();//注意必须要commit
  40.     }
  41. }

写到这里是不是没有用一点SpringMVC的影子呢，没错确实没有，因为他是粘合剂当然是最后加入，继续我们可以写一个测试类来测试目前为止的mybatis的操作有没有错误：

UserDaoTest.java:

  1. package dao;
  3. import domain.User;
  4. import org.junit.Test;
  6. import java.util.List;
  9. public class UserDaoTest {
  10.     @Test//测试单例查找
  11.     public void test_findUserById() throws Exception {
  12.         User user = UserDao.findUserById(1);
  13.         System.out.println("id:" + user.getId() + " name:" + user.getName() + " age:"+user.getAge()+" password:" + user.getPassword());
  14.     }
  15.     @Test//测试通过用户名查找
  16.     public void test_findUserByName()throws Exception
  17.     {
  18.         User u=UserDao.findUserByName("hjy");
  19.         if(u!=null)
  20.         {
  21.             System.out.println("id:" + u.getId() + " name:" + u.getName() + " age:"+u.getAge()+ " password:" + u.getPassword());
  22.         }
  23.     }
  24.     @Test//测试插入操作
  25.     public void  test_insertUser()throws Exception
  26.     {
  27.         User user=new User();
  28.         user.setName("ggboy");
  29.         user.setAge(14);
  30.         user.setPassword("1008611");
  31.         UserDao.insertUser(user);
  32.         User u=UserDao.findUserByName("ggboy");
  33.         if(u!=null)
  34.         {
  35.             System.out.println("id:" + u.getId() + " name:" + u.getName() + " age:"+u.getAge()+ " password:" + u.getPassword());
  36.         }
  37.     }
  38.     @Test//测试删除操作
  39.     public void test_deleteUser()throws Exception
  40.     {
  41.         UserDao.deleteUser(1);
  42.         test_findUserByName();
  43.     }
  44.     @Test//测试更新操作
  45.     public void test_updateUser()throws Exception
  46.     {
  47.         User user=new User();
  48.         user.setId(1);
  49.         user.setName("hjy");
  50.         user.setAge(10);
  51.         user.setPassword("99999");
  52.         UserDao.updateUser(user);
  53.         test_findUserByName();
  54.     }
  55. }

测试结束没有错误就可以开始下一步的操作了，然后就是准备好一系列的页面，我说一下我的分配，首先是登录界面login.jsp，然后是登录失败界面login2.jsp（就是加了一行字而已，从login页面那复制），然后是注册界面regist.jsp，注册失败界面regist2.jsp（也只是加了一行字），success.jsp登录成功界面，会输出欢迎+你的用户名，当然用户名是唯一的。

login.jsp:

  1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  2. <html>
  3. <head>
  4.     <title>login</title>
  5. </head>
  6. <body>
  7.     <form action="login" method="post">
  8.         用户名:<input type="text" name="name"/><br>
  9.         密 码:<input type="password" name="password"/><br>
  10.         <input type="submit" value="登录"><br>
  11.         <a href="regist">注册</a>
  12.     </form>
  13. </body>
  14. </html>

login2.jsp:

  1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  2. <html>
  3. <head>
  4.     <title>login</title>
  5. </head>
  6. <body>
  7. <form action="login" method="post">
  8.     用户名:<input type="text" name="name"/><br>
  9.     密 码:<input type="password" name="password"/><br>
  10.     <input type="submit" value="登录">登录失败，用户名或密码有误<br>
  11.     <a href="regist">注册</a>
  12. </form>
  13. </body>
  14. </html>

regist.jsp:

  1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  2. <html>
  3. <head>
  4.     <title>Regist</title>
  5. </head>
  6. <body>
  7.     <form action="registSuccess" method="post">
  8.         用户名:<input type="text" name="name"/><br>
  9.         密 码:<input type="password" name="password"/><br>
  10.         年 龄:<input type="number" name="age"><br>
  11.         <input type="submit" value="提交"/>
  12.     </form>
  13. </body>
  14. </html>

regist2.jsp:

  1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  2. <html>
  3. <head>
  4.     <title>Regist</title>
  5. </head>
  6. <body>
  7. <form action="registSuccess" method="post">
  8.     用户名:<input type="text" name="name"/><br>
  9.     密 码:<input type="password" name="password"/><br>
  10.     年 龄:<input type="number" name="age"><br>
  11.     <input type="submit" value="提交"/>
  12.     注册失败，用户名已被占用
  13. </form>
  14. </body>
  15. </html>

success.jsp:

  1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  2. <html>
  3. <head>
  4.     <title>Success</title>
  5. </head>
  6. <body>
  7. Success Login!<br>
  8. 欢迎${name};
  9. </body>
  10. </html>

写到这里，jsp页面中是不是有些你没见过的东西和写法呢，这其中就使用了SpringMVC，首先在web.xml中声明一个解析器（我这么认为）和加入mybatis的配置文件，解析器的作用大概就是对jsp页面的参数进行拦截处理，比如写了一个login，但是一般的写法应该是后面加上一个页面地址才对，那么这个解析器就会根据这个参数到相应的springmvc中的controller类中去找到相应的方法然后对此字符串进行解析后返回

然后重点来了，下面是SpringMVC的核心内容，springmvc-servlet.xml，也就是对这个解析器进行解释的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:p="http://www.springframework.org/schema/p"
  5.        xmlns:context="http://www.springframework.org/schema/context"
  6.        xmlns:mvc="http://www.springframework.org/schema/mvc"
  7.        xsi:schemaLocation="
  8.     http://www.springframework.org/schema/beans
  9.     http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
  10.     http://www.springframework.org/schema/context
  11.     http://www.springframework.org/schema/context/spring-context-4.0.xsd
  12.     http://www.springframework.org/schema/mvc
  13.     http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">
  14.     <!--默认的注解映射的支持 -->
  15.     <mvc:annotation-driven/>
  16.     <!--启用自动扫描 -->
  17.     <context:component-scan base-package="controller"/>
  18.     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  19.         <property name="prefix" value="/WEB-INF/jsp/"/>
  20.         <property name="suffix" value=".jsp"/>
  21.     </bean>
  22. </beans>

这个文件的意思就是将拦截到的字符串前面加上个前缀/WEB-INF/JSP/,后面加上.jsp,现在你明白为什么可以那样写参数了吧，是因为会有解析处理的，还有就是扫描controller包中所有的controller类对其进行正确拦截

下面也是很核心的LoginController.java:

  1. package controller;
  3. import dao.UserDao;
  4. import org.springframework.stereotype.Controller;
  5. import org.springframework.ui.Model;
  6. import org.springframework.web.bind.annotation.RequestMapping;
  7. import org.springframework.web.bind.annotation.RequestMethod;
  9. import javax.servlet.http.HttpServletRequest;
  11. @Controller
  12. public class LoginController {
  13.     @RequestMapping(value = "/", method = RequestMethod.GET)//这里表示访问根目录的时候转到login.jsp页面的意思，同样会对该字符串进行路径解析
  14.     public String sayHello() {
  15.         return "login";
  16.     }
  17.     @RequestMapping(value = "login",method = RequestMethod.POST)//这个的意思是拦截到login的字样会加以判断来转移到哪个页面，当然也会加以处理
  18.     public String login(Model model, HttpServletRequest request)
  19.     {
  20.         String name=request.getParameter("name");
  21.         String password=request.getParameter("password");
  22.         if(UserDao.checkLogin(name,password)!=null)
  23.         {
  24.             model.addAttribute("name",name);
  25.             return "success";
  26.         }
  27.         else
  28.         {
  29.             return "login2";
  30.         }
  31.     }
  32. }

然后是RegistController.java:

  1. package controller;
  3. import dao.UserDao;
  4. import domain.User;
  5. import org.springframework.stereotype.Controller;
  6. import org.springframework.ui.Model;
  7. import org.springframework.web.bind.annotation.RequestMapping;
  8. import org.springframework.web.bind.annotation.RequestMethod;
  10. import javax.servlet.http.HttpServletRequest;
  13. @Controller
  14. public class RegistController {
  15.     @RequestMapping(value = "regist",method = RequestMethod.GET)
  16.     public String regist()
  17.     {
  18.         return "regist";
  19.     }
  20.     @RequestMapping(value = "registSuccess",method = RequestMethod.POST)
  21.     public String registSuccess(HttpServletRequest request,Model model)
  22.     {
  23.         String name=request.getParameter("name");
  24.         String password=request.getParameter("password");
  25.         int age=Integer.parseInt(request.getParameter("age"));
  26.         if(UserDao.findUserByName(name)!=null)
  27.         {
  28.             return "regist2";
  29.         }
  30.         else
  31.         {
  32.             User user=new User();
  33.             user.setName(name);
  34.             user.setPassword(password);
  35.             user.setAge(age);
  36.             UserDao.insertUser(user);
  37.             model.addAttribute("name", name);
  38.             return "login";
  39.         }
  40.     }
  41. }

这个类的作用和上面那个差不多，还有一点要说的就是model这个东西，相当于为返回页面添加了一个属性，第一个参数为jsp中你要调用的属性名字，第二个参数为该属性的值，要调用的时候就直接在该页面中用${属性名字}这个样子调用。

还有最后说一下测试的时候，地址栏输入localhost:8080/就可以转到login.jsp页面了，因为这就是SpringMVC解析器的作用，然后再说一个我在写代码过程中的了解的知识：WEB-INF文件tommcat是默认不允许访问的，在web.xml那里设置个welcome标签就可以访问了，当然使用SpringMVC解析也是可以的，这也是其作用之一。

本篇文章希望帮助像我一样被SpringMVC框架困扰的人，写完以后是不是对框架有更了解一些了呢。

发表评论

表情：
评论列表 （有 0 条评论，232人围观）

还没有评论，来说两句吧...

相关阅读

    相关 SpringMVC入门+Mybatis实践demo

    看了几天的SpringMVC，换了很多视频，看了很多博客也不是特别懂，直到看到b站上有人分享出了付费版的极客学院的讲解视频我才大致了解了这个框架，结合一篇博客，花了一天写代码，

    系统管理员系统管理员/ 0 赞/ 233 阅读

    相关 mybatis入门+demo

    先百科一波: MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集

    Bertha 。Bertha 。/ 0 赞/ 316 阅读