devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Mysql存储过程调用_mysql调用存储过程

作者：weixin_40725706 | 2024-05-17 14:01:15

赞

踩

mysql调用存储过程

项目结构：

准备数据

CREATE TABLE `demo_entity` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) COLLATE utf8mb4_bin DEFAULT NULL,
  `age` bigint(20) DEFAULT '0',
  `cdate` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `udate` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin

1、存储过程的调用
存储过程主要返回三类

1、返回数值的存储过程，其执行完后返回一个值，例如数据库中执行一个有返回值的函数或命令。
2、返回记录集的存储过程:执行结果是一个记录集，例如，从数据库中检索出符合某一个或几个条件的记录。
3、行为存储过程，用来实现数据库的某个功能，而没有返回值，例如在数据库中的更新和删除操作。
1、接收一个返回值
1.1、创建存储过程
1.2、返回out变量

DROP PROCEDURE IF EXISTS pro;
CREATE PROCEDURE pro (
  IN userId INT,
  OUT userCount INT
)
  BEGIN
    DECLARE user_name VARCHAR (64);
    #SELECT d.name FROM demo_entity d WHERE d.id = userId INTO user_name;
    #INSERT INTO demo_entity (name) VALUES (user_name);
    SELECT COUNT(*) FROM demo_entity INTO userCount;
end;

call pro(1,@userCount);
select @userCount ;

1.2、返回集合和out变量

DROP PROCEDURE IF EXISTS pro_one_list;
CREATE PROCEDURE pro_one_list (
  IN p_name varchar(20),
  OUT userCount INT
)
  BEGIN
    select count(*) from demo_entity d where d.name = p_name into userCount ;
    SELECT * FROM demo_entity d  where  d.name = p_name;
  end;


call pro_one_list('小芳',@userCount);
select @userCount ;

1.3、返回多列集合和变量

drop procedure IF EXISTS pro_many_list ;
CREATE PROCEDURE pro_many_list (
  IN one_name varchar(20),
  IN two_name varchar(20),
  OUT userCount INT
)
  BEGIN
    select count(*) from demo_entity d where d.name = one_name into userCount ;
    SELECT d.* FROM demo_entity d  where  d.name = one_name;
    SELECT e.* FROM demo_entity e  where  e.name = two_name;
  end;


call pro_many_list('小芳','小小芳',@userCount);
select @userCount ;

2、mybatis xml 配置

out 中必须制定jdbc类型，因为存储过程会对它进行赋值操作

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
  3. <mapper namespace="com.example.cache.mapper.DemoEntityMapper">
  4.  
  5.  
  6.  
  7.  
  8.     <!--out 中必须制定jdbc类型，因为存储过程会对它进行赋值操作-->
  9.     <select id="procedureGetOut" parameterType="java.util.Map" statementType="CALLABLE" >
  10.       call pro (
  11.               #{userId,   mode=IN},
  12.               #{userCount,mode=OUT,jdbcType=INTEGER}
  13.       )
  14.   </select>
  15.  
  16.  
  17.  
  18.     <select id="procedureGetOneList" parameterType="java.util.Map" statementType="CALLABLE" resultType="com.example.cache.entity.DemoEntity" >
  19.       call pro_one_list (
  20.               #{userName, mode=IN},
  21.               #{userCount,mode=OUT,jdbcType=INTEGER}
  22.       )
  23.   </select>
  24.  
  25.  
  26.  
  27.  
  28.     <resultMap id="twoList" type="com.example.cache.entity.DemoEntity">
  29.         <result column="id" property="id"></result>
  30.         <result column="name" property="name"></result>
  31.     </resultMap>
  32.  
  33.     <resultMap id="oneList" type="com.example.cache.entity.DemoEntity">
  34.         <result column="id" property="id"></result>
  35.         <result column="name" property="name"></result>
  36.     </resultMap>
  37.  
  38.     <!--resultMap中会提示报错，但是实际上启动项目不会报错-->
  39.     <select id="procedureGetManyList" parameterType="java.util.Map" statementType="CALLABLE" resultMap="oneList,twoList">
  40.       call pro_many_list (
  41.               #{oneName, mode=IN},
  42.               #{twoName, mode=IN},
  43.               #{userCount,mode=OUT,jdbcType=INTEGER}
  44.       )
  45.    </select>
  46.  
  47.  
  48. </mapper>

