简单的实现springboot对mysql的调试连接（环境：Vscode）

你tm看不懂我头剁给你。

首先你得有个mysql和一个springboot项目。

 我这里实现的功能是将用户的名称和密码通过url的方式传入数据库。

第一步：

pom.xml文件里加上依赖：

		
            org.springframework.boot
            spring-boot-starter-data-jpa
        
        
        
            mysql
            mysql-connector-java
           

第二步：

更改你的配置文件application.properties

#访问的接入端口
server.port=8088
#你的url根目录
# server.serverlet.context-path=/tuling

#你的访问数据库的路由地址，localhost:127.0.0.1(本机地址) 3306(数据库访问的端口，这个是自己在数据库设置的， denglu(你的数据库名称))
spring.datasource.url=jdbc:mysql://localhost:3306/denglu?useUnicode=true&characterEncoding=utf8&useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=GMT%2B8
#登录数据库的用户名
spring.datasource.username=root
#登录数据库的密码
spring.datasource.password=Zz457178918
#下面这些默认就可以
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.properties.hibernate.hbm2ddl.auto=update
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
spring.jpa.show-sql= true

详情配置mysql的配置看下面这个代码：注意这个是yml格式（这个同样也是配置文件允许的格式哦），你当然也可以直接copy下面这个，自己改。

spring:
    datasource:
#      数据源
        type: com.alibaba.druid.pool.DruidDataSource
#      数据库连接驱动
        driverClassName: com.mysql.jdbc.Driver
#
        druid:
            default:  #默认数据源
#
              url: jdbc:mysql://localhost:3306/数据库?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8
              username: 账户
              password: 密码
#           初始化建立的物理连接数
            initial-size: 10
#           最大连接池数量
            max-active: 1000
#           最小连接池数量
            min-idle: 10
#           获取连接时最大等待时间
            max-wait: 60000
#            是否缓存preparedStatement
            pool-prepared-statements: true
             # 要启用PSCache，必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true。
            max-pool-prepared-statement-per-connection-size: 20
#             有两个含义：1) Destroy线程会检测连接的间隔时间，如果连接空闲时间大于等于minEvictableIdleTimeMillis则关闭物理连接。
#                        2) testWhileIdle的判断依据，详细看testWhileIdle属性的说明
            time-between-eviction-runs-millis: 60000
#            连接保持空闲而不被驱逐的最小时间
            min-evictable-idle-time-millis: 300000
#            用来检测连接是否有效的sql，要求是一个查询语句，常用SELECT 1 FROM DUAL。
            validation-query: SELECT 1 FROM DUAL
#            建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
            test-while-idle: true
#            申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。
            test-on-borrow: false
#            归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。
            test-on-return: false
#            监控页面相关配置
            stat-view-servlet:
                enabled: true
                url-pattern: /druid/
                #login-username: admin
                #login-password: 123456
#                filter相关配置
            filter:
                stat:
                    log-slow-sql: true
                    slow-sql-millis: 1000
                    merge-sql: true
                wall:
                    config:
                        multi-statement-allow: true

改了上面这些祝贺你基本环境配置的差不多了.

下面来码代码：

这个是我项目下的src文件结构，红框框标起来的是待会儿要写的

 首先你得有个User的实体类吧，在你的DemoApplication.java的同级目录下新建一个文件夹专门用来放实体类，我这里就叫enity

下面粘User.java代码，我全写了注释，不到迫不得已我就不细讲了。

package lmx.demo.enity;


import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

//表明我下面写的是实体类
@Entity
//创建数据库中的表，我这边叫new
@Table(name = "new")

public class User implements Serializable {

    private static final long serialVersionUID = 1L;
//标注用于声明一个实体类的属性映射为数据库的主键列
    @Id
//用于标注主键的生成策略，通过strategy 属性指定。默认情况下，JPA 自动选择一个最适合底层数据库的主键生成策略：SqlServer对应identity，MySQL 对应 auto increment。 
    @GeneratedValue
//id 为主键
    private Long id;
//表中的列
    @Column(name = "username")
    private String userName;
//表中的列
    @Column(name = "password")
    private String passWord;

//User的默认构造函数
    public User() {
        super();
    }
    

//User的构造函数
    public User(String userName, String passWord) {
        super();
        this.userName = userName;
        this.passWord = passWord;
    }

//获取主键id
    public Long getId() {
        return id;
    }
//设置主键id
    public void setId(Long id) {
        this.id = id;
    }
//获得用户姓名
    public String getUserName() {
        return userName;
    }
// 设置用户姓名
    public void setUserName(String userName) {
        this.userName = userName;
    }
// 得到密码
    public String getPassWord() {
        return passWord;
    }
// 设置密码
    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }

}

