springboot-数据库

最新推荐文章于 2022-05-19 09:12:10 发布
最新推荐文章于 2022-05-19 09:12:10 发布
阅读量650 收藏 1
点赞数
分类专栏： spring-boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Inke88/article/details/74766843
版权

springboot-数据库

MySQL

  • 准备工作，加入数据库的配置和依赖

    为了使用 jpa 和 mysql，在 pom.xml文件中增加依赖。

    <!--jpa-->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

<!--mysql-->
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
</dependency>

    application.yml 配置 mysql 连接信息

    spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test?characterEncoding=utf8
    username: root
    password: root


# jpa

  jpa:
    database: MYSQL
    show-sql: true

# Hibernate ddl auto (validate|create|create-drop|update)

    hibernate:
      ddl-auto: update
      naming-strategy: org.hibernate.cfg.ImprovedNamingStrategy
    properties:
      hibernate:
        dialect: org.hibernate.dialect.MySQL5Dialect

    Person.java

    @Entity
public class Person {

    @Id
    @GeneratedValue
    private Integer id;
    private String name;
    private Integer age;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

    创建接口继承JpaRepository，泛型使用的是

    public interface PersonRespository extends JpaRepository<Person, Integer> {
}

  • 单表简单查询

    HelloController.java

    @RestController
public class HelloController {

    @Autowired
    private PersonRespository personRespository;

    @PostMapping(value = "/addPerson")
    public Person addPerson(@RequestParam(value = "name") String name, @RequestParam(value = "age") Integer age) {
        Person person = new Person();
        person.setName(name);
        person.setAge(age);
        return personRespository.save(person);
    }

        @DeleteMapping(value = "/delPerson/{id}")
    public void delPerson(@PathVariable(value = "id") Integer id) {
        personRespository.delete(id);
    }

    @PutMapping(value = "/updatePerson")
    public Person updatePerson(@RequestParam(value = "id") Integer id, @RequestParam(value = "name") String name, @RequestParam(value = "age") Integer age) {
        Person person = new Person();
        person.setId(id);
        person.setName(name);
        person.setAge(age);
        return personRespository.save(person);
    }

    @GetMapping(value = "/findPerson/{id}")
    public Person findPerson(@PathVariable(value = "id") Integer id) {
        return personRespository.findOne(id);
    }

    @GetMapping(value = "/findPersons")
    public List<Person> findPerson() {
        return personRespository.findAll();
    }
}

  • 单表根据年龄查询

    PersonRespository.java

    增加一个根据年龄查询的抽象方法

    public interface PersonRespository extends JpaRepository<Person, Integer> {
    Person findByAge(Integer age);
}

    HelloController.java

    @RestController
public class HelloController {

    @Autowired
    private PersonRespository personRespository;

