简单springboot项目，出错+运行成功对比

王安安的记录

已于 2024-01-30 22:56:22 修改

阅读量791

点赞数 14

文章标签： spring boot 后端 java

于 2024-01-30 22:55:34 首次发布

本文链接：https://blog.csdn.net/weixin_52034824/article/details/135935955

版权

**https://blog.csdn.net/yuran06/article/details/122012790
这个是成功版的，按照这个坐下来，可以运行在这里插入图片描述 **出错的版本：

  public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2)//指定版本
                .apiInfo(apiInfo())
                .select()//有些情况，我们需要指定固定包路径下的类生成API，或者根据前端用户路径请求过滤；

//使用过滤，必须先调用select方法；

                .apis(RequestHandlerSelectors.basePackage("com.example.demo2.com.it.www.controller.UserController"))
                //通过apis方法，basePackage可以根据包路径来生成特定类的API，any方法是默认所有都有效，none方法都无效；
                .paths(PathSelectors.any())
                //最后要加 build()方法；

类似的还有一个根据请求路径的paths方法；

一般用ant匹配路径；

any是匹配任意路径，none是都不匹配，regex是正则匹配；
                .build();
    }
    通过设置Docket，可以配置很多功能，比如是否开启swagger，过滤，分组等

＿＿＿＿＿＿＿＿＿＿＿＿－

 @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
        // 解决静态资源无法访问
        registry.addResourceHandler("/**").addResourceLocations("classpath:/static/");
        // 解决swagger无法访问
        registry.addResourceHandler("/swagger-ui.html").addResourceLocations("classpath:/META-INF/resources/");
        // 解决swagger的js文件无法访问
        registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
    }
    //这段代码意思就配置一个拦截器， 如果访问路径是addResourceHandler中的filepath 这个路径 那么就 映射到访问本地的addResourceLocations 的参数的这个路径上，这样就可以让别人访问服务器的本地文件了，比如本地图片或者本地音乐视频什么的。

正确版的ｙａｍｌ

server:
  port: 8086
spring:
  datasource:
    username: ..
    password: ...
    url: jdbc:mysql://localhost:3306/db_name?serverTimezone=UTC&userUnicode=true&characterEncoding=utf-8
    driver-class-name: com.mysql.cj.jdbc.Driver