然后你得有个桥梁连接你的User类和数据库吧，这个就是所谓的dao层。我这项目里的dao层就体现在Userrepository.java中

Userrepository.java

import org.springframework.data.repository.CrudRepository;
import lmx.demo.enity.User;

// 读取数据库的方法：继承CrudRepository，用CrudRepository中提供的方法来读写数据库
// CrudRepository需要传两个类，其中的第一个类User表示数据库操作实体类，第二类Integer表示实体User中id对应的类型。
// 这部分就是网上说的dao层
public interface Userrepository extends CrudRepository {

}

然后你得想办法把这两个东西跟你的网页连接起来吧，所以下面写controller控制器，首先你在DemoApplication.java的同级目录下建一个文件夹（controllers），这个文件夹专门用来放控制器

，我这里的控制器是MainController.java

MainController.java

import org.hibernate.engine.spi.Mapping;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import lmx.demo.enity.Userrepository;
import lmx.demo.enity.User;

@RestController //表示这个类是控制器
@RequestMapping("/sql") // 意味着你的路由由/sql开始
public class MainController {

//它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作。
@Autowired 
// This means to get the bean called userRepository // Which is auto-generated by Spring, we will use it to handle the data
  private Userrepository userRepository;

// Mapping介绍：

//   Spring4.3中引进了｛@GetMapping、@PostMapping、@PutMapping、@DeleteMapping、@PatchMapping｝ 来帮助简化常用的HTTP方法的映射 并更好地表达被注解方法的语义
//   @GetMapping： 处理get请求，传统的RequestMapping来编写应该是@RequestMapping(value = “/get/{id}”, method = RequestMethod.GET)
//   新方法可以简写为：
//   @GetMapping("/get/{id}")
//   @PostMapping： 处理post请求，传统的RequestMapping来编写应该是@RequestMapping(value = “/get/{id}”,method = RequestMethod.POST)
//   新方法可以简写为：
//   @PostMapping("/get/{id}")
//   @PutMapping： 和PostMapping作用等同，都是用来向服务器提交信息。如果是添加信息，倾向于用@PostMapping，如果是更新信息，倾向于用@PutMapping。两者差别不是很明显。
//   @DeleteMapping 删除URL映射，具体没有再实践中用过，不知道好在什么地方
//   @PatchMapping 局部更新
 
@GetMapping(path="/add") // 路由/sql/add

//添加用户
// @RequestParam：将请求参数绑定到你控制器的方法参数上（是springmvc中接收普通参数的注解），说白了就是从前端获取参数

// 语法：@RequestParam(value=”参数名”,required=”true/false”,defaultValue=””)
// value：参数名
// required：是否包含该参数，默认为true，表示该请求路径中必须包含该参数，如果不包含就报错。
// defaultValue：默认参数值，如果设置了该值，required=true将失效，自动为false,如果没有传该参数，就使用默认值

  public String addNewUser (@RequestParam(value="name",required = true) String name ,@RequestParam(value="password",required = true) String password) {
    // @ResponseBody means the returned String is the response, not a view name
    // @RequestParam means it is a parameter from the GET or POST request

    // 声明User对象
    User n = new User();
    // 把前端传过来的用户名和密码放入User对象
    n.setUserName(name);
    n.setPassWord(password);
    // 数据库存一下
    userRepository.save(n);
    //返回saved
    return "Saved";
  }


//返回数据库里的数据
  @RequestMapping(path="/all")//看上面吧,一样的用来确定路由的
//这边待会细讲一下吧
//@responseBody注解的作用是将controller的方法返回的对象通过适当的转换器转换为指定的格式之后，写入到response对象的body区，通常用来返回JSON数据或者是XML
  public @ResponseBody Iterable getAllUsers() {
    // This returns a JSON or XML with the users
    return userRepository.findAll();
  }
}

为啥是Iterable getAllUsers()是这个类型呢？

去看findAll（）源码，人家长这样：

 所以我就不多说了。

下面运行就完事儿了

mvn spring-boot:run   

先看下数据库里有啥:

 空的

然后往数据库里加个用户

 你传多个参数时先？，然后参数之间用&链接

再重新去看数据库

 对吧，就成了。当然我通常喜欢在vscode里面看

 这里vscode链接数据库我就不讲了，你在它那个组件商店里搜一下mysql然后连接一下就完事儿了！