    @GetMapping(value = "/findPersonByAge/{age}")
    public Person findPersonByAge(@PathVariable(value = "age") Integer age) {
        return personRespository.findByAge(age);
    }
}


集成 Redis

pom.xml

<!--redis-->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
</dependency>
<!--gson-->
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.2.4</version>
</dependency>

RedisTemplate.java Redis 配置

/**
 * RedisTemplate 初始化
 */
@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
        StringRedisTemplate template = new StringRedisTemplate(factory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

application.yml 配置 redis 连接信息

spring:

# redis 配置，没有密码的话，可以不写 password 或者 password 值不填写
  redis:
    host: 192.168.18.130
    port: 6379
    pool:
      max-idle: 8
      min-idle: 0
      max-active: 8
      max-wait: -1

UserRedis.java 用户模块的 redis 增删改查

@Repository
public class UserRedis {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;


    public void add(String key, Long time, User user) {
        Gson gson = new Gson();
        redisTemplate.opsForValue().set(key, gson.toJson(user), time, TimeUnit.MINUTES);
    }

    public void add(String key, Long time, List<User> users) {
        Gson gson = new Gson();
        redisTemplate.opsForValue().set(key, gson.toJson(users), time, TimeUnit.MINUTES);
    }


    public User get(String key) {
        Gson gson = new Gson();
        User user = null;
        String json = redisTemplate.opsForValue().get(key);
        if (!StringUtils.isEmpty(json))
            user = gson.fromJson(json, User.class);
        return user;
    }

    public List<User> getList(String key) {
        Gson gson = new Gson();
        List<User> ts = null;
        String listJson = redisTemplate.opsForValue().get(key);
        if (!StringUtils.isEmpty(listJson))
            ts = gson.fromJson(listJson, new TypeToken<List<User>>() {
            }.getType());
        return ts;
    }

    public void delete(String key) {
        redisTemplate.opsForValue().getOperations().delete(key);
    }
}

RedisController.java 接口类测试

@RestController
@RequestMapping(value = "/springboot")
public class RedisController {


    private static Logger logger = LoggerFactory.getLogger(RedisController.class);

    @Autowired
    UserRedis userRedis;

    @Autowired
    RoleService roleService;

    @RequestMapping(value = "/getRedis")
    public void getRedis() {
        Department deparment = new Department();
        deparment.setName("开发部");

        Role role = new Role();
        role.setName("admin");

        User user = new User();
        user.setName("user");
        user.setCreatedate(new Date());
        user.setDeparment(deparment);

        List<Role> roles = new ArrayList<>();
        roles.add(role);

        user.setRoles(roles);

        userRedis.delete(this.getClass().getName() + ":userByname:" + user.getName());
        userRedis.add(this.getClass().getName() + ":userByname:" + user.getName(), 10L, user);

        User userRes = userRedis.get(this.getClass().getName() + ":userByname:user");
        Assert.notNull(userRes);
        logger.info("======userRes====== name:{}, deparment:{}, role:{}",
                userRes.getName(), userRes.getDeparment().getName(), userRes.getRoles().get(0).getName());
    }

    @RequestMapping(value = "/springcache_redis_create")
    public Role springcache_redis_create() {
        Role role = new Role();
        role.setName("jack");
        return roleService.create(role);
    }

    @RequestMapping(value = "/springcache_redis_find/{id}", method = RequestMethod.GET)
    public Role springcache_redis_find(@PathVariable(value = "id") Long id) {
        return roleService.findById(id);
    }

    @RequestMapping(value = "/springcache_redis_update/{id}", method = RequestMethod.GET)
    public Role springcache_redis_update(@PathVariable(value = "id") Long id) {
        Role role = roleService.findById(id);
        role.setName("rose");
        return roleService.update(role);
    }

    @RequestMapping(value = "/springcache_redis_delete/{id}", method = RequestMethod.GET)
    public void springcache_redis_delete(@PathVariable(value = "id") Long id) {
        roleService.delete(id);
    }
}


Redis 缓存优化

Spring Cache 注解

结构简单的对象，即没有包含其他对象的实体，可以用 spring cache 的方式使用 redis 缓存，前提是打开 spring cache。

  • Spring Cache 配置

    /**
 * 结构简单的对象，既没有包含其他对象的实体，可以用 spring cache 的方式使用 redis 缓存
 * 前提是打开 spring cache
 */
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
        StringRedisTemplate template = new StringRedisTemplate(factory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }

    /**
     * Spring Cache 配置
     * @param redisTemplate
     * @return
     */
    @Bean
    public CacheManager cacheManager(@SuppressWarnings("rawtypes") RedisTemplate redisTemplate) {
        RedisCacheManager manager = new RedisCacheManager(redisTemplate);
        manager.setDefaultExpiration(43200);//12小时
        return manager;
    }

    /**
     * simpleKey 根据 类名+参数 id 作为唯一标识
     * @Cacheable 存取缓存
     * @CachePut 更新缓存
     * @CacheEvict 删除缓存
     * 注解中的 value 参数是一个 key 的前缀，
     * 并由 keyGenerator 按照一定的规则生成一个唯一的标识
     */
    @Bean
    public KeyGenerator simpleKey() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName() + ":");
                for (Object obj : params) {
                    sb.append(obj.toString());
                }
                return sb.toString();
            }
        };
    }

    /**
     * objectId 根据 类名+参数 id 作为唯一标识
     * @Cacheable 存取缓存
     * @CachePut 更新缓存
     * @CacheEvict 删除缓存
     * 注解中的 value 参数是一个 key 的前缀，
     * 并由 keyGenerator 按照一定的规则生成一个唯一的标识
     */
    @Bean
    public KeyGenerator objectId() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName() + ":");
                try {
                    sb.append(params[0].getClass().getMethod("getId", null).invoke(params[0], null).toString());
                } catch (NoSuchMethodException no) {
                    no.printStackTrace();
                } catch (IllegalAccessException il) {
                    il.printStackTrace();
                } catch (InvocationTargetException iv) {
                    iv.printStackTrace();
                }
                return sb.toString();
            }
        };
    }
}

    RoleService.java 使用 Spring Cache 注解来用 redis 操作。

    @Service
public class RoleService {
    @Autowired
    private RoleRepository roleRepository;

