线上实训Day0N（用ssm实现登录、注册、删除、查询功能

最新推荐文章于 2022-09-01 22:39:45 发布
最新推荐文章于 2022-09-01 22:39:45 发布
阅读量270 收藏 2
点赞数
文章标签： ssm java mysql java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hoyiii/article/details/107287149
版权

在这里插入图片描述

这就是个目录标题

抱头

前言

好久不见，这博客没写肯定不是我偷懒。
这次带来的是用ssm实现登录、注册、删除、查询功能。
（u1s1偷懒挺爽哒）

准备

1.通过Maven来下载我们所需要的jar包。

Maven里有各种各样我们所需要的jar包，只要联网他就会自动下载我们所需要的jar包
在这里插入图片描述
新建项目时候如是选择后无脑Next到这一步
在这里插入图片描述
和上图一样设置后再点击右边加号添加
在这里插入图片描述
然后就是愉快的无脑Next了

下面这是setting.xml文件的内容

setting.xml文件

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

<!--
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License.  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
-->

<!--
 | This is the configuration file for Maven. It can be specified at two levels:
 |
 |  1. User Level. This settings.xml file provides configuration for a single user,
 |                 and is normally provided in ${user.home}/.m2/settings.xml.
 |
 |                 NOTE: This location can be overridden with the CLI option:
 |
 |                 -s /path/to/user/settings.xml
 |
 |  2. Global Level. This settings.xml file provides configuration for all Maven
 |                 users on a machine (assuming they're all using the same Maven
 |                 installation). It's normally provided in
 |                 ${maven.home}/conf/settings.xml.
 |
 |                 NOTE: This location can be overridden with the CLI option:
 |
 |                 -gs /path/to/global/settings.xml
 |
 | The sections in this sample file are intended to give you a running start at
 | getting the most out of your Maven installation. Where appropriate, the default
 | values (values used when the setting is not specified) are provided.
 |
 |-->
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
  <!-- localRepository
   | The path to the local repository maven will use to store artifacts.
   |
   | Default: ${user.home}/.m2/repository
  <localRepository>/path/to/local/repo</localRepository>
  -->

  <!-- interactiveMode
   | This will determine whether maven prompts you when it needs input. If set to false,
   | maven will use a sensible default value, perhaps based on some other setting, for
   | the parameter in question.
   |
   | Default: true
  <interactiveMode>true</interactiveMode>
  -->

  <!-- offline
   | Determines whether maven should attempt to connect to the network when executing a build.
   | This will have an effect on artifact downloads, artifact deployment, and others.
   |
   | Default: false
  <offline>false</offline>
  -->

  <!-- pluginGroups
   | This is a list of additional group identifiers that will be searched when resolving plugins by their prefix, i.e.
   | when invoking a command line like "mvn prefix:goal". Maven will automatically add the group identifiers
   | "org.apache.maven.plugins" and "org.codehaus.mojo" if these are not already contained in the list.
   |-->
  <pluginGroups>
    <!-- pluginGroup
     | Specifies a further group identifier to use for plugin lookup.
    <pluginGroup>com.your.plugins</pluginGroup>
    -->
  </pluginGroups>

  <!-- proxies
   | This is a list of proxies which can be used on this machine to connect to the network.
   | Unless otherwise specified (by system property or command-line switch), the first proxy
   | specification in this list marked as active will be used.
   |-->
  <proxies>
    <!-- proxy
     | Specification for one proxy, to be used in connecting to the network.
     |
    <proxy>
      <id>optional</id>
      <active>true</active>
      <protocol>http</protocol>
      <username>proxyuser</username>
      <password>proxypass</password>
      <host>proxy.host.net</host>
      <port>80</port>
      <nonProxyHosts>local.net|some.host.com</nonProxyHosts>
    </proxy>
    -->
  </proxies>

  <!-- servers
   | This is a list of authentication profiles, keyed by the server-id used within the system.
   | Authentication profiles can be used whenever maven must make a connection to a remote server.
   |-->
  <servers>
    <!-- server
     | Specifies the authentication information to use when connecting to a particular server, identified by
     | a unique name within the system (referred to by the 'id' attribute below).
     |
     | NOTE: You should either specify username/password OR privateKey/passphrase, since these pairings are
     |       used together.
     |
    <server>
      <id>deploymentRepo</id>
      <username>repouser</username>
      <password>repopwd</password>
    </server>
    -->

    <!-- Another sample, using keys to authenticate.
    <server>
      <id>siteServer</id>
      <privateKey>/path/to/private/key</privateKey>
      <passphrase>optional; leave empty if not used.</passphrase>
    </server>
    -->
  </servers>

  <!-- mirrors
   | This is a list of mirrors to be used in downloading artifacts from remote repositories.
   |
   | It works like this: a POM may declare a repository to use in resolving certain artifacts.
   | However, this repository may have problems with heavy traffic at times, so people have mirrored
   | it to several places.
   |
   | That repository definition will have a unique id, so we can create a mirror reference for that
   | repository, to be used as an alternate download site. The mirror site will be the preferred
   | server for that repository.
   |-->
  <mirrors>

  	<mirror>
      <id>alimaven</id>
      <name>aliyun maven</name>
      <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
      <mirrorOf>central</mirrorOf>
    </mirror>
    <!-- mirror
     | Specifies a repository mirror site to use instead of a given repository. The repository that
     | this mirror serves has an ID that matches the mirrorOf element of this mirror. IDs are used
     | for inheritance and direct lookup purposes, and must be unique across the set of mirrors.
     |
    <mirror>
      <id>mirrorId</id>
      <mirrorOf>repositoryId</mirrorOf>
      <name>Human Readable Name for this Mirror.</name>
      <url>http://my.repository.com/repo/path</url>
    </mirror>
     -->
  </mirrors>

  <!-- profiles
   | This is a list of profiles which can be activated in a variety of ways, and which can modify
   | the build process. Profiles provided in the settings.xml are intended to provide local machine-
   | specific paths and repository locations which allow the build to work in the local environment.
   |
   | For example, if you have an integration testing plugin - like cactus - that needs to know where
   | your Tomcat instance is installed, you can provide a variable here such that the variable is
   | dereferenced during the build process to configure the cactus plugin.
   |
   | As noted above, profiles can be activated in a variety of ways. One way - the activeProfiles
   | section of this document (settings.xml) - will be discussed later. Another way essentially
   | relies on the detection of a system property, either matching a particular value for the property,
   | or merely testing its existence. Profiles can also be activated by JDK version prefix, where a
   | value of '1.4' might activate a profile when the build is executed on a JDK version of '1.4.2_07'.
   | Finally, the list of active profiles can be specified directly from the command line.
   |
   | NOTE: For profiles defined in the settings.xml, you are restricted to specifying only artifact
   |       repositories, plugin repositories, and free-form properties to be used as configuration
   |       variables for plugins in the POM.
   |
   |-->
  <profiles>
    <!-- profile
     | Specifies a set of introductions to the build process, to be activated using one or more of the
     | mechanisms described above. For inheritance purposes, and to activate profiles via <activatedProfiles/>
     | or the command line, profiles have to have an ID that is unique.
     |
     | An encouraged best practice for profile identification is to use a consistent naming convention
     | for profiles, such as 'env-dev', 'env-test', 'env-production', 'user-jdcasey', 'user-brett', etc.
     | This will make it more intuitive to understand what the set of introduced profiles is attempting
     | to accomplish, particularly when you only have a list of profile id's for debug.
     |
     | This profile example uses the JDK version to trigger activation, and provides a JDK-specific repo.
    <profile>
      <id>jdk-1.4</id>

      <activation>
        <jdk>1.4</jdk>
      </activation>

      <repositories>
        <repository>
          <id>jdk14</id>
          <name>Repository for JDK 1.4 builds</name>
          <url>http://www.myhost.com/maven/jdk14</url>
          <layout>default</layout>
          <snapshotPolicy>always</snapshotPolicy>
        </repository>
      </repositories>
    </profile>
    -->

    <!--
     | Here is another profile, activated by the system property 'target-env' with a value of 'dev',
     | which provides a specific path to the Tomcat instance. To use this, your plugin configuration
     | might hypothetically look like:
     |
     | ...
     | <plugin>
     |   <groupId>org.myco.myplugins</groupId>
     |   <artifactId>myplugin</artifactId>
     |
     |   <configuration>
     |     <tomcatLocation>${tomcatPath}</tomcatLocation>
     |   </configuration>
     | </plugin>
     | ...
     |
     | NOTE: If you just wanted to inject this configuration whenever someone set 'target-env' to
     |       anything, you could just leave off the <value/> inside the activation-property.
     |
    <profile>
      <id>env-dev</id>

      <activation>
        <property>
          <name>target-env</name>
          <value>dev</value>
        </property>
      </activation>

      <properties>
        <tomcatPath>/path/to/tomcat/instance</tomcatPath>
      </properties>
    </profile>
    -->
  </profiles>

  <!-- activeProfiles
   | List of profiles that are active for all builds.
   |
  <activeProfiles>
    <activeProfile>alwaysActiveProfile</activeProfile>
    <activeProfile>anotherAlwaysActiveProfile</activeProfile>
  </activeProfiles>
  -->