#    type: com.alibaba.druid.pool.DruidDataSource
mybatis:
  type-aliases-package: com.example.pojo
  mapper-locations: classpath:mapper/*.xml

#要配置的端口号\datasource\mybatis

注意yaml的语法格式：
推荐文章：
https://blog.csdn.net/whiteBearClimb/article/details/109181872
推荐文章
ｘｍｌ文件对比：

旧版：
<!--    使用If修改-->
    <update id="updateUserByIf" 
   parameterType="com.example.demo.www.pojo.User">
        UPDATE user
        <set>
<!--            这里用if:传递了什么值就修改什么值！！！！！-->
            <if test="userAccount!=null and userAccount!=''">
                userAccount=#{userAccount}
            </if>
            <if test="userPassword!=null and userPassword!=''">
                ,userPassword=#{userPassword}
            </if>
            <if test="userName!=null and userName!=''">
                ,userName=#{userName}
            </if>
            <if test="userSex>0">
                ,userSex=#{userSex}
            </if>
            <if test="userAge>0">
                ,userAge=#{userAge}
            </if>
            <if test="userPhone!=null and userPhone!=''">
                ,userPhone=#{userPhone}
            </if>
            <if test="userAddress!=null and userAddress!=''">
                ,userAddress=#{userAddress}
            </if>
        **</set>**
        WHERE userId=#{userId}
    </update>

ＭｙＢａｔｉｓ的9大动态SQL标签
推荐文章：https://zhuanlan.zhihu.com/p/354533234
添加链接描述
＇在例如 Java 高级语言中，都会嵌入（支持）SQL 能力，一般我们可以直接在代码或配置文件中编写 SQL 语句，如果一个 SQL 语句在 “编译阶段” 就已经能确定主体结构，那我们称之为静态 SQL，如果一个 SQL 语句在编译阶段无法确定主体结构，需要等到程序真正 “运行时” 才能最终确定，那么我们称之为动态 SQL＇
额外添加了一块 if 标签作为条件判断，所以应用程序在编译阶段是无法确定 SQL 语句最终主体结构的，只有在运行时根据应用程序是否传入 id 这个条件，来动态的拼接最终执行的 SQL 语句，因此属于动态 SQL 。
Mybatis 在初始化解析配置文件的时候，会实例化这么一个标签节点的构造器，那么它本身就会提前把所有 Mybatis 支持的动态 SQL 标签对象对应的处理器给进行一个实例化，然后放到一个 Map 池子里头，
set 标签下至少存在一个条件满足，同时每个条件子句都建议在句末添加逗号 ,最后一个条件语句可加可不加。

<!--    使用WHERE判断符合条件的结果:自动去除WHERE开头的OR/AND-->
<insert id="addUser" parameterType="com.example.demo.www.pojo.User" >
      INSERT INTO user(userAccount
      ,userPassword
      ,userName
      ,userSex
      ,userAge
      ,userPhone
      ,userAddress)
      VALUES(#{userAccount}
      ,#{userPassword}
      ,#{userName}
      ,#{userSex}
      ,#{userAge}
      ,#{userPhone}
      ,#{userAddress} )
  </insert>
  <!--更新用户信息1-->
  <update id="updateUser" parameterType="com.example.demo.www.pojo.User">
      UPDATE user
      SET userAccount = #{userAccount},
      userPassword = #{userPassword},
      userName = #{userName},
      userSex = #{userSex},
      userAge = #{userAge},
      userPhone = #{userPhone},
      userAddress = #{userAddress}
      WHERE userId = #{userId}
  </update>

新建立的ｘｍｌ：

<mapper namespace="com.example.mapper.UserInfoMapper">
//命名空间：mapper接口包

    <insert id="add2" parameterType="UserInfo">
        insert into metest.userinfo (username, password, authority)
        values (#{username},#{password},#{authority});
    </insert>

    <delete id="delete" parameterType="Integer">
        delete from metest.userinfo where id = #{id};
    </delete>

    <update id="update" parameterType="UserInfo">
        update metest.userinfo set username=#{username},password=#{password},authority=#{authority}
        where id=#{id};
    </update>

    <select id="queryById" parameterType="Integer" resultType="UserInfo">
        select * from metest.userinfo where id=#{id};
    </select>

    <select id="queryAll" resultType="UserInfo">
        select * from metest.userinfo;
    </select>
</mapper>

来源：https://blog.csdn.net/qq_44973159/article/details/105441783
注意是：返回的类型的类的全限定名／别名，集合可以包含的类型！！

mapper接口：

import com.example.pojo.UserInfo;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;
@Repository
@Mapper
public interface UserInfoMapper {

    /**
     * 增加一条数据
     * @param userInfo 数据
     */
    void add(UserInfo userInfo);

    /**
     * 删除一条数据
     * @param id 被删除数据的id
     */
    void delete(Integer id);
    ．．．

依赖：

ＭyBatis Framework SQL
Persistence framework with support for custom SQL, stored procedures and advanced mappings. MyBatis couples objects with stored procedures or SQL statements using a XML descriptor or annotations.

<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>3.1.8</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.example</groupId>
	<artifactId>demo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>demo</name>
	<description>Demo project for Spring Boot</description>
	<properties>
		<java.version>17</java.version>
	</properties>
	<dependencies>
<!--		新加的-->
		<!--springboot+mybatis的依赖-->
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>3.0.0</version>
		</dependency>
		<dependency>
			<groupId>org.springdoc</groupId>
			<artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
			<version>2.0.2</version>
		</dependency>
		<!-- 官方建议是springdoc替代springfox-->
		<dependency>
			<groupId>org.springdoc</groupId>
			<artifactId>springdoc-openapi-starter-webmvc-api</artifactId>
			<version>2.0.2</version>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
		<!--		１！！！！！！！！！！！！！！！！！！！！！１-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-jdbc</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>com.mysql</groupId>
			<artifactId>mysql-connector-j</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.xmlunit</groupId>
			<artifactId>xmlunit-core</artifactId>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<configuration>
					<image>
						<builder>paketobuildpacks/builder-jammy-base:latest</builder>
					</image>
				</configuration>
			</plugin>
		</plugins>
	</build>

在spring　Initializr
在这里插入图片描述
MyBatis 框架是一个持久化框架，支持自定义 SQL、存储过程和高级映射。MyBatis 使用 XML 描述符或注解将对象与存储过程或 SQL 语句进行耦合。