    /**
     * @Cacheable(value = "mysql:findById:role", keyGenerator = "simpleKey")
     * value = "mysql:findById:role" 是一个key 的前缀，并由 keyGenerator 按照一定的规则生成一个唯一的标识
     * @Cacheable 存取缓存
     * @CachePut 更新缓存
     * @CacheEvict 删除缓存
     */

    @Cacheable(value = "mysql:findById:role", keyGenerator = "simpleKey")
    public Role findById(Long id) {
        return roleRepository.findOne(id);
    }

    @CachePut(value = "mysql:findById:role", keyGenerator = "objectId")
    public Role create(Role role) {
        return roleRepository.save(role);
    }

    @CachePut(value = "mysql:findById:role", keyGenerator = "objectId")
    public Role update(Role role) {
        return roleRepository.save(role);
    }

    @CacheEvict(value = "mysql:findById:role", keyGenerator = "simpleKey")
    public void delete(Long id) {
        roleRepository.delete(id);
    }
}

  • 使用 Redis Template，配置可以参考第2章的RedisConfig.java

    @Repository
public class UserRedis {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;


    public void add(String key, Long time, User user) {
        Gson gson = new Gson();
        redisTemplate.opsForValue().set(key, gson.toJson(user), time, TimeUnit.MINUTES);
    }

    public void add(String key, Long time, List<User> users) {
        Gson gson = new Gson();
        redisTemplate.opsForValue().set(key, gson.toJson(users), time, TimeUnit.MINUTES);
    }


    public User get(String key) {
        Gson gson = new Gson();
        User user = null;
        String json = redisTemplate.opsForValue().get(key);
        if (!StringUtils.isEmpty(json))
            user = gson.fromJson(json, User.class);
        return user;
    }

    public List<User> getList(String key) {
        Gson gson = new Gson();
        List<User> ts = null;
        String listJson = redisTemplate.opsForValue().get(key);
        if (!StringUtils.isEmpty(listJson))
            ts = gson.fromJson(listJson, new TypeToken<List<User>>() {
            }.getType());
        return ts;
    }

    public void delete(String key) {
        redisTemplate.opsForValue().getOperations().delete(key);
    }
}

    UserService.java 存储和查询策略，先查询 redis，不存在再查询数据库同时添加到 redis

    /**
 * 先查询 redis，不存在再查询数据库同时添加到 redis
 */
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    @Autowired
    private UserRedis userRedis;
    private static final String keyHead = "mysql:get:user:";

    public User findById(Long id) {
        User user = userRedis.get(keyHead + id);
        if (user == null) {
            user = userRepository.findOne(id);
            if (user != null)
                userRedis.add(keyHead + id, 30L, user);
        }
        return user;
    }

    public User create(User user) {
        User newUser = userRepository.save(user);
        if (newUser != null)
            userRedis.add(keyHead + newUser.getId(), 30L, newUser);
        return newUser;
    }

    public User update(User user) {
        if (user != null) {
            userRedis.delete(keyHead + user.getId());
            userRedis.add(keyHead + user.getId(), 30L, user);
        }
        return userRepository.save(user);
    }

    public void delete(Long id) {
        userRedis.delete(keyHead + id);
        userRepository.delete(id);
    }

}


提高数据库访问性能

Druid

pom.xml 增加 druid 依赖

<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>druid</artifactId>
  <version>1.0.9</version>
</dependency>
server:
  port: 8080
  tomcat:
    uri-encoding: utf-8
spring:
#系统默认的 DataSource
#  datasource:
#    url: jdbc:mysql://localhost:3306/test?characterEncoding=utf8
#    username: root
#    password: root

#阿里的 DruidDataSourc
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/test?characterEncoding=utf8
    username: root
    password: 12345678
    # 初始化大小，最小，最大
    initialSize: 5
    minIdle: 5
    maxActive: 20
    # 配置获取连接等待超时的时间
    maxWait: 60000
    # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
    timeBetweenEvictionRunsMillis: 60000
    # 配置一个连接在池中最小生存的时间，单位是毫秒
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    # 打开PSCache，并且指定每个连接上PSCache的大小
    poolPreparedStatements: true
    maxPoolPreparedStatementPerConnectionSize: 20
    # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
    filters: stat,wall,log4j
    # 通过connectProperties属性来打开mergeSql功能；慢SQL记录
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
    # 合并多个DruidDataSource的监控数据
    #useGlobalDataSourceStat=true

  # jpa
  jpa:
    database: MYSQL
    show-sql: true
  #Hibernate ddl auto (validate|create|create-drop|update)
    hibernate:
      ddl-auto: update
      naming-strategy: org.hibernate.cfg.ImprovedNamingStrategy
    properties:
      hibernate:
        dialect: org.hibernate.dialect.MySQL5Dialect

  # redis 配置，没有密码的话，可以不写 password 或者 password 值不填写
  redis:
    host: 192.168.18.130
    port: 6379
    password:
    pool:
      max-idle: 8
      min-idle: 0
      max-active: 8
      max-wait: -1