</settings>

刚刚新建好的时候 Idea下面会读条，这是它在联网下载Jar包，等等就行。

然后再pom.xml文件里写入依赖 下面是pom.xml的内容

pom.xml的内容

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

<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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.Day05</groupId>
  <artifactId>testssm</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>testssm Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <!-- spring版本号 -->
    <spring.version>5.0.2.RELEASE</spring.version>
    <!-- mybatis版本号 -->
    <mybatis.version>3.2.6</mybatis.version>
    <!-- log4j日志文件管理包版本 -->
    <slf4j.version>1.7.7</slf4j.version>
    <log4j.version>1.2.17</log4j.version>
    <c3p0.version>0.9.5.2</c3p0.version>
    <taglibs.version>1.1.2</taglibs.version>
  </properties>

  <dependencies>
    <!-- spring核心包 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-oxm</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!-- mybatis核心包 -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>${mybatis.version}</version>
    </dependency>
    <!-- mybatis/spring包 -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.2.2</version>
    </dependency>
    <!-- 导入java ee jar 包 -->
    <dependency>
      <groupId>javax</groupId>
      <artifactId>javaee-api</artifactId>
      <version>7.0</version>
    </dependency>

    <!-- 导入Mysql数据库链接jar包 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.30</version>
    </dependency>
    <!-- 导入dbcp的jar包，用来在applicationContext.xml中配置数据库 -->
    <dependency>
      <groupId>commons-dbcp</groupId>
      <artifactId>commons-dbcp</artifactId>
      <version>1.2.2</version>
    </dependency>
    <!-- JSTL标签类 -->
    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
    <!-- 日志文件管理包 -->
    <!-- log start -->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>${log4j.version}</version>
    </dependency>


    <!-- 数据连接池 -->
    <dependency>
      <groupId>com.mchange</groupId>
      <artifactId>c3p0</artifactId>
      <version>${c3p0.version}</version>
    </dependency>

    <dependency>
      <groupId>taglibs</groupId>
      <artifactId>standard</artifactId>
      <version>${taglibs.version}</version>
    </dependency>

    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>${slf4j.version}</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>${slf4j.version}</version>
    </dependency>

    <!-- 导入servlet-api/jsp -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>
    <!-- https://mvnrepository.com/artifact/javax.servlet.jsp/javax.servlet.jsp-api -->
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>javax.servlet.jsp-api</artifactId>
      <version>2.3.1</version>
      <scope>provided</scope>
    </dependency>

  </dependencies>

  <build>
    <finalName>testssm</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