Spring Web 是使用 Spring MVC 构建 Web 应用程序，包括 RESTful 应用程序。默认使用 Apache Tomcat 作为嵌入式容器。

JDBC API 是一个用于连接和查询数据库的数据库连接 API。MySQL Driver 是用于连接 MySQL 数据库的 JDBC 驱动程序。

//关于springboot版本和swagger版本冲突问题看这里https://blog.csdn.net/qq_33334411/article/details/125655201

这些依赖的作用如下：

org.springframework.boot:spring-boot-starter-jdbc是一个Spring Boot的starter，用于简化在Spring Boot应用程序中**使用JDBC进行数据库访问的配置和集成。它包含了必要的依赖和自动配置，**使得开发人员可以更容易地使用JDBC来访问和操作数据库。通过使用这个starter，开发人员可以快速地搭建一个基于JDBC的数据库访问层，并且可以利用Spring Boot的自动配置功能来简化配置过程。

＿＿＿＿＿＿

org.springdoc:springdoc-openapi-starter-webmvc-ui:2.0.2 和 org.springdoc:springdoc-openapi-starter-webmvc-api:2.0.2：这些依赖用于集成OpenAPI（以前称为Swagger）到Spring Boot应用程序中，以便生成API文档和提供交互式API文档UI。

org.projectlombok:lombok：Lombok是一个Java库，用于自动插入编辑器和构建工具中的样板代码，从而简化Java代码的开发。

org.springframework.boot:spring-boot-starter-jdbc：这个starter简化了在Spring Boot应用程序中使用JDBC进行数据库访问的配置和集成。

org.springframework.boot:spring-boot-starter-web：这个starter包含了构建Web应用程序所需的核心功能，包括Spring MVC和嵌入式Tomcat服务器。

com.mysql:mysql-connector-j：这是MySQL官方提供的JDBC驱动程序，用于在Java应用程序中连接和操作MySQL数据库。

org.springframework.boot:spring-boot-starter-test：这个starter包含了在Spring Boot应用程序中进行单元测试和集成测试所需的依赖。

org.xmlunit:xmlunit-core：XMLUnit是一个Java库，用于执行XML比较和验证。

要实现一个Spring Boot项目的连接MySQL的增删改查功能，通常需要以下依赖：
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
`spring-boot-starter-data-jpa`是一个Spring Boot starter，用于简化在Spring Boot应用程序中使用JPA（Java Persistence API）进行数据库访问的配置和集成。它包含了一系列依赖和默认配置，使得在Spring Boot应用程序中使用JPA变得更加简单和快速。

具体来说，`spring-boot-starter-data-jpa`包含了以下功能和依赖：

1. Spring Data JPA：一个用于简化数据访问层开发的框架，它提供了一种基于JPA的仓库模式来操作数据。
2. Hibernate：一个流行的JPA实现，用于将Java对象映射到数据库表。
3. 数据库连接池：通常会集成一个默认的数据库连接池，比如HikariCP。
4. Spring Transaction：用于管理事务的功能，以确保数据库操作的一致性和完整性。
5. 其他相关的依赖和默认配置，比如实体管理器、数据源配置等。

使用`spring-boot-starter-data-jpa`可以大大简化在Spring Boot应用程序中使用JPA进行数据库访问的配置和集成，同时提供了一些默认的最佳实践和配置，使得开发者可以更专注于业务逻辑的实现而不是繁琐的配置。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>
这些依赖包括了Spring Boot Data JPA starter（用于简化使用JPA进行数据库访问的配置和集成）、Spring Boot Web starter（用于构建Web应用程序）、以及MySQL JDBC驱动程序。同时，还需要进行相应的数据库配置和实体类的定义，以及编写相应的Repository接口和Service类来实现数据库的增删改查功能。

在这里插入图片描述
ｐｏｊｏ类：

package com.example.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

//使用@Data自动生成需要的get、set
@Data
//使用@AllArgsConstructor自动生成有参构造
@AllArgsConstructor
//使用@NoArgsConstructor自动生成无参构造
@NoArgsConstructor
public class UserInfo {

    private Integer id;
    private String username;
    private String password;
    private String authority;

    @Override
    public String toString() {
        return "UserInfo{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", authority='" + authority + '\'' +
                '}';
    }

  
}

ｍａｐｐｅｒ包：

@Repository是属于Spring的注解。它用来标注访问层的类（Dao层），它表示一个仓库，主要用于封装对于数据库的访问。其实现方式与@Component注解相同，只是为了明确类的作用而设立。
即@Repository是@Component注解的一个派生品，与@Service和@Controller都可以理解为@Component注解的扩展。他们的作用都是在类上实例化bean，并把当前类对象的实现类交给spring容器进行管理。

换句话说，@Repository注解修饰哪个类表明这个类具有对数据库CRUD的功能，用在持久层的接口上。

另外，作为spring的注解，他还能把所标注的类中抛出的数据访问异常封装为spring的数据访问异常类型
————————————————

                        版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

原文链接：https://blog.csdn.net/fengling_smile/article/details/129853866

import com.example.pojo.UserInfo;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;
@Repository
@Mapper
public interface UserInfoMapper {

    /**
     * 增加一条数据
     * @param userInfo 数据
     */
    void add(UserInfo userInfo);

    /**
     * 删除一条数据
     * @param id 被删除数据的id
     */
    void delete(Integer id);

    /**
     * 修改一条数据
     * @param userInfo 修改的数据
     */
    void update(UserInfo userInfo);

    /**
     * 根据id去查询一条数据
     * @param id 查询的id
     */
    UserInfo queryById(Integer id);

    /**
     * 查询全部数据
     * @return
     */
    List<UserInfo> queryAll();
}

1、@Repository是spring的注解，@Mapper是mybatis的注解。
2、@Repository与@Mapper都可以使用，二者可以同时出现，也可以单一使用。
3、单独使用@Repository，需要配合使用MapperScannerConfigurer或者@MapperScan注解。
4、单独使用@Mapper时，可能会在编辑器出现警告，不影响程序运行。可以配合使用@Repository消除警告。（也可以在编辑器中设置忽略这种警告）
————————————————

                        版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

原文链接：https://blog.csdn.net/fengling_smile/article/details/129853866

cont’ro’ller

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;


//一般只需要作为接口放回JSON格式数据的话推荐使用@RestController
@Controller
@RequestMapping(value = "/test")
public class UserInfoController {
    //获取到UserInfoService
    @Autowired
    private UserInfoService userInfoService;

    //Get请求
    @GetMapping
    //@ResponseBody 注释后表示放回的是字符串
    @ResponseBody
    public String queryAll(){
        List<UserInfo> userInfoList = userInfoService.queryAll();
        return String.valueOf(userInfoList);
    }

    @GetMapping("/{id}")
    @ResponseBody
    public String queryById(@PathVariable(value = "id")Integer id) {
        UserInfo userInfo = userInfoService.queryById(id);
        List<UserInfo> userInfoList = new ArrayList<>();
        userInfoList.add(userInfo);
        return userInfoList.toString();//发现这里改变返回只九慧00
    }

    //post请求
    //@RequestBody 表示接收请求是JSON格式的数据
    @PostMapping
    @ResponseBody
    public String add(@RequestBody UserInfo userInfo){
        userInfoService.add(userInfo);
        return "添加OK";
    }

    //Delete请求
    @DeleteMapping(value = "/{id}")
    @ResponseBody
    public String delete(@PathVariable("id")Integer id){
        userInfoService.delete(id);
        return "删除成功";
    }

    //Put请求
    @PutMapping("/{id}")
    @ResponseBody
    public String update(@PathVariable("id")Integer id,
                         @RequestBody UserInfo userInfo){
        userInfo.setId(id);
        userInfoService.update(userInfo);
        return "修改成功";
    }
}

王安安的记录

关注

14
点赞
踩
19

收藏

觉得还不错? 一键收藏
1
评论
简单springboot项目，出错+运行成功对比

同时，还需要进行相应的数据库配置和实体类的定义，以及编写相应的Repository接口和Service类来实现数据库的增删改查功能。＇在例如 Java 高级语言中，都会嵌入（支持）SQL 能力，一般我们可以直接在代码或配置文件中编写 SQL 语句，如果一个 SQL 语句在 “编译阶段” 就已经能确定主体结构，那我们称之为静态 SQL，如果一个 SQL 语句在编译阶段无法确定主体结构，需要等到程序真正 “运行时” 才能最终确定，那么我们称之为动态 SQL＇@Repository是属于Spring的注解。
复制链接

扫一扫