Springboot数据库访问JPA

本篇将介绍几种连接数据库的方式。首先我们今天使用JPA进行连接数据库进行测试。

首先我们先得安装一个数据库，我本机是使用虚拟机上进行安装docker，docker安装的mysql数据库。

docker安装

docker的安装直接参考官方文档：

docker常用的命令

我们可以查询命令https://docs.docker.com/engine/reference/commandline/docker/，也可以在docker里边输入docker help查询命令。

docker search  #从docker搜索镜像	Search the Docker Hub for images
docker pull #拉取镜像  Pull an image or a repository from a registry
#拉取的时候可以加上版本号，或者拉取最新的
docker ps #查看当前运行的镜像
docker ps -a #查看所有的，包括停止运行的
docker rename	#给容器修改名字  Rename a container
docker restart	#重启容器  Restart one or more containers
docker run	#创建容器Run a command in a new container
docker rm	#删除容器Remove one or more containers
1
2
3
4
5
6
7
8
9

docker 安装mysql

#拉取mysql
docker pull mysql
#创建容器
docker run -itd -p 3306:3306 --name mysql -e MYSQL_ROOT_PASSWORD=123456 mysql
#查看容器
docker ps
1
2
3
4
5
6

docker ps查看mysql

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
c71ff8eff881 mysql “docker-entrypoint.s…” 40 hours ago Up 18 hours 0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp mysql

命令创建数据库

命令登录mysql

docker exec -it mysql bash
#登录mysql
mysql -u root -p
1
2
3

操作数据库

#创建数据库
 create database dbname;
 #创建数据库test
 create database test; 
 #查看数据库
 show databases;
 #使用选择数据库
 use database; 
 use test;//Database changed
1
2
3
4
5
6
7
8
9

引入依赖

 
    
      org.springframework.boot
      spring-boot-starter-data-jpa
    
    
    
      mysql
      mysql-connector-java
      5.1.47
    
1
2
3
4
5
6
7
8
9
10
11

yml配置

需要配置数据库连接信息以及jpa信息

server:
  port: 8812
spring:
  application:
    name: SpringbootJPA
  #配置数据库
  datasource:
    url: jdbc:mysql://数据库ip:3306/test
    driver-class-name: com.mysql.jdbc.Driver
    username: root
    password: 123456
  jpa:
    hibernate:
      ddl-auto: update #更新或者创建数据表结构
      dialect: org.hibernate.dialect.MySQL8Dialect
    show-sql: true  #控制台显示SQL
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

创建实体类

package com.elite.springboot.Entity;

import lombok.Data;
import lombok.Getter;
import lombok.Setter;
import org.springframework.data.annotation.Id;
import javax.persistence.*;

//使用JPA注解配置映射关系
@Entity //告诉JPA这是一个实体类（和数据表映射的类）
@Table(name = "user") //@Table,指定表明，不指定默认和类名字一样
@Getter
@Setter
@Data
public class User {
    @javax.persistence.Id
    @Id //这是一个主键
    @GeneratedValue(strategy = GenerationType.IDENTITY)//自增主键
    private Integer id;
    @Column(name = "user_name", length = 50) //这是和数据表对应的一个列
    private String username;
    @Column(name = "age", length = 3) //这是和数据表对应的一个列
    private Integer age;
    @Column //省略默认列名就是属性名
    private String address;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

创建一个接口UserDao来操作实体类对应的表

package com.elite.springboot.Dao;

import com.elite.springboot.Entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
/**
 * 编写一个UserDao接口来操作实体类User对应的数据表
 */
@Repository
public interface UserDao extends JpaRepository {
}
1
2
3
4
5
6
7
8
9
10
11

提供的核心接口源码

//查找所有的
List findAll();

List findAll(Sort var1);

List findAllById(Iterable var1);

 List saveAll(Iterable var1);

void deleteInBatch(Iterable var1);

void deleteAllInBatch();
//根据ID获取
T getOne(ID var1);

 List findAll(Example var1);

 List findAll(Example var1, Sort var2);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

package com.elite.springboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;


@SpringBootApplication
//需要扫描实体
@EntityScan("com.elite.springboot.Entity")
public class SpringbootJPA {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootJPA.class,args);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

package com.elite.springboot;



import com.elite.springboot.Dao.UserDao;
import com.elite.springboot.Entity.User;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;
import java.util.List;

/**
 * 测试User CRUD
 */
@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest
public class AppTest {

    @Resource
    private UserDao userDao;

    /**
     * 测试新增User
     * @throws Exception
     */
    @Test
    public void insertUser(){
        //select * from user
        //插入的sql日志：insert into user (address, age, user_name) values (?, ?, ?)
        User user = new User();
        user.setUsername("牛奶糖");
        user.setAge(22);
        user.setAddress("xx省市");
        User save = userDao.save(user);
    }

    /**
     * 更新User
     * @throws Exception
     */
    @Test
    public void updateUser() {
        //更新也是调用save方法
        //update user set address=?, age=?, user_name=? where id=?
        User user = new User();
        user.setUsername("牛奶糖");
        user.setId(1);
        user.setAge(24);
        user.setAddress("xx省市");
        userDao.save(user);
    }

    /**
     * 查询用户
     * @throws Exception
     */
    @Test
    public void getUser() {
        User user = userDao.getOne(1);
        System.out.println(user);

    }

    /**
     * 查询用户列表
     */
    @Test
    public void getUserList()  {
        //select user0_.id as id1_0_, user0_.address as address2_0_, user0_.age as age3_0_, user0_.user_name as user_nam4_0_ from user user0_
        List userList = userDao.findAll();
        for (User user:userList){
            System.out.println(user);
        }
        //User(id=1, username=牛奶糖, age=24, address=xx省市)
        //User(id=2, username=tom, age=22, address=guangzhou)
    }
    /**
     * 删除用户
     */
    @Test
    public void DelUser()  {
        //delete from user where id=?
       userDao.deleteById(2);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90