• 简易SSM框架转账

    编译器：IDEA

    数据库：Mysql 8.0

    项目要求：实现张三给李四转账

    如果自己有项目，可以根据本篇文章修改

    一、导入数据库

    -- 因为我们项目的目标只是实现一个简单的转账，所以我们只使用一个user表，一共三个字段，id，名字，余额

    可以自己搭，也可以用下面的

    1.  
    2. SET NAMES utf8mb4;
    3. SET FOREIGN_KEY_CHECKS = 0;
    4.  
    5. -- ----------------------------
    6. -- Table structure for user
    7. -- ----------------------------
    8. DROP TABLE IF EXISTS `user`;
    9. CREATE TABLE `user`  (
    10.   `user_id` int(11) NOT NULL,
    11.   `user_name` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL,
    12.   `user_money` float(50, 0) NULL DEFAULT NULL,
    13.   PRIMARY KEY (`user_id`) USING BTREE
    14. ) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
    15.  
    16. -- ----------------------------
    17. -- Records of user
    18. -- ----------------------------
    19. INSERT INTO `user` VALUES (1, '张三', 90);
    20. INSERT INTO `user` VALUES (2, '李四', 20);
    21. INSERT INTO `user` VALUES (3, '王五', 90);
    22. INSERT INTO `user` VALUES (4, '赵六', 0);
    23.  
    24. SET FOREIGN_KEY_CHECKS = 1;

    清楚自己需要做什么功能，准备对应的sql语句

    二、创建工程

    （一）创建目录结构及类

    控制器，Dao，实体，服务

    （是类，是接口）

    然后添加一个汤姆猫

    三、导包

    打开pom.xml，粘贴后记得刷一下如果刷不了可以右键 -->  meven -->Reload project

    1. "1.0" encoding="UTF-8"?>
    2.  
    3. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.   <modelVersion>4.0.0modelVersion>
    6.  
    7.   <groupId>com.fixgroupId>
    8.   <artifactId>hellossmartifactId>
    9.   <version>1.0-SNAPSHOTversion>
    10.   <packaging>warpackaging>
    11.  
    12.   <name>hellossm Maven Webappname>
    13.   
    14.   <url>http://www.example.comurl>
    15.  
    16.   
    17.   <properties>
    18.     <spring.version>5.1.8.RELEASEspring.version>
    19.   properties>
    20.  
    21.   <dependencies>
    22.     <dependency>
    23.       <groupId>org.springframeworkgroupId>
    24.       <artifactId>spring-testartifactId>
    25.       <version>${spring.version}version>
    26.     dependency>
    27.     
    28.     <dependency>
    29.       <groupId>log4jgroupId>
    30.       <artifactId>log4jartifactId>
    31.       <version>1.2.17version>
    32.     dependency>
    33.     
    34.     <dependency>
    35.       <groupId>junitgroupId>
    36.       <artifactId>junitartifactId>
    37.       <version>4.12version>
    38.       <scope>testscope>
    39.     dependency>
    40.  
    41.     
    42.     <dependency>
    43.       <groupId>org.springframeworkgroupId>
    44.       <artifactId>spring-webmvcartifactId>
    45.       <version>${spring.version}version>
    46.     dependency>
    47.     
    48.     <dependency>
    49.       <groupId>org.aspectjgroupId>
    50.       <artifactId>aspectjweaverartifactId>
    51.       <version>1.8.7version>
    52.     dependency>
    53.     <dependency>
    54.       <groupId>org.springframeworkgroupId>
    55.       <artifactId>spring-jdbcartifactId>
    56.       <version>${spring.version}version>
    57.     dependency>
    58.     
    59.     <dependency>
    60.       <groupId>com.fasterxml.jackson.coregroupId>
    61.       <artifactId>jackson-databindartifactId>
    62.       <version>2.9.8version>
    63.     dependency>
    64.     
    65.     <dependency>
    66.       <groupId>javax.servletgroupId>
    67.       <artifactId>javax.servlet-apiartifactId>
    68.       <version>3.1.0version>
    69.       <scope>providedscope>
    70.     dependency>
    71.     <dependency>
    72.       <groupId>javax.servlet.jspgroupId>
    73.       <artifactId>jsp-apiartifactId>
    74.       <version>2.0version>
    75.       <scope>providedscope>
    76.     dependency>
    77.     <dependency>
    78.       <groupId>javax.servletgroupId>
    79.       <artifactId>jstlartifactId>
    80.       <version>1.2version>
    81.     dependency>
    82.  
    83.     
    84.     <dependency>
    85.       <groupId>mysqlgroupId>
    86.       <artifactId>mysql-connector-javaartifactId>
    87.       <version>8.0.15version>
    88.     dependency>
    89.     
    90.     <dependency>
    91.       <groupId>com.alibabagroupId>
    92.       <artifactId>druidartifactId>
    93.       <version>1.1.10version>
    94.     dependency>
    95.     
    96.     <dependency>
    97.       <groupId>org.mybatisgroupId>
    98.       <artifactId>mybatisartifactId>
    99.       <version>3.3.0version>
    100.     dependency>
    101.     
    102.     <dependency>
    103.       <groupId>org.mybatisgroupId>
    104.       <artifactId>mybatis-springartifactId>
    105.       <version>1.2.3version>
    106.     dependency>
    107.     
    108.     <dependency>
    109.       <groupId>com.github.pagehelpergroupId>
    110.       <artifactId>pagehelperartifactId>
    111.       <version>5.1.8version>
    112.     dependency>
    113.  
    114.     <dependency>
    115.       <groupId>org.projectlombokgroupId>
    116.       <artifactId>lombokartifactId>
    117.       <version>1.18.12version>
    118.     dependency>
    119.   dependencies>
    120. project>

    四、配置文件

    （一）创建配置文件

    在目录下  resources   目录下创建五个文件

    jdbc.properties      mybatis-config.xml       spring-dao.xml        spring-web-xml 

     userMapper.xml  (要在resources中建mapper包，并放在包里)

    jdbc.properties

    (替换自己的mysql账户密码跟数据库名)

    1. jdbc.driver=com.mysql.cj.jdbc.Driver
    2. jdbc.url=jdbc:mysql://localhost:3306/up?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
    3. jdbc.username=root
    4. jdbc.password=a123
    mybatis-config.xml 
    1. "1.0" encoding="UTF-8" ?>
    2. configuration
    3.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    4.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
    5. <configuration>
    6.     <settings>
    7.         
    8.         <setting name="useGeneratedKeys" value="true"/>
    11.         
    12.         <setting name="logImpl" value="STDOUT_LOGGING" />
    13.     settings>
    14. configuration>
    spring-dao.xml
    1. "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:context="http://www.springframework.org/schema/context"
    5.        xmlns:tx="http://www.springframework.org/schema/tx"
    6.        xsi:schemaLocation="http://www.springframework.org/schema/beans
    7.  http://www.springframework.org/schema/beans/spring-beans.xsd
    8.  http://www.springframework.org/schema/context
    9.  http://www.springframework.org/schema/context/spring-context.xsd
    10.  http://www.springframework.org/schema/tx
    11.  http://www.springframework.org/schema/tx/spring-tx.xsd">
    12.  
    13.     
    14.     <context:component-scan base-package="com.an"/>
    15.  
    16.     
    17.     <context:property-placeholder location="classpath:jdbc.properties"/>
    18.  
    19.     
    20.     <bean id="dataSource"
    21.           class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
    22.         
    23.         <property name="url" value="${jdbc.url}"/>
    24.         <property name="driverClassName" value="${jdbc.driver}"/>
    25.         <property name="username" value="${jdbc.username}"/>
    26.         <property name="password" value="${jdbc.password}"/>
    27.     bean>
    28.  
    29.     <bean id="sessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    30.         
    31.         <property name="dataSource" ref="dataSource"/>
    32.         
    33.         <property name="configLocation" value="classpath:mybatis-config.xml"/>
    34.         
    35.         <property name="typeAliasesPackage" value="com.an.entity"/>
    36.         
    37.         <property name="mapperLocations" value="classpath:mapper/*.xml"/>
    38.     bean>
    39.  
    40.     
    41.     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    42.         
    43.         <property name="sqlSessionFactoryBeanName" value="sessionFactory"/>
    44.         
    45.         <property name="basePackage" value="com.an.dao"/>
    46.     bean>
    47.  
    48.     
    49.     <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    50.         
    51.         <property name="dataSource" ref="dataSource"/>
    52.     bean>
    53.     
    54.     <tx:annotation-driven transaction-manager="txManager"/>
    55.  
    56. beans>
    spring-web.xml
    1. "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:context="http://www.springframework.org/schema/context"
    5.        xmlns:mvc="http://www.springframework.org/schema/mvc"
    6.        xsi:schemaLocation="
    7.         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    8.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
    9.         http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    10.  
    11.     
    12.     <context:component-scan base-package="com.an"/>
    13.  
    14.     
    15.     <mvc:default-servlet-handler/>
    16.  
    18.     <mvc:annotation-driven>
    19.         <mvc:message-converters>
    20.             <bean class="org.springframework.http.converter.StringHttpMessageConverter">
    21.                 <property name="supportedMediaTypes">
    22.                     <list>
    23.                         <value>text/plain;charset=UTF-8value>
    24.                         <value>text/html;charset=UTF-8value>
    25.                         <value>application/json;charset=UTF-8value>
    26.                     list>
    27.                 property>
    28.             bean>
    29.         mvc:message-converters>
    30.     mvc:annotation-driven>
    31.  
    32.     
    33.     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    34.         <property name="prefix" value="/WEB-INF/pages/">property>
    35.         <property name="suffix" value=".jsp">property>
    36.     bean>
    37.  
    38. beans>
    39.
    userMapper.xml 

    这里填sql语句  #{ }是占位符

    指定接口，mapper标签里面的标签id指定接口方法，占位符内映射为方法传入的参数

    1. "1.0" encoding="UTF-8"?>
    2. mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    3. <mapper namespace="com.an.dao.UserDao">
    4.     <select id="selectUser" resultType="User">
    5.         select * from user where user_id = #{uid}
    6.     select>
    7.  
    8.     <update id="updateUserMoney">
    9.         update user set user_money = #{money} where user_id = #{uid}
    10.     update>
    11.  
    12. mapper>
    （二）web.xml,开启spring
    1. "1.0" encoding="UTF-8"?>
    2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee"
    3.          xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
    4.          id="WebApp_ID" version="3.0">
    5.  
    6.   <display-name>ssmdisplay-name>
    7.  
    8. <--  开启spring -->
    9.   <servlet>
    10.     <servlet-name>springservlet-name>
    11.     <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
    12.     <init-param>
    13.       <param-name>contextConfigLocationparam-name>
    14.       <param-value>classpath:spring-*.xmlparam-value>
    15.     init-param>
    16.     <load-on-startup>1load-on-startup>
    17.   servlet>
    18.   <servlet-mapping>
    19.     <servlet-name>springservlet-name>
    20.     <url-pattern>/url-pattern>
    21.   servlet-mapping>
    22.  
    23. web-app>

    三、类

    如果按照  之前 的建好包了，那么就可以开始着手写类了 

    （一）实体

        所在包：entity  

            User

    实体类中的变量名与数据库的名字一样（避免不必要的冲突）

    这里使用了lombok动态生成get set

    1. package com.an.entity;
    2.  
    3. import lombok.Data;
    4.  
    5. @Data
    6. public class User {
    7.     int user_id;
    8.     String user_name;
    9.     float user_money;
    10. }

    （二）Dao
    UserDao

    类型接口，用与与mapper交涉

    1. package com.an.dao;
    2. import com.an.entity.User;
    3. import org.apache.ibatis.annotations.Param;
    4.  
    5. import java.util.List;
    6.  
    7. public interface UserDao {
    8.      User selectUser(int uid);
    9. //    查询某人
    10.  
    11.      int updateUserMoney(@Param("uid") int uid,@Param("money") float money);
    12. //    修改余额,这里用@param是因为要映射到mapper，之前试了不写就会说匹配不到参数
    13. }
     （三）服务以及服务实现
             UserService

        跟Userdao写一样就行（别把类名也写一样了）

    1.      package com.an.service;
    2.      import com.an.entity.User;
    3.      import java.util.List;
    4.      
    5.      public interface UserService {
    6.           User selectUser(int uid);
    7.      //    查询某人
    8.      
    9.           int updateUserMoney(int uid,float money);
    10.      //    修改余额
    11.      }
            UserServiceImpl

            最后这四个字母是   大写的 挨 I         按亩m  批p  爱奥 l

    1. package com.an.service.Impl;
    2.  
    3. import com.an.dao.UserDao;
    4. import com.an.entity.User;
    5. import com.an.service.UserService;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.stereotype.Service;
    8. @Service
    9. public class UserServiceImpl implements UserService {
    10.  
    11.     @Autowired
    12.     UserDao userdao;
    13.  
    14.     @Override
    15.     public User selectUser(int uid) {
    16.         System.out.println("selectUser  进入服务层");
    17.         User userAll = userdao.selectUser(uid);
    18.         return userAll;
    19.     }
    20.  
    21.     @Override
    22.     public int updateUserMoney(int uid,float money) {
    23.         System.out.println("updateUserMoney  进入服务层  uid  -->" +uid  +";  money --> "+ money);
    24.         int succ = userdao.updateUserMoney(uid,money);
    25.         return succ;
    26.     }
    27. }
         

    四、测试

    写完就可以进入测试流程了

    我们可以在dao这里创建一个测试类

    选择junit4，把下面两个方法勾上

    测试类会放在这个地方，不会被运行编译，方法单独运行

    UserDaoTest

    开始测试

    1. package com.an.dao;
    2.  
    3. import com.an.entity.User;
    4. import com.an.service.Impl.UserServiceImpl;
    5. import org.junit.Test;
    6. import org.junit.runner.RunWith;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8. import org.springframework.context.ApplicationContext;
    9. import org.springframework.test.context.ContextConfiguration;
    10. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    11.  
    12. @RunWith(SpringJUnit4ClassRunner.class)
    13. @ContextConfiguration("classpath:spring-dao.xml")
    14. //这里直接把spring配置进去，因为要装配一个容器
    15. public class UserDaoTest {
    16.  
    17.     @Autowired
    18.     ApplicationContext context;
    19. //装配容器
    20.  
    21.     @Test
    22.     public void selectUser() {
    23.         UserServiceImpl userService = context.getBean(UserServiceImpl.class);
    24. //        拿取实现类
    25.         User u = userService.selectUser(1);
    26.         System.out.println(u);
    27.  
    28.     }
    29.  
    30.     @Test
    31.     public void updateUserMoney() {
    32.         UserServiceImpl userService = context.getBean(UserServiceImpl.class);
    33.         int succ = userService.updateUserMoney(1,100);
    34.         System.out.println("影响行  --> "+succ);
    35.     }
    36. }

    均测试成功

    （一）控制类

    UserController

    测试成功之后就可以写控制类了

    1. package com.an.controller;
    2.  
    3. import com.an.entity.User;
    4. import com.an.service.Impl.UserServiceImpl;
    5. import org.apache.ibatis.annotations.Param;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.stereotype.Controller;
    8. import org.springframework.web.bind.annotation.RequestMapping;
    9. import org.springframework.web.bind.annotation.ResponseBody;
    10.  
    11. @Controller
    12. public class UserController {
    13.  
    14.     @Autowired
    15.     UserServiceImpl userService;
    16. //    这里直接注入服务实现类
    17.  
    18.     @RequestMapping("view")
    19.     public String selectUserAll(){
    20.         System.out.println("进入视图");
    21. //        这里直接跳转到user.jsp
    22.         return "tomoney";
    23. //        返回users   ，usersjsp的名字，在spring-web中配置了视图解析器，返回jsp名就会被解析并实现视图
    24.     }
    25.  
    26.     @RequestMapping("toFoMoney")
    27.     @ResponseBody//不跳转页面,只是返回字符串
    28.     public String updateUserMoney(@Param("uid") int uid,@Param("money")float money,@Param("touid") int touid){
    29.         System.out.println("进入修改余额");
    30.         User u1 =  userService.selectUser(uid);
    31.         float u1moeny = u1.getUser_money();
    32.         float _u1money;//u1转账后的余额
    33.         float _u2money;//u2转账后的余额
    34. //转账人的余额
    35.  
    36.         User u2 = userService.selectUser(touid);
    37.         float u2money = u2.getUser_money();
    38. //收款人的余额
    39.  
    40.         if(u1moeny>=money){
    41.             //判断转账人是否满足转账金额,如果余额大于或等于正在转账的金额，那么直接进入转账
    42.             _u1money = u1moeny - money;
    43.              userService.updateUserMoney(uid,_u1money);
    44.             System.out.println(_u1money+" u1转账后余额");
    45.             //            u1新的余额
    46.  
    47.             _u2money = u2money += money;
    48.             userService.updateUserMoney(touid,_u2money);
    49.             System.out.println(_u1money+" u2收款后余额");
    50.             //            u2新的余额
    51.         }else{
    52.             return "转账失败"+u1.getUser_name()+"的钱不够"+money+"无法转账给"+u2.getUser_name();
    53.         }
    54.         return "转账成功"+u1.getUser_name()+"成功给"+u2.getUser_name()+"转账"+money+"  转账人" + u1.getUser_name()+"余额还有"+_u1money+" 收款人"+u2.getUser_name()+"余额还有"+_u2money;
    55.     }
    56.  
    57. }

    创建jsp路径，这里也是本篇文章最后的定版结构了

    index.jsp
    1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    2. <html>
    3. <head>
    4.     <title>Titletitle>
    5. head>
    6. <body>
    7. <a href="view">转账a>
    8. body>
    9. html>
    tomoney.jsp
    1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    2. <html>
    3. <head>
    4.     <title>Titletitle>
    5. head>
    6. <body>
    7. <form action="toFoMoney">
    8.     <p>转账人id：<input type="number" name="uid">   转账金额<input type="number" name="money" placeholder="转账金额">p>
    9.     <p>收款人：<input type="number" name="touid">  p>
    10.     <p><button type="submit">转账button> p>
    11. form>
    12.  
    13. body>
    14. html>

    最后打开汤姆猫

    最终效果：

    点击转账进入控制器 的 view

            

    比如说张三现在有100圆子，给李四转 50 圆子

    转账成功

    赵六没钱，想给张三转100

    转账失败

  • 相关阅读:
    设计模式---工厂模式
    【011】Wireshark主窗口新增、删除显示的列数
    MLX90640 红外热成像传感器测温模块开发笔记（三）
    yolov5和yolov7之实例分割训练
    rdma-轮询常用cq函数。
    JVM调优-GC基本原理和调优关键分析
    《大数据之路：阿里巴巴大数据实践》-第1篇 数据技术篇 -第5章 实时技术
    消息队列十连问
    微信小程序 springboot新冠疫苗预约系统#计算机毕业设计
    （附源码）springboot水利机械厂仓储管理系统 毕业设计 091408
  • 原文地址：https://blog.csdn.net/qq_54179640/article/details/132800975