3、mapper接口

  1. @Mapper
  2. public interface DemoEntityMapper {
  3.  
  4.     /**
  5.      * 1、获取 存储过程out参数值
  6.      * @param map
  7.      * @return
  8.      */
  9.     void procedureGetOut(Map map);
  10.  
  11.  
  12.     /**
  13.      * 2、获取 存储过程的结果集合-只有一个
  14.      * @param map
  15.      * @return
  16.      */
  17.     List<DemoEntity> procedureGetOneList(Map map) ;
  18.  
  19.  
  20.  
  21.     /**
  22.      * 3、获取 存储过程的 获取多个集合 使用了泛型，有可能集合中是不同的
  23.      * @param
  24.      * @return
  25.      */
  26.     List<List<?>> procedureGetManyList(Map map);
  27.  
  28. }

4、业务层

  1. @Service
  2. public class ProcedureServiceImpl implements IProcedureService {
  3.     @Autowired
  4.     DemoEntityMapper demoEntityMapper;
  5.  
  6.     @Override
  7.     public Integer procedureGetOut(Long id) {
  8.         Map<String, Object> param = new HashMap<>();
  9.         param.put("userId", id) ;
  10.         //执行完存储过程会自动更新这个map值
  11.         demoEntityMapper.procedureGetOut(param);
  12.         return Integer.valueOf(param.get("userCount").toString());
  13.     }
  14.  
  15.  
  16.     /**
  17.      * 2、获取 存储过程的结果集合-只有一个
  18.      * @param name
  19.      * @return
  20.      */
  21.     @Override
  22.     public List<DemoEntity> procedureGetOneList(String name) {
  23.         Map<String, Object> param = new HashMap<>();
  24.         param.put("userName", name) ;
  25.  
  26.         //获取结果集
  27.         List<DemoEntity> list  = demoEntityMapper.procedureGetOneList(param);
  28.         System.out.println(Integer.valueOf(param.get("userCount").toString()));
  29.  
  30.         return list;
  31.     }
  32.  
  33.     /**
  34.      * 3、获取 存储过程的 获取多个集合 使用了泛型，有可能集合中是不同的
  35.      * @param
  36.      * @return
  37.      */
  38.     @Override
  39.     public List<List<?>> procedureGetManyList(String oneName, String twoName) {
  40.         Map<String, Object> param = new HashMap<>();
  41.         param.put("oneName", oneName) ;
  42.         param.put("twoName", twoName) ;
  43.         List<List<?>> lists =   demoEntityMapper.procedureGetManyList(param) ;
  44.         System.out.println("数组大小"+lists.size());
  45.         System.out.println("某个数量"+Integer.valueOf(param.get("userCount").toString()));
  46.         return lists;
  47.     }
  48. }

5、控制层

  1. @RestController
  2. @RequestMapping("/procedure")
  3. public class ProcedureController {
  4.     @Autowired
  5.     IProcedureService procedureService;
  6.  
  7.     @GetMapping("/procedureGetOut")
  8.     @ResponseBody
  9.     public String  procedureGetOut(Long id){
  10.         Integer integer = procedureService.procedureGetOut(id);
  11.         return String.valueOf(integer);
  12.     }
  13.  
  14.     /**
  15.      * @Author
  16.      * @Description //TODO 获取返回结果集
  17.      * @Date
  18.      * @Param
  19.      * @return
  20.      **/
  21.     @GetMapping("procedureGetOneList")
  22.     @ResponseBody
  23.     public List<?> procedureGetOneList(String name){
  24.         return procedureService.procedureGetOneList(name);
  25.     }
  26.  
  27.  
  28.     /**
  29.      * @Author
  30.      * @Description //TODO 获取返回结果集(多个)
  31.      * @Date
  32.      * @Param
  33.      * @return
  34.      **/
  35.     @GetMapping("procedureGetManyList")
  36.     @ResponseBody
  37.     public List<?> procedureGetManyList(String oneName,String twoName){
  38.         return procedureService.procedureGetManyList(oneName,twoName);
  39.     }
  40.  
  41. }