然后再resource文件目录下面添加3个配置文件

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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
		http://www.springframework.org/schema/context
		http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://www.springframework.org/schema/aop
		http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
		http://www.springframework.org/schema/tx
		http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">
    <!-- 1.配置数据库相关参数properties的属性：${url} -->
    <context:property-placeholder location="classpath:db.properties"/>
    <!-- 2.配置数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="maxPoolSize" value="30"/>
        <property name="minPoolSize" value="2"/>
    </bean>

    <!-- 3.配置SqlSessionFactory对象 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 注入数据库连接池 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 扫描bean包 使用别名 -->
        <property name="typeAliasesPackage" value="com.Day05.bean"></property>

        <!--配置加载映射文件 UserMapper.xml-->
        <property name="mapperLocations" value="classpath:mapper/*.xml"/>

    </bean>

    <!-- 自动生成dao,mapper-->
    <!-- 4.配置扫描Dao接口包，动态实现Dao接口，注入到spring容器中 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 给出需要扫描Dao接口包 -->
        <property name="basePackage" value="com.Day05.dao"/>
        <!-- 注入sqlSessionFactory -->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    </bean>



    <!--自动扫描-->
    <context:component-scan base-package="com.Day05"/>


    <!-- 配置事务-->
    <!-- 5.配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!-- 6.开启事务注解-->
    <tx:annotation-driven></tx:annotation-driven>

</beans>

db.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/testtt?useSSL=true&characterEncoding=utf-8
jdbc.username=root
jdbc.password=123456

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

    <!-- 1.注解扫描位置-->
    <context:component-scan base-package="com.Day05.controller " />

    <!-- 2.配置映射处理和适配器-->
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"/>

    <!-- 3.视图的解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/pages/" />
        <property name="suffix" value=".jsp" />
    </bean>
</beans>

在resource下新建mapper package
里面有个UserMapper.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="com.Day05.dao.UserDao">

    <select id="findUserByName" parameterType="String" resultType="user">
        select * from user where name =#{name}
    </select>

    <delete id="deleteById" parameterType="Integer">
        delete * from user where id =#{id}
    </delete>

    <insert id="add" parameterType="user">
        insert into user (name ,password) values (#{name},#{password})
    </insert>

    <select id="findAll" parameterType="String" resultType="user">
        select * from user
    </select>

    <select id="findUserById" parameterType="Integer" resultType="User">
        select * from user where id=#{id}
    </select>

    <update id="update" parameterType="User">
        update user set name =#{name},password=#{password} where id=#{id}
    </update>

    <select id="searchByName" parameterType="String" resultType="User">
        select * from user where name like concat('%',#{name },'%')
    </select>

</mapper>

User实体类

package com.Day05.bean;

public class User {

    private int id;
    private String name;
    private String password;

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

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

web.xml

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

  <!-- 配置加载类路径的配置文件 -->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath*:applicationContext.xml</param-value>
  </context-param>

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

  <!-- 解决中文乱码过滤器 -->
  <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>
  </filter>
  <filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

  <!-- 前端控制器（加载classpath:spring-mvc.xml 服务器启动创建servlet） -->
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 配置初始化参数，创建完DispatcherServlet对象，加载springmvc.xml配置文件 -->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:spring-mvc.xml</param-value>
    </init-param>
    <!-- 服务器启动的时候，让DispatcherServlet对象创建 -->
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>

  <filter>
    <filter-name>loginFilter</filter-name>
    <filter-class>com.Day05.filter.LoginFilter</filter-class>
  </filter>  
  <filter-mapping>
    <filter-name>loginFilter</filter-name>
    <url-pattern>*.do</url-pattern>
  </filter-mapping>
</web-app>

实现流程

在这里插入图片描述
大概就是上面这个流程

功能的实现

UserServiceImpl

package com.Day05.service.Impl;

import com.Day05.bean.User;
import com.Day05.dao.UserDao;
import com.Day05.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Override
    public boolean login(String name, String password){
        User user = userDao.findUserByName(name);
        System.out.println(1);
        if(user != null && user.getPassword().equals(password)){
            return true;
        }
        return false;
    }

    @Override
    public boolean delete(Integer id) {
        int del=userDao.deleteById(id);
        if(del>0){
            return true;
        }
        return false;
    }

    @Override
    public List<User> findAll() {
        return userDao.findAll();
    }

    @Override
    public boolean add(User user) {
        int ad=userDao.add(user);
        if(ad>0){
            return true;
        }
        return false;
    }

    @Override
    public User findById(Integer id) {
        return userDao.findUserById(id);
    }

    @Override
    public boolean update(User user) {
        int upd=userDao.update(user);
        if (upd>0){
            return true;
        }
        return false;
    }

    @Override
    public List<User> searchByName(String name) {
        return userDao.searchByName(name);
    }
}

UserService

package com.Day05.service;

import com.Day05.bean.User;

import java.util.List;

public interface UserService {

    boolean login(String name,String password);

    boolean delete(Integer id);

    List<User> findAll();

    boolean add(User user);

    User findById(Integer id);

    boolean update(User user);

    List<User> searchByName(String name);

}

UserController

package com.Day05.controller;

import com.Day05.bean.User;
import com.Day05.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpSession;
import java.util.List;

@Controller
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    @RequestMapping("/login.do")
    public ModelAndView login(User user, HttpSession session){
        System.out.println("UserController run");
        boolean flag = userService.login(user.getName(),user.getPassword());
        System.out.println("UserController end");
        ModelAndView modelAndView=new ModelAndView();
        if(flag){
            session.setAttribute("user",user);
            modelAndView.setViewName("../ok");
        }else {
            modelAndView.setViewName("../failure");
        }
        return modelAndView;
    }

    @RequestMapping("/findAll.do")
    public ModelAndView findAll(@RequestParam(value = "name",defaultValue="")String name){
        ModelAndView modelAndView=new ModelAndView();
        List<User> userList=userService.searchByName(name);
        System.out.println("userList中的内容为："+userList);
        modelAndView.addObject("userList",userList);
        modelAndView.setViewName("../main");
        System.out.println("modelAndView中的内容为："+modelAndView);
        return modelAndView;
    }

    @RequestMapping("/delete.do")
    public String delete(int id){
        boolean del=userService.delete(id);
        if (del){
            return "redirect:findAll.do";
        }
        return "../failure";
    }
    @RequestMapping("/add.do")
    public String add(User user){
        boolean ad=userService.add(user);
        if(ad){
            return "redirect:findAll.do";
        }
        return "../failure";
    }
    @RequestMapping("/findById.do")
    public String findById(int id, Model model){
        User user=userService.findById(id);
        model.addAttribute("user",user);
        return "../modify";
    }
    @RequestMapping("/update.do")
    public String update(User user){
        boolean upd=userService.update(user);
        if(upd){
            return "redirect:findAll.do";
        }
        return "../failure";
    }

}

UserDao

package com.Day05.dao;

import com.Day05.bean.User;

import java.util.List;

public interface UserDao {

    User findUserByName(String name);

    List<User> findAll();

    int deleteById(Integer id);

    int add(User user);

    int update(User user);

    User findUserById(Integer id);

    List<User> searchByName(String name);
}

通过以上的代码 简单的登录、注册、删除、查询功能就能实现了。

那么 就下班
在这里插入图片描述

这里是小面包哒
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
maven的一点进阶
richest_qi的博客
10-26 518
文章目录maven依赖范围maven父子项目的依赖传递maven项目聚合统一管理maven项目常用插件 maven依赖范围 所谓依赖范围，指的是 依赖的jar包在maven项目生命周期里 作用的范围。 之前我们讲过，构建的gav坐标包括groupId、artifactId和version，其实还有一个scope。如果没有明示scope，则默认是compile。这里的compile就是依赖范围的一种，表示项目在编译、运行、测试、打包的这些生命周期里都依赖这个jar包，这个jar包在这些阶段都在起作用。 sco
配置maven时常见的小问题
beast___的博客
05-06 575
配置maven时常见的小问题 1.出现报错Unable to compile class for JSP 报错信息图片如下： 解决方案 1.考虑是否是jar包冲突而出现的问题 在pom.xml中添加jar包没有加限制，如下列代码： <?xml version="1.0" encoding="UTF-8"?> <!--修改前--> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www
maven配置 ssm
qq_35779815的博客
05-26 302
1.在main目录下创建 java和resource目录 把java标记成Sources root 把resource 标记成 Resources root pom文件 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;project xmlns="http://maven.apache.org/POM/4...
Maven的详细解读（一）
qq_44692189的博客
07-01 290
文章目录前言Maven功能及特点Maven到底是什么呢？Maven的好处 前言 Maven翻译为"专家"、"内行"， 是Apache下的一个纯Java开发的开源项目。基于项目对象模型(缩写: PO M)概念，Maven利用一个中央信息 片断能管理一个项目 的构建、报告和文档等步骤。 Maven是一个项目管理 工具，可以对Java项目进行构建、依赖管理。 Maven也可被用于构建和管理各种项目，例如C#，Ruby, Scala 和其他语言编写的项目。Maven 曾是Jakarta项目的子项目，现为由Apach
Maven项目管理软件pom.xml依赖包管理（通过此文件直接生成项目）
给时光以文明
06-26 396
<?xml version="1.0" encoding="UTF-8"?> <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/xsd/maven-4.0.0
SSM框架实现登录注册功能完整代码
10-23
这个"SSM框架实现登录注册功能完整代码"项目，通过IDEA（IntelliJ IDEA）进行整合，提供了从零开始构建登录注册功能的全套源码，包括所需的jar包和配置文件。下面我们将详细探讨SSM框架实现登录注册功能的关键知识点...
SSM框架实现注册登录功能
03-30
以上就是使用SSM框架实现注册登录功能的基本步骤和关键知识点。实际开发中，还需要考虑用户体验、性能优化、安全性强化等方面，但这个教程为你提供了一个良好的起点。通过学习和实践，你可以逐步掌握SSM框架并应用于...
SSM 实现登录验证码功能（附源码）
08-26
本文主要介绍了使用 SSM 框架实现登录验证码功能的方法，通过实例代码详细介绍了验证码的实现过程，具有很高的参考价值。 验证码的重要性 验证码是一种常用的安全机制，用于防止机器人和恶意攻击。它可以有效地...
IDEA搭建SSM实现登录、注册，增删改查功能
04-18
本教程将详细介绍如何使用IntelliJ IDEA（IDEA）来搭建SSM环境并实现登录、注册以及增删改查等基本功能。 首先，我们从创建项目开始。在IDEA中选择“New Project”，然后选择“Spring Initializr”来初始化一个...
基于SSM框架实现简单的登录注册功能【数据库+源码】
07-12
本项目旨在帮助初学者通过实践掌握基于SSM实现简单登录注册功能的基本步骤和技巧。 首先，`Spring`作为核心容器，管理着应用的bean和依赖注入（DI）。在`pom.xml`中，我们需要添加Spring的相关依赖，如`spring-...
springmvc第十四个练习（异常处理）
weixin_59334478的博客
06-23 177
1.pom.xml文件 2.自定义异常类 定义三个异常类：NameException、AgeException、MyUserException。其中MyUserException是另外两个异常的父类。MyUserException NameException AgeException 3.MyController类 4.定义三个异常响应页面 nameError.js ageError.jsp defaultError.jsp 5.定义主页
JavaEE——Spring学习笔记06【Maven创建Web工程】
书启鸿蒙知秋枫
02-19 921
目录 八、Maven创建Web工程使用Spring 1. 使用maven创建一个web工程项目：04-spring-web 2. 修改web.xml文件的版本为4.0 3. 构建项目的包结构 4.搭建tomcat服务器，启动服务器 5.实现在前端页面中添加学生的信息 5.1 修改pom.xml文件 5.2 创建数据库表——student表 5.3使用mybatis的逆向工程生成pojo和mapper 5.4创建添加学生列表的jsp页面index.jsp ......
springMVC——Xml配置方式实现Helloworld
乔治大哥的博客
09-19 889
Xml配置helloworld maven创建war项目 添加java和resources目录，并修改类型 修改web.xml配置文件 <?xml version="1.0" encoding="UTF-8"?><web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns...
使用idea搭建基于maven的ssm聚合项目
破茧成蝶
09-16 1792
版本统一 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 关于项目搭建，版本间的相互依赖很重要，所以一般情况下需要固定版本。 jdk：1.8 maven：3.5.4 Tomcat：7 最终搭建的结构如下： &nbsp;&nbsp;&nbsp;&nbsp;&
maven项目ssm框架中的配置文件
WY001的博客
05-09 746
文章目录0 目录结构1 pom.xml2 web.xml2.1 applicationContext.xml2.1.1 jdbc.properties2.1.2 mybatis.xml2.1.3 classpath:mappers/*.xml"2.2 log4j.properties2.3 springmvc.xml 0 目录结构 1 pom.xml <?xml version="1.0"...
第一次使用IDEA，结合mvn和Spring搭建Web项目
mayuan2011的博客
09-21 1361
使用idea工具，结合mvn和spring来搭建一个简单的web项目 最近一段时间都是在用webstorm进行前端开发验证，没有怎么研究结合后端的开发，现在有时间了就简单了解一下前后端结合的流程。中间参照了有经验人士的博客，初次接触，如下的流程如有不妥，还请谅解。 新建项目 IDEA中，File-&gt;New-&gt;Project，新建项目，选择maven-archetype-webapp ...
利用Maven工程命令行学习实操＜第三课＞
qq_56248592的博客
09-01 577
compile：通常使用的第三方框架的 jar 包这样在项目实际运行时真正要用到的 jar 包都是以 compile 范围进行依赖的。比如 SSM 框架所需jar包。 test：测试过程中使用的 jar 包，以 test 范围依赖进来。比如 junit。 provided：在开发过程中需要用到的“服务器上的 jar 包”通常以 provided 范围依赖进来。比如 servlet-api、jsp-api。而这个范围的 jar 包之所以不参与部署、不放进 war 包，就是避免和服务器上已有的同类 jar
ssm+ajax实现登录注册功能
最新发布
06-06
实现登录注册功能，可以按照以下步骤进行操作： 1. 搭建基本的SSM环境。SSM分别是Spring、SpringMVC和MyBatis的缩写，是一种常用的Java Web开发框架。 2. 编写前端页面，使用HTML、CSS和JavaScript实现用户界面。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值