事务管理

在方法名称上增加@Transactional，该方法就有事务管理了。

@Service
public class PersonService {

    @Autowired
    private PersonRespository personRespository;

    @Transactional
    public void insertTwo() {
        Person person = new Person();
        person.setName("jack");
        person.setAge(40);
        personRespository.save(person);

        Person person1 = new Person();
        person1.setName("rose");
        person1.setAge(30000);
        int a = 1 / 0;
        personRespository.save(person1);

    }
}


Inke
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot数据库操作
weixin_34128839的博客
01-31 1万+
本篇概述 上一篇中我们已经介绍了在SpringBoot项目中怎么修改默认配置参数，并且我们还掌握了怎么获取配置文件中自定义参数。在这一篇中我们将介绍SpringBoot对数据库的操作。既然是对数据库的操作，那难免有一些配置的参数。例如数据库的连接、数据库账号及数据库密码等。所以掌握上篇中的内容很重要。除此之外，我们还要介绍一下用什么样的技...
SpringBoot ---- 整合JDBC、Druid
学不死就往死里学
08-14 556
SpringData简介 对于数据访问层，无论是 SQL(关系型数据库) 还是 NOSQL(非关系型数据库)，Spring Boot 底层都是采用 Spring Data 的方式进行统一处理。 Spring Boot 底层都是采用 Spring Data 的方式进行统一处理各种数据库，Spring Data 也是 Spring 中与 Spring Boot、Spring Cloud 等齐名的知名项目。 Sping Data 官网：https://spring.io/projects/spring-data
SpringBoot中数据库的配置和使用
龙套的博客
08-16 6万+
文章目录1、MySQL1.1、配置依赖1.2、实体配置1.3、JPA实现持久化1.4、测试 此文忽略Springboot项目的创建以及初始化 学习书籍《深入实践SpringBoot》 1、MySQL 对于传统关系型数据库（如MySQL）来说，SpringBoot使用JPA（Java　Persistence API）资源库实现对数据库的操作。JPA是为POJO（Plain Ordinary J......
SpringBoot操作数据库
AquaMriusC的博客
01-28 6976
SpringBoot数据库
spring boot之数据库
qq_46073943的博客
05-19 3268
Spring Boot 底层针对于MySQL 、Oracle 等数据库都提供了良好的支持，通过 Spring Boot 提供的场景启动器就能够看出来。 Java 程序在进行与 MySQL 的连接时需要通过 JDBC 来实现，JDBC 全称为 Java Data Base Connectivity（Java 数据库连接），主要由接口组成，是一种用于执行 SQL 语句的 Java API，各个数据库厂家基于它各自实现了自己的驱动程序（Driver），如下图所示： Java程序在获取数据库连接时，
Springboot-dms:数据库在线管理工具
04-13
《Springboot-dms：构建高效数据库管理系统的利器》 在当今快速发展的信息技术领域，数据库管理系统的高效性与便捷性成为了企业运维的关键要素。Springboot-dms便是一款基于Spring Boot框架开发的数据库在线管理...
springboot-集成达梦数据库-源代码
03-02
springboot-父子工程-初始版（包含CRUD示例接口） jpa-hibernate-dm: 数据库为{国产达梦数据库},持久层技术为jpa-hibernate mybatis-dm: 数据库为{国产达梦数据库},持久层技术为mybatis mybatis-plus-dm: 数据库为{...
springboot-curd:springboot操作数据库
04-28
springboot-curd 使用jpa操作数据库 GirlRespority.java interface GirlRespority extends JpaRespority<Girl>{} 使用mybatis操作数据库 UserDao.java @Insert( "insert into t_user(id,name,age) values(#{id},#{...
Java开发案例-springboot-53-导出数据库表信息生成Word文档-源代码+文档.rar
05-31
Java开发案例-springboot-53-导出数据库表信息生成Word文档-源代码+文档.rar Java开发案例-springboot-53-导出数据库表信息生成Word文档-源代码+文档.rar Java开发案例-springboot-53-导出数据库表信息生成Word文档-...
Java开发案例-springboot-27-整合Flyway实现数据库版本控制-源代码+文档.rar
最新发布
05-31
Java开发案例-springboot-27-整合Flyway实现数据库版本控制-源代码+文档.rar Java开发案例-springboot-27-整合Flyway实现数据库版本控制-源代码+文档.rar Java开发案例-springboot-27-整合Flyway实现数据库版本控制-...
SpringBoot（3）之SpringBoot访问数据库
Karen博客
10-19 1万+
SpringBoot_3 SpringBoot访问数据库
SpringBoot使用数据库
大老杨的博客
03-28 3213
这一篇简单介绍一下SpringBoot配置数据库的配置（依赖和application.properties）,以下全是以本地数据库为例子，具体用户名密码地址都根据实际去修改。 Mysql数据库： pom文件： &lt;dependency&gt; &lt;groupId&gt;mysql&lt;/groupId&gt; &lt;artifactId&gt;mysql-co...
Springboot项目搭建（前端到数据库，超详细）
小白一个
02-11 12万+
下面详细谈谈我的第一个springboot项目搭建，希望会给还在摸索的同学一点帮助。 项目说明： 开发环境：Eclipse 4.42 框架：Springboot 工具：Maven 前端：Html、Thymeleaf 后台：Hibernate 数据库：Mysql 为什么要搭建Springboot项目？ 教科书式的阐述这里就不说了，我就总结为两个词语 “简单、方便”。 为了更...
Spring Boot JDBC 连接数据库
热门推荐
小单的博客专栏
01-12 14万+
文本将对在Spring Boot构建的Web应用中，基于MYSQL数据库的几种数据库连接方式进行介绍。 包括JDBC、JPA、MyBatis、多数据源和事务。JDBC1、属性配置文件（application.properties）spring.datasource.url=jdbc:mysql://localhost:3306/test spring.datasource.username=roo
SpringBoot学习系列(十一)------SpringBoot访问数据库
剑小纯的夜话白鹭
11-02 3万+
SpringBoot学习系列(十一)------SpringBoot访问数据库 前言 在项目开发中,数据库的访问是必不可少的,对于数据访问层,无论是SQL还是NoSql,SpringBoot默认采用整合Spring Data的方式进行统一处理,添加了大量的自动配置,屏蔽了很多设置.引入各种Template或Repository来简化我们对数据访问层的操作,对我们来说只需要进行简单的设置即可. 正文...
springboot连接数据库的三种方式
Victorsb1的博客
07-29 1万+
转载自原链接 使用数据库是开发应用的基本基础，那么，使用Spring Boot如何连接数据库呢？ 前提，需要知道如何建一个Spring Boot项目，可参照：https://www.jianshu.com/p/d6e6c84cd190 一、准备工作： 1、建一个简单的数据库，名为springboot_db，在其下建一个表，名为t_author，脚本如下： 2、添加配置文件，可用使用yaml配置，即application.yml（与application.properties配置文件，没什么太大的区别）连接
Springboot操作数据库
Rk的博客
10-27 3912
一、集成JDBC 1、编写yaml配置文件连接数据库 spring: datasource: username: root password: luolin123 url: jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8 driver-class-name: com.mysql.jdbc.Dri...
spring boot连接数据库并插入数据
qq_38320255的博客
08-01 3万+
使用spring连接数据库并写入数据，以save插入一条数据为例： 1.首先在数据库中建一张数据表名称为 ：user。       其中该数据库的名称为test，id设为主键，自动增长。我们将以name插入一条数据。   2.在eclipse中，用spring boot创建一个项目：右击new--&gt;project,选择Spring Starter Project   3....
SpringBoot开发详解（四）--JDBC操作数据库
尼斯湖水鬼的博客
04-16 2万+
JDBC在Spring Boot中的配置使用JDBC连接数据库： 通过上几篇幅的介绍，我们已经能够构建一个简单的，没有数据库的API接口项目，可是作为一个接口程序，没有数据库就是在耍流氓。那么本文我们就介绍下最简单的通过JDBC连接数据库的操作。POM依赖添加在POM文件中我们需要引入一些依赖来配置数据源，我们在pom.xml中加入以下依赖：<!--数据库连接jdbc依赖--> <dependen
springboot-vue框架设计
10-24
SpringBoot-Vue框架设计是一种基于...6. 数据库设计：设计了系统的数据库结构，包括表结构、字段类型和关系等。 7. 系统功能模块设计：设计了系统的功能模块，包括代理商管理、共享设备管理、产品及套餐管理等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值