6、application.properties配置文件

  1. server.port=9090
  2. spring.datasource.url=jdbc:mysql://localhost:3306/procedure
  3. spring.datasource.username=root
  4. spring.datasource.password=root
  5. #数据库驱动
  6. #spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
  7.  
  8. # 打开驼峰命名规则
  9. mybatis.configuration.map-underscore-to-camel-case=true
  10. # classpath和classpath*的区别
  11. #classpath：只会到你的class路径中查找找文件。
  12. #classpath*：不仅包含class路径，还包括jar文件中（class路径）进行查找。
  13. #注意： 用classpath*:需要遍历所有的classpath，所以加载速度是很慢的；因此，在规划的时候，应该尽可能规划好资源文件所在的路径，尽量避免使用classpath*。
  14. #接口的配置文件的位置-映射用
  15. mybatis.mapper-locations=classpath*:com/example/cache/mapper/xml/*Mapper.xml
  17. # mapper包下打印日志
  18. logging.level.com.example.cache.mapper=debug
  21. spring.redis.host=127.0.0.1
  22. spring.redis.port=6379
  23. spring.redis.password=''
  26. #debug=true

7、pom文件依赖

  1. <dependencies>
  2.         <dependency>
  3.             <groupId>org.springframework.boot</groupId>
  4.             <artifactId>spring-boot-starter-data-redis</artifactId>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>org.springframework.boot</groupId>
  8.             <artifactId>spring-boot-starter-web</artifactId>
  9.         </dependency>
  10.         <dependency>
  11.             <groupId>org.mybatis.spring.boot</groupId>
  12.             <artifactId>mybatis-spring-boot-starter</artifactId>
  13.             <version>2.2.2</version>
  14.         </dependency>
  15.         <dependency>
  16.             <groupId>mysql</groupId>
  17.             <artifactId>mysql-connector-java</artifactId>
  18.             <scope>runtime</scope>
  19.         </dependency>
  20.         <dependency>
  21.             <groupId>org.projectlombok</groupId>
  22.             <artifactId>lombok</artifactId>
  23.             <optional>true</optional>
  24.         </dependency>
  25.         <dependency>
  26.             <groupId>org.springframework.boot</groupId>
  27.             <artifactId>spring-boot-starter-test</artifactId>
  28.             <scope>test</scope>
  29.         </dependency>
  30.         <dependency>
  31.             <groupId>io.projectreactor</groupId>
  32.             <artifactId>reactor-test</artifactId>
  33.             <scope>test</scope>
  34.         </dependency>
  35.     </dependencies>

调用回报错：

报错问题：
mapper绑定异常 nested exception is org.apache.ibatis.binding.BindingException: Invalid bound statement (not found): xxx.xxxx.mapper.UserMapper.getAllUser] with root cause

背景：

mapper接口和**mapper.xml映射文件**在同一个包下。

在看到 **Invalid bound statement (not found)**后，提示未找到mapper映射文件，然后打开编译后的target包或生成的jar包后，找到mapper映射文件存放位置，发现编译后的jar包内并没有此映射文件，进而将问题指向到Maven编译的过程中没有将普通配置文件编译进jar包内。

报错原因：

​ 由于我把mapper映射文件放在mapper接口的同一包里，并没有放在resources目录下，导致通过Maven编译后没有把除Java以外的映射文件、配置文件编译到target和jar包内，在运行时，调用mapper映射文件时，发现在同一个目录下没有找到mapper映射文件而报错。

​ 我们知道Maven是根据pom.xml执行任务，其中build标签描述了如何来编译及打包项目，而具体的编译和打包工作是通过build中配置的 plugin 来完成。而对于resources目录下资源，往往不是代码（.properties或XML配置文件），无需编译，所以在构建过程中往往会将资源文件从源路径直接复制到指定的目标路径。

​ src/main/java和src/test/java这两个目录中的所有*.java文件会分别在comile和test-comiple阶段被编译，编译结果分别放到了target/classes和targe/test-classes目录中，但是这两个目录中的其他文件都会被忽略掉。

解决办法：

需要在你的项目的pom文件中添加一下配置

  1. <build>
  2.         <resources>
  3.         <!-- 解决mapper绑定异常 -->
  4.         <resource>
  5.             <directory>src/main/java</directory>
  6.             <includes>
  7.                 <include>**/*.yml</include>
  8.                 <include>**/*.xml</include>
  9.             </includes>
  10.             <filtering>false</filtering>
  11.         </resource>
  12.         <!-- 解决未找到数据源等配置异常 -->
  13.         <resource>
  14.             <directory>src/main/resources</directory>
  15.             <includes>
  16.                 <include>**/*.yml</include>
  17.                 <include>**/*.properties</include>
  18.             </includes>
  19.         </resource>
  20.     </resources>
  21. </build>

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/583886
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号