SpringMVC+Spring+JDBC

最新推荐文章于 2021-10-13 10:51:16 发布

原创最新推荐文章于 2021-10-13 10:51:16 发布 · 767 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#spring #mysql #java

Spring+SpringMVC+JDBC 专栏收录该内容

1 篇文章

订阅专栏

本文介绍如何使用SpringMVC框架实现用户登录和注销功能，包括项目搭建、依赖添加、实体类创建、数据访问层及业务逻辑层设计、控制器类编写与配置文件设置，同时涵盖全局异常处理。

一.项目需求

1.使用Spring+SpringMVC+JDBC实现用户的登录和注销操作，并添加全局的异常处理。

二.解决思路

2.1.创建工程，添加项目的依赖。

2.2.创建用户实体类。

2.3.创建数据访问层接口以及实现类。‘

2.4.创建业务逻辑层的接口以及实现类。

2.5.创建控制器类，用来接收请求和处理请求。

2.6.配置Spring，SpringMVC以及Web.xml核心配置文件，并在Web.xml文件中加载Spring和SpringMVC的核心配置文件。

项目依赖下载地址：

链接：https://pan.baidu.com/s/1LTQG2jzIi4XGuPV2doiuxg
提取码：cg0n

三.实现步骤

3.1.创建工程，添加依赖

3.2创建用户实体类

代码如下：

package com.atguigu.springmvc.pojo;

/**
 * @author sd
 * @date 2020-07-21 20:14
 */
public class User {
    private Integer id;
    private String namess;
    private String passwords;

    public Integer getId() {
        return id;
    }

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

    public String getNamess() {
        return namess;
    }

    public void setNamess(String namess) {
        this.namess = namess;
    }

    public String getPasswords() {
        return passwords;
    }

    public void setPasswords(String passwords) {
        this.passwords = passwords;
    }
}

3.3创建数据访问层接口，和实现类

自定义工具类定义获取数据库连接以及关闭有关对象的方法

package com.atguigu.springmvc.utils;

import java.sql.*;

/**
 * @author sd
 * @date 2020-07-21 20:05
 */
public class Conn {
    private static Connection connection;
    static {
        try {
            Class.forName("com.mysql.jdbc.Driver");
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis_01", "root", "root");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /*
    * 获取数据库的连接对象
    * */
    public static Connection getConnection(){
        return connection;
    }
    /*
    * 关闭数据库资源
    * */
    public static void closeConnection(Connection conn, ResultSet resultSet, Statement statement){
        if (conn!=null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (resultSet!=null){
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (statement!=null){
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

}

数据访问层的接口：

package com.atguigu.springmvc.dao;

import com.atguigu.springmvc.pojo.User;

/**
 * @author sd
 * @date 2020-07-21 20:19
 */
public interface UserDao {
//    根据用户的名称和密码来进行登录
    public User queryByUserNameAndPassword(String username,String password);
}

数据访问层的实现类:

package com.atguigu.springmvc.dao.Impl;

import com.atguigu.springmvc.dao.UserDao;
import com.atguigu.springmvc.pojo.User;
import com.atguigu.springmvc.utils.Conn;
import org.springframework.stereotype.Repository;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;

/**
 * @author sd
 * @date 2020-07-21 20:21
 */
@Repository
public class UserDaoImpl implements UserDao {
    private Connection connection;
    private ResultSet resultSet;
    private Statement statement;
    @Override
    public User queryByUserNameAndPassword(String username, String password) {
//        创建实体对象
        User user=null;
//        获取数据库连接
        connection= Conn.getConnection();
//        编写Sql语句
        String sql="select * from user where namess='"+username +"'and passwords='"+password+"'";
        try {
            statement=connection.createStatement();
            resultSet=statement.executeQuery(sql);
            if (resultSet != null){
                while (resultSet.next()){
                    user=new User();
                    user.setNamess((String) resultSet.getObject("namess"));
                    user.setPasswords((String)resultSet.getObject("passwords"));
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
//        关闭数据库连接
//        Conn.closeConnection(connection,resultSet,statement);
        return user;
    }
}

数据库访问对象类的测试：

package com.atguigu.springmvc.test;

import com.atguigu.springmvc.utils.Conn;
import org.junit.Test;

import java.sql.Connection;

/**
 * @author sd
 * @date 2020-07-21 20:12
 */
public class TestConnection {
    @Test
    public void test1(){
        Connection connection = Conn.getConnection();
        System.out.println(connection);
        Conn.closeConnection(connection,null,null);
    }
}

数据访问层实现类的测试：

package com.atguigu.springmvc.test;

import com.atguigu.springmvc.dao.Impl.UserDaoImpl;
import com.atguigu.springmvc.dao.UserDao;
import com.atguigu.springmvc.pojo.User;
import com.atguigu.springmvc.utils.Conn;
import org.junit.Test;

/**
 * @author sd
 * @date 2020-07-21 20:30
 */
public class TestUserDaoImpl {
    @Test
    public void test1(){
        UserDao userDao=new UserDaoImpl();
        User user = userDao.queryByUserNameAndPassword("admin", "ly@168");
        System.out.println(user.getNamess()+user.getPasswords());
//        关系数据库连接

    }
}

3.4业务逻辑层的接口以及实现类

接口：

package com.atguigu.springmvc.service;

import com.atguigu.springmvc.pojo.User;

/**
 * @author sd
 * @date 2020-07-21 20:43
 */
public interface UserService {
//    /    根据用户的名称和密码来进行登录
    public User queryByUserNameAndPassword(String username, String password);
}

业务逻辑层的实现类：

package com.atguigu.springmvc.service.Impl;

import com.atguigu.springmvc.dao.UserDao;
import com.atguigu.springmvc.pojo.User;
import com.atguigu.springmvc.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
 * @author sd
 * @date 2020-07-21 20:43
 */
@Service
public class UserServiceImpl implements UserService {

//    创建依赖层的对象
    @Autowired
    private UserDao userDao;

    public UserDao getUserDao() {
        return userDao;
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public User queryByUserNameAndPassword(String username, String password) {
        return userDao.queryByUserNameAndPassword(username,password);
    }
}

3.5.控制器类的实现

代码实现：

package com.atguigu.springmvc.controller;

import com.atguigu.springmvc.pojo.User;
import com.atguigu.springmvc.service.UserService;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

/**
 * @author sd
 * @date 2020-07-21 20:15
 */
@Controller
@RequestMapping("/user")
public class UserController {

    @Resource
    UserService userService=null;
    @RequestMapping("/login")
    public String login(String username, String password, HttpServletRequest request){
        User user = userService.queryByUserNameAndPassword(username, password);
        if (user == null){
            request.setAttribute("errors","用户名或者密码错误!!!");
            return "logins";
        }else {
            HttpSession session = request.getSession();
            session.setAttribute("currentUser",user);
            return "success";
        }
    }

    /*
    * 用户的注销操作
    * */
    @RequestMapping("/clear")
    public String clear(HttpServletRequest request){
        request.getSession().invalidate();
        return "logins";
    }
}

3.6.配置文件的配置

Spring配置文件的配置：

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--扫描数据访问层的注解-->
    <context:component-scan base-package="com.atguigu.springmvc.dao"/>
    <!--配置自动扫描业务逻辑层的注解-->
    <context:component-scan base-package="com.atguigu.springmvc.service"/>

</beans>

SpringMVC的配置：

<?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:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--配置静态资源的访问-->
    <!--配置SpringMVC的前端控制器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--补充mvc的配置-->
    <mvc:annotation-driven/>

    <!--开启自动扫描指定包下面的注解-->
    <context:component-scan base-package="com.atguigu.springmvc.controller"/>
    <!--配置全局异常处理-->
    <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
        <property name="exceptionMappings">
            <props>
                <prop key="java.lang.RuntimeException">
                    error
                </prop>
            </props>
        </property>
    </bean>

</beans>

Web.xml的配置：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">


    <!--加载Spring的配置文件-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applictionContext.xml</param-value>
    </context-param>

    <!--配置监听器-->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!--配置过滤器-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--配置初始化参数加载SpringMVC的配置文件-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springMVCContext.xml</param-value>
        </init-param>
    </servlet>

    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    
    <!--访问静态资源-->
    <servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>*.jpg</url-pattern>
    </servlet-mapping>

</web-app>