基于springmvc+mysql+mybatis实现用户登陆功能

最新推荐文章于 2024-07-06 20:30:42 发布

温酒YXY

最新推荐文章于 2024-07-06 20:30:42 发布

阅读量4.3k

点赞数 9

本文链接：https://blog.csdn.net/qq_16398505/article/details/79547655

版权

最近在学习springmvc框架，每天的学习过程中颇有一些收获，打算写一篇博客记录一下，也希望能帮到同样在学这个的人。

一：Springmvc

1:SpringMVC的组成结构：

（1）前端控制器（DispatcherServlet）：用于接受用户请求；

（2）处理器映射器（HandleMapping）：根据URL去查找处理器，在代码中用Controller来表示处理器的相关代码实现；

（3）处理器（Handle或者Controller）:需要程序员来写处理逻辑；

（4）处理器适配器（HandleAdapter）：把处理器包装成适配器，这样可以支持多种处理器使用；

（5）视图解析器（ViewResovler）:进行视图解析，返回对应的页面；

2：SpringMVC的工作原理：（几个步骤）

（1）用户向前端控制器发送请求，前端控制器转而请求处理器映射器去查找合适的处理器，查找的方式是通过xml配置文件或者注解；

（2）当处理器映射器找到合适的处理器之后，会向前端控制器返回一个执行链；

（3）前端控制器再通过返回的执行链去调用处理器适配器来执行对于的处理器；

（4）处理器执行完会给处理器适配器返回一个ModelAndView，处理器适配器再将这个ModelAndView返回给前端控制器；

（5）前端控制器拿到之后再去请求视图解析器进行解析，视图解析器解析之后再向前端控制器返回View；前端控制器将返回的View进行渲染之后，将结果展现给用户。

二：项目实现

在做这个项目之前请先在电脑里安装好mysql和tomcat，我用的开发工具是IDEA。先来一张整个项目的结构图，对于新手而言能有一张项目结构图帮助理解是顶好的：

在idea里新建一个maven工程（maven工程的创建网上有很多教程，这里不加赘述），工程名称叫做SBlog，因为我这个工程最终是为了实现个人博客，所以不要纠结工程名字。

1：在SBlog/src/main下创建java文件夹，右键Mark Directory as，选择Test Sources root；只有这样才能在java文件夹下创建包。然后在java文件夹下创建example包，在example包下再分别创建controller，dao，pojo，service四个包。在webapp/WEB-INF下创建view文件夹。

在springmvc工程中，每一个包都有不同的作用：

（1）controller包是用来存放前后端控制的java代码；

（2）dao包是用来存放与数据库相关的java代码；

（3）pojo包使用来存放各种been的；

（4）service包是存放与服务器相关的java代码；

（5）view下的.jsp文件是前端页面显示内容的配置文件；

2：修改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.yxy.BLOG</groupId>
  <artifactId>SBlog</artifactId>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>SBlog Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <!-- 项目依赖-->
  <!--定义mevan属性，使用jdk1.8，字符格式UTF-8-->
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <downloadSources>true</downloadSources>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>
  <dependencies>
    <!-- 添加junit4依赖 -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
    <!-- 添加日志相关jar包 -->
      <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>RELEASE</version>
      </dependency>
      <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>RELEASE</version>
      </dependency>
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>1.1.41</version>
    </dependency>
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>1.7.21</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>1.7.21</version>
    </dependency>
    <!-- 添加spring核心依赖 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-oxm</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <!--j2ee相关包，servlet,jsp,jst1-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>4.0.0</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.2</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jstl</artifactId>
      <version>1.1.1</version>
    </dependency>
    <!-- 添加mybatis依赖 -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.4.5</version>
    </dependency>
    <!-- 添加mybatis/spring整合包依赖 -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.0</version>
    </dependency>
    <!-- 添加mysql驱动依赖 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.38</version>
    </dependency>
    <!-- 添加数据库连接池依赖 -->
    <dependency>
      <groupId>commons-dbcp</groupId>
      <artifactId>commons-dbcp</artifactId>
      <version>1.2.2</version>
    </dependency>
    <!-- 映入JSON -->
    <dependency>
      <groupId>org.codehaus.jackson</groupId>
      <artifactId>jackson-mapper-asl</artifactId>
      <version>1.9.13</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.8.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.8.0</version>
    </dependency>
    <!-- 上传组件包 -->
    <dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.3.1</version>
    </dependency>
    <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>2.4</version>
    </dependency>
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-lang3</artifactId>
      <version>3.4</version>
    </dependency>
    <dependency>
      <groupId>commons-codec</groupId>
      <artifactId>commons-codec</artifactId>
      <version>1.9</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjrt</artifactId>
      <version>1.8.6</version>
    </dependency>
  </dependencies>

  <build>
    <finalName>SBlog</finalName>
    <plugins>
      <!--mybatis 逆向工程插件-->
      <plugin>
        <groupId>org.mybatis.generator</groupId>
        <artifactId>mybatis-generator-maven-plugin</artifactId>
        <version>1.3.2</version>
        <configuration>
          <verbose>true</verbose>
          <overwrite>true</overwrite>
        </configuration>
      </plugin>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
          <encoding>UTF-8</encoding>
        </configuration>
      </plugin>
      <!-- 用于防止properties文件中文乱码 -->
      <plugin>
        <artifactId>maven-resources-plugin</artifactId>
        <version>2.6</version>
        <configuration>
          <encoding>ISO-8859-1</encoding>
          <!--<encoding>UTF-8</encoding>-->
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

引入之后会自动开始下载。

3：在mysql里创建user表和usertwo表，然后插入几条数据

4:在pojo包下新建User.java和Usertwo.java文件。注意这里这两个文件的名称最好与你所要查询的数据库表的名称相统一，结构上会更加清晰。

package example.pojo;

public class User {

    //获取登陆账号密码的been；
    private String username;
    private String password;

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

}

package example.pojo;

public class Usertwo {
    private Integer id;
    private String name;
    private String address;

    public Usertwo(){}

    public Usertwo(Integer id, String name, String address) {
        this.id = id;
        this.name = name;
        this.address = address;
    }

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

5：在dao包下建立访问底层数据的接口UserDao

package example.dao;
import example.pojo.User;
import example.pojo.Usertwo;
import java.util.List;

public interface UserDao {
    List<Usertwo> getAllUsers();
    //这里以接口形式定义了数据库操作方法,我们只需在Mybatis映射文件中对其进行映射就可以直接使用
    public User selectByName(String username);
}

6：配置mysql数据库的连接信息，以便于可以找到本地的数据库位置；

在mybatis目录下新建mysql.properties文件：

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/数据库的名称
username=root
password=root

7：配置与UserDao对应的Mapper.xml文件，新建文件mybatis/mapping/UserDaoMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

        <!--命名空间是对应接口的包名+类名,指定要映射的接口 -->
<mapper namespace="example.dao.UserDao">
    <!--id是接口中的方法名，结果类型如没有在mybatis.xml文件中配置别名，则必须使用全名称（包名+类名） -->
    <select id="getAllUsers" resultType="Usertwo">
        select id,`name`,address from usertwo
    </select>

    <!--select表示查询,它的id名称必须与DAO层接口的方法名相同,否则无法绑定-->
    <select id="selectByName" parameterType="string" resultType="User">
        select * from user where username = #{username}
    </select>
</mapper>

8：在resources下创建mybatis包，然后新建mybatis.xml文件，用了实现Mybatis与mysql的连接

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<typeAliases>
        <package name="example.pojo"/>
    </typeAliases>
</configuration>

9：配置log4j文件，用于在本地输出日志，新建文件resources/log4j.properties

#定义LOG输出级别
log4j.rootLogger=INFO,Console,File
#定义日志输出目的地为控制台
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.Target=System.out
#可以灵活地指定日志输出格式，下面一行是指定具体的格式
log4j.appender.Console.layout = org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=[%c] - %m%n

#文件大小到达指定尺寸的时候产生一个新的文件
log4j.appender.File = org.apache.log4j.RollingFileAppender
#指定输出目录
log4j.appender.File.File = F:/Java Bian Chen/log/log.log
#定义文件最大大小
log4j.appender.File.MaxFileSize = 10MB
#输出所以日志，如果换成DEBUG表示输出DEBUG以上级别日志
log4j.appender.File.Threshold = ALL
log4j.appender.File.layout = org.apache.log4j.PatternLayout
log4j.appender.File.layout.ConversionPattern =[%p] [%d{yyyy-MM-dd HH\:mm\:ss}][%c]%m%n

10：实现spring和mybatis的配置，在resources下新建spring包，在spring目录下新建spring-mybatis.xml文件；

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
                      xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
           http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <!-- 引入mysql jdbc配置文件 -->
    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>classpath:mybatis/mysql.properties</value>
                <!--要是有多个配置文件，只需在这里继续添加即可 -->
            </list>
        </property>
    </bean>
    <!-- 配置mysql数据源 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <!-- 使用properties来配置 -->
        <property name="driverClassName">
            <value>${driver}</value>
        </property>
        <property name="url">
            <value>${url}</value>
        </property>
        <property name="username">
            <value>${username}</value>
        </property>
        <property name="password">
            <value>${password}</value>
        </property>
    </bean>
    <!-- 自动扫描了所有的XxxxMapper.xml对应的mapper接口文件，这样就不用一个一个手动配置Mpper的映射了，只要Mapper接口类和Mapper映射文件对应起来就可以了。 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="example.dao.*" />
    </bean>
    <!-- 配置Mybatis的文件 ，mapperLocations配置**Mapper.xml文件位置，configLocation配置mybatis-config文件位置-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="mapperLocations" value="classpath:mybatis/mapping/UserDaoMapper.xml"/>
        <property name="configLocation" value="classpath:mybatis/mybatis.xml" />
    </bean>
    <!-- 自动扫描注解的bean -->
    <context:component-scan base-package="example.*" />
    <bean id="userDao" class="org.mybatis.spring.mapper.MapperFactoryBean">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
        <property name="mapperInterface" value="example.dao.UserDao"></property>
    </bean>
</beans>

11:配置springmvc文件，在spring目录下新建spring-mvc.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:mvc="http://www.springframework.org/schema/mvc"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
                         http://www.springframework.org/schema/context
                        http://www.springframework.org/schema/context/spring-context-3.2.xsd
                        http://www.springframework.org/schema/mvc
                        http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!--本文件相当于-->
<!--启用spring的注解annotation -->
<context:annotation-config/>

<!-- 自动扫描该包，使SpringMVC认为包下用了@controller注解的类是控制器 -->
<context:component-scan base-package="example.controller ">
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

<!-- 配置注解驱动 可以将request参数与绑定到controller参数上 -->
<mvc:annotation-driven/>

<!-- 添加视图解析器前后缀，这里默认使用.jsp文件-->
<bean id="defaultViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
    <property name="prefix" value="/WEB-INF/view/"/><!--设置JSP文件的目录位置-->
    <property name="suffix" value=".jsp"/>
</bean>
</beans>

12：配置大管家web.xml文件；

<?xml version="1.0" encoding="UTF-8"?>
<web-app 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_3_0.xsd"
         version="3.0">
  <!--welcome pages-->
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
  <!-- 读取spring配置文件 -->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring/spring-mybatis.xml</param-value>
  </context-param>
  <!--解决乱码问题-->
  <filter>
    <filter-name>characterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
      <param-name>forceEncoding</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  <!-- 日志记录 -->
  <context-param>
    <!-- 日志配置文件路径 -->
    <param-name>log4jConfigLocation</param-name>
    <param-value>classpath:log4j.properties</param-value>
  </context-param>
 <!--spring上下文监听器，如果没有-->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!--配置springmvc DispatcherServlet,转发前端或后台发来的请求-->
  <servlet>
    <servlet-name>springMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <!--resources目录下需要新建一个spring文件夹-->
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:spring/spring-mvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
    <async-supported>true</async-supported>
  </servlet>
  <servlet-mapping>
    <servlet-name>springMVC</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

13：接下来就是编辑页面的显示内容了，这需要在.jsp文件里进行操作；

（1）首先更改index.jsp文件的内容，它是工程默认的登陆页面；

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    String path = request.getContextPath();
    String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<html>
<head>
    <title></title>
</head>
<body>
<br>
<br>
<br>
<br>
<br>
<form name="form1" action="/user/login" method="post" >
    <table width="300" border="1" align="center">
        <tr>
            <td colspan="2">登入窗口</td>
        </tr>
        <tr>
            <td>用户名:</td>
            <td><input type="text" name="username">
            </td>
        </tr>
        <tr>
            <td>密码:</td>
            <td><input type="password" name="password"/>
            </td>
        </tr>
        <tr>
            <td colspan="2">
                <input type="submit" name="submit" value="登录"/>
            </td>


        </tr>
    </table>
</form>
</body>
</html>

（2）在WEB-INF/view/目录下添加文件page1.jsp展示从数据库获取的usertwo数据信息；

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<html>
<head>
</head>
<body>
<h1>Hello world!</h1>
${user.id}
${user.name}
</body>
</html>

（3）在WEB-INF/view/目录下添加文件dlcg.jsp和dlsb.jsp文件，这两个文件对应登陆成功和登录失败两个界面；

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    String path = request.getContextPath();
    String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<html>
<head>
    <title></title>
</head>
<body>

登入成功!
<br>
您好!${user.username}
<br>
<a href="/index.jsp" rel="external nofollow" >返回</a>
</body>
</html>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    String path = request.getContextPath();
    String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<html>
<head>
    <title></title>
</head>
<body>
登入失败!
${message}
<br>
<a href="<%=path%>/index.jsp" rel="external nofollow" >返回</a>
</body>
</html>

14：然后是控制层的代码编写，这里面要实现我们从前端获取输入信息与数据库比对已经从数据库获取信息并显示在前端的方法；在controller包下新建UserController.java

package example.controller;
import example.pojo.User;
import example.pojo.Usertwo;
import example.service.UserService;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.List;

//@Controller注解用于标示本类为web层控制组件
@Controller
//@RequestMapping("/user")用于标定访问时对url位置
@RequestMapping("/user")
//在默认情况下springmvc的实例都是单例模式,所以使用scope域将其注解为每次都创建一个新的实例
@Scope("prototype")
public class UserController {
    private static final Logger logger = Logger.getLogger(UserController.class);
    @Resource
    private UserService service;
    /**
     *返回user对象信息给page1.jsp处理，然后在前端页面展示
     */
     @RequestMapping("/page")
    public ModelAndView getUser() {
        System.out.println("访问page1的后台。。。");
        ModelAndView mav = new ModelAndView("page1");
        List<Usertwo> users = service.getAllUser();
        System.out.println(users);
        mav.addObject("user", users.get(0));
        return mav;
//        return "page1"; //跳转到.jsp结尾的对应文件（page1.jsp）,此时返回值是String
    }
    /**
     * 直接返回字符串给请求的页面（这里在请求URL增加参数v是验证前后台通信是否正常）
     * @param request
     * @param response
     * @return
     */

    @RequestMapping(value = "/sql", produces = "text/html;charset=UTF-8")
    @ResponseBody
    public String sayHi(HttpServletRequest request, HttpServletResponse response) {
        String name = request.getParameter("v");
        List<Usertwo> users = service.getAllUser();
        logger.info("{name:yxy,context:hi,你好}");
        return name+"-{name:yxy,context:hi,你好}"+users;
    }
        //自动注入业务层的userService类
        @Autowired
        UserService userService;
        //login业务的访问位置为/user/login
        @RequestMapping("/login")
        public String login(User user,HttpServletRequest request){
            //调用login方法来验证是否是注册用户
            boolean loginType = userService.login(user.getUsername(),user.getPassword());
            if(loginType){
                //如果验证通过,则将用户信息传到前台
                request.setAttribute("user",user);
                //并跳转到success.jsp页面
                return "dlcg";
            }else{
                //若不对,则将错误信息显示到错误页面
                request.setAttribute("message","用户名密码错误");
                return "dlsb";
            }
        }
}

15：最后是服务层的代码编写，在service包下分别创建UserService和UserServiceImpl文件；

package example.service;
import example.pojo.User;
import example.pojo.Usertwo;
import java.util.List;

public interface UserService {
    List<Usertwo> getAllUser();
    public boolean login(String username, String password);
}

这里定义了一个UserService接口，里面需要实现两个方法来获取数据库的信息；

package example.service;
import example.dao.UserDao;
import example.pojo.User;
import example.pojo.Usertwo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.List;

@Service("userServiceImpl")
@Scope("prototype")
public class UserServiceImpl implements UserService {
    @Resource
    private UserDao userDao;
    @Override
    public List<Usertwo> getAllUser() {
        return userDao.getAllUsers();
    }
    //下面是实现登陆的服务层代码；
    //自动注入iuserdao 用于访问数据库
    @Autowired
    UserDao Mapper;
    //登录方法的实现,从jsp页面获取username与password
    public boolean login(String username, String password) {
        User user = Mapper.selectByName(username);
        if (user != null) {
            if (user.getUsername().equals(username) && user.getPassword().equals(password))
                return true;
        }
        return false;
    }
}

至此，代码工作就完成了，下面是测试的方法以及测试的结果展示；

三：测试方法与结果

使用Tomcat9作为服务器，将WEB工程发布到Tomcat上并进行测试。

服务器启动进入登陆界面：

输入用户名为：yxy，密码为：123456，点击登陆跳转页面到

当输入用户名和密码与数据库总保存的不一致时，页面跳转到

当输入地址:http://localhost:8080/user/sql后，会调取数据库中usertwo表的数据并显示到页面；

四：总结

本文介绍的主要是springmvc框架的搭建以及和mysql数据库的连接调用方法，也是在这段时间开始学习框架以来的一次总结。网上类似讲解springmvc的文章有很多，而且我在代码里该标注的地方也标注出来了，所以文中讲解的东西并不多。在配置的过程中学习到了很多东西，这些东西只有当自己亲手去搭建时才能领会。希望能帮到一些和我一样的初学者更快的掌握这个框架，实现想要实现的功能。