3 springboot操作数据库

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

1 springboot配置数据源

  1. Dependencies中选择Spring Web、JDBC API、MySQL Driver

  2. 配置数据源：resources下创建application.yaml

    spring:
  datasource:
    username: root
    password: c50hst
    url: jdbc:mysql://localhost:3306/demo?serverTimezone=UTC&useUnicode=true@characterEncoding=utf-8
    driver-class-name: com.mysql.jdbc.Driver

  3. 测试数据源是否配置成功

    package com.mashibing;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;


@SpringBootTest
class SpringbootDatabaseApplicationTests {
    @Autowired
    DataSource dataSource;

    @Test
    void contextLoads() throws SQLException {
        //springboot默认使用com.zaxxer.hikari.HikariDataSource作为数据源
        System.out.println(dataSource.getClass());
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }
}

  4. crud操作

    1. 获取到了数据源，就可以进一步通过数据源获取到数据库连接(java.sql.Connection)，有了Connection，就可以使用Connection和原生的JDBC语句来操作数据库
    2. 即使不使用第三方数据库操作框架(例如MyBatis)，Spring本身也对原生的JDBC做了轻量级的封装，即org.springframework.jdbc.core.JdbcTemplate
    3. springboot不仅提供了默认的数据源，同时默认配置好了JdbcTemplate放在容器中，开发人员只需自己注入即可使用
    4. JdbcTemplate的自动配置是依赖org.springframework.boot.autoconfigure.jdbc包下的org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration类实现的
    package com.mashibing.contoller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;
import java.util.Map;

@RestController
public class JDBCController {

    @Autowired
    JdbcTemplate jdbcTemplate;

    @GetMapping("/emplist")
    public List<Map<String,Object>> empList(){
        String sql = "select * from emp";
        List<Map<String, Object>> maps = jdbcTemplate.queryForList(sql);
        return maps;
    }

    @GetMapping("/addEmp")
    public String addUser(){
        String sql = "insert into emp(empno,ename) values(1111,'zhangsan')";
        jdbcTemplate.update(sql);
        return "success";
    }

    @GetMapping("/updateEmp/{id}")
    public String updateEmp(@PathVariable("id") Integer id){
        String sql = "update emp set ename=? where empno = "+id;
        String name = "list";
        jdbcTemplate.update(sql,name);
        return "update success";
    }

    @GetMapping("/deleteEmp/{id}")
    public String deleteEmp(@PathVariable("id")Integer id){
        String sql = "delete from emp where empno = "+id;
        jdbcTemplate.update(sql);
        return "delete success";
    }
}

2 自定义数据源

  1. springboot默认使用DataSourceAutoConfiguration类来注入数据源，数据源的配置信息在DataSourceProperties类中存放

  2. 默认使用HikariDataSource数据源，如果想改为使用阿里的druid数据源，需要进行如下操作

  3. 添加druid的maven配置

    <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.12</version>
</dependency>

  4. yaml配置文件中新增spring.datasource.type

    spring:
  datasource:
    username: root
    password: c50hst
    url: jdbc:mysql://localhost:3306/demo?serverTimezone=UTC&useUnicode=true@characterEncoding=utf-8
    driver-class-name: com.mysql.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource

  5. 运行SpringbootDatabaseApplicationTests测试类，发现数据源类型已经更改

3 为druid数据源添加独有配置

  1. yaml

    spring:
  datasource:
    username: root
    password: c50hst
    url: jdbc:mysql://localhost:3306/demo?serverTimezone=UTC&useUnicode=true@characterEncoding=utf-8
    driver-class-name: com.mysql.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource
    #springboot默认提供的数据源的配置类DataSourceProperties中，只有username、password等属性，没有initialSize、minIdle等属性，因此无法将下方内容加载到druid数据源中
    #druid 数据源专有配置
    initialSize: 5
    minIdle: 5
    maxActive: 20
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedStatements: true

  2. 自定义配置类，并将DruidDataSource作为bean交给spring管理

    package com.mashibing.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

@Configuration
public class DruidConfig {
    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DataSource druidDataSource(){
        return new DruidDataSource();
    }
}

  3. 运行SpringbootDatabaseApplicationTests测试类

    DruidDataSource druidDataSource = (DruidDataSource) dataSource;
//打印5，说明配置生效
System.out.println(druidDataSource.getInitialSize());

4 使用druid数据源提供的监控功能

  1. Druid数据源具有监控功能，并提供了一个web界面方便用户进行监控

  2. druid监控的管理控制台的servlet为StatViewServlet、某些请求不想被druid监控时，可以使用WebStatFilter过滤器，druid提供了StatViewServlet和WebStatFilter，但需要手动对它们进行注册

    package com.mashibing;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.servlet.Servlet;
import javax.sql.DataSource;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

@Configuration
public class DruidConfig {
    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DataSource druidDataSource() {
        return new DruidDataSource();
    }

    @Bean
    public ServletRegistrationBean druidServletRegistrationBean() {
        //输入localhost:8080/druid就能进入控制台
        ServletRegistrationBean<Servlet> servletRegistrationBean = new ServletRegistrationBean<>(new StatViewServlet(), "/druid/*");
        Map<String, String> initParams = new HashMap<>();
        //控制台的用户名和密码
        initParams.put("loginUsername", "admin");
        initParams.put("loginPassword", "123456");
        //1. allow：允许谁可以访问
        //a. 表示只有本机可以访问
        //initParams.put("allow", "localhost")
        //b. 为空或者为null时，表示允许所有访问
        //initParams.put("allow", "")：
        initParams.put("allow", "");
        //2. deny：拒绝谁访问
        //initParams.put("deny", "192.168.1.20");表示禁止此ip访问

        servletRegistrationBean.setInitParameters(initParams);
        return servletRegistrationBean;
    }
    
    //某些请求不想进行监控，可以使用过滤器
    @Bean
    public FilterRegistrationBean webStatFilter() {
        FilterRegistrationBean bean = new FilterRegistrationBean();
        bean.setFilter(new WebStatFilter());

        //exclusions：设置哪些请求进行过滤排除掉，从而不进行统计
        Map<String, String> initParams = new HashMap<>();
        initParams.put("exclusions", "*.js,*.css,/druid/*");
        bean.setInitParameters(initParams);

        //"/*" 表示过滤所有请求
        bean.setUrlPatterns(Arrays.asList("/*"));
        return bean;
    }
}

  3. 需要在yaml中新增以下内容从而开启监控

    #配置监控统计拦截的filters
	#stat:监控统计
	#log4j：日志记录
	#wall：防御sql注入
filters: stat,wall,log4j
maxPoolPreparedStatementPerConnectionSize: 20
useGlobalDataSourceStat: true
connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

  4. druid的监控需要log4j依赖，如果不添加，启动报错java.lang.ClassNotFoundException: org.apache.log4j.Priority

    <!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
  <groupId>log4j</groupId>
  <artifactId>log4j</artifactId>
  <version>1.2.17</version>
</dependency>

  5. 输入localhost:8080/emplist，就会调用数据库语句，之后在localhost:8080/druid监控的SQL监控页面中就能看到这个语句

5 springboot配置多数据源

  1. 在spring2.0.1中引入了AbstractRoutingDataSource，该类充当了DataSource的路由中介，能有在运行时，根据determineCurrentLookupKey返回值来动态切换到真正的DataSource上

  2. 该类的targetDataSources属性中可以存放一组有效的数据源，defaultTargetDataSource属性中存放系统默认使用的数据源，我们可以通过自定义一个AbstractRoutingDataSource类型的bean对象替换原有的AbstractRoutingDataSource对象，并重写该类的determineCurrentLookupKey方法从而动态地切换系统使用的数据源

  3. DynamicDataSource：重写AbstractRoutingDataSource，具体注册逻辑在下面DataSourceConfig中完成

    package com.mashibing.mult;

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

import javax.sql.DataSource;
import java.util.Map;

public class DynamicDataSource extends AbstractRoutingDataSource {

    public DynamicDataSource(DataSource defaultTargetDataSource, Map<Object, Object> targetDataSources) {
      	//存放默认使用的数据源
        super.setDefaultTargetDataSource(defaultTargetDataSource);
      	//存放所有的数据源
        super.setTargetDataSources(targetDataSources);
        //用来将targetDataSources的属性写入resolvedDataSources中，真正执行语句时，使用的是resolvedDataSources中的数据源
        super.afterPropertiesSet();
    }

    //返回一个key值，真正使用的数据源会通过targetDataSources.get(key)获取
    @Override
    protected Object determineCurrentLookupKey() {
        return DynamicDataSourceContextHolder.getDataSourceType();
    }
}

  4. DynamicDataSourceContextHolder：该类组合了一个ThreadLocal类型变量，这样就可以保证不同线程获取其使用的数据源时，不互相干扰

    package com.mashibing.mult;

public class DynamicDataSourceContextHolder {

    //使用ThreadLocal维护变量，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本
    private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();

    public static void setDataSourceType(String dataSourceType){
        System.out.printf("切换到{%s}数据源", dataSourceType);
        CONTEXT_HOLDER.set(dataSourceType);
    }

    public static String getDataSourceType(){
        return CONTEXT_HOLDER.get();
    }

    public static void clearDataSourceType(){
        CONTEXT_HOLDER.remove();
    }
}

  5. DataSourceConfig：注入所有的数据源对象、以及刚才创建的DynamicDataSource类的对象

    package com.mashibing.mult;

import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

@Configuration
public class DataSourceConfig {
    @Bean
    @ConfigurationProperties("spring.datasource.remote")
    public DataSource remoteDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties("spring.datasource.local")
    public DataSource localDataSource() {
        return DataSourceBuilder.create().build();
    }
    
    @Bean(name = "dynamicDataSource")
  	//DynamicDataSource实现了AbstractRoutingDataSource，此时spring中会有多个AbstractRoutingDataSource类型的bean，Primary表示，优先使用当前bean对AbstractRoutingDataSource类型的变量进行注入
    @Primary
    public DynamicDataSource dataSource(DataSource remoteDataSource, DataSource localDataSource) {
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put(DataSourceType.REMOTE.name(), remoteDataSource);
        targetDataSources.put(DataSourceType.LOCAL.name(), localDataSource);
        return new DynamicDataSource(remoteDataSource, targetDataSources);
    }
}

  6. application.yaml：DataSourceConfig中通过配置文件中的值初始化数据源，因此需要引入配置文件

    spring:
  datasource:
    local:
      username: root
      password: c50hst
      driver-class-name: com.mysql.jdbc.Driver
      #分别连接c50hst和demo库
      jdbc-url: jdbc:mysql://localhost:3306/c50hst?serverTimezone=UTC&useUnicode=true@characterEncoding=utf-8
    remote:
      username: root
      password: c50hst
      driver-class-name: com.mysql.jdbc.Driver
      jdbc-url: jdbc:mysql://localhost:3306/demo?serverTimezone=UTC&useUnicode=true@characterEncoding=utf-8

  7. DataSourceType：targetDataSources数据源集合中，key值由枚举类DataSourceType中的枚举值决定

    package com.mashibing.mult;

public enum DataSourceType {
    REMOTE,
    LOCAL
}

  8. 此时只要在具体方法中，调用DynamicDataSourceContextHolder.setDataSourceType方法，就可以改变使用的数据源

  9. 为了更加方便地切换注解可以考虑引入一个注解DataSource配置在具体的方法上，然后利用spring AOP的功能，在调用具体方法的前后，自动加入调用DynamicDataSourceContextHolder.setDataSourceType的逻辑，就可以实现根据不同注解，使用不同数据源

  10. DataSource：新增的注解，属性value的值为DataSourceType中定义的枚举值

    package com.mashibing.mult;

import java.lang.annotation.*;
//该注解用在方法上
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataSource {
  	//该注解修饰的方法，所使用的数据源的key值
    DataSourceType value() default DataSourceType.REMOTE;
}

  11. DataSourceAspect：利用AOP在DataSource注解前后，自动根据DataSource的value属性的值，来修改DynamicDataSourceContextHolder中线程环境变量CONTEXT_HOLDER中的值

    package com.mashibing.mult;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
//之前没选中AOP模块，因此需要在springboot官网或maven官网中查找springboot AOP的pom依赖，并加入到pom依赖中
@Aspect
@Order(1)
@Component
public class DataSourceAspect {
		//@annotation表示定义切点为具有指定注解的方法
    @Pointcut("@annotation(com.mashibing.mult.DataSource)")
    public void dsPointCut() {

    }

    @Around("dsPointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method = signature.getMethod();
        DataSource dataSource = method.getAnnotation(DataSource.class);
        if (dataSource != null) {
          	//方法执行前，获取该方法上DataSource注解的value值，放入到DynamicDataSourceContextHolder的CONTEXT_HOLDER属性中
            DynamicDataSourceContextHolder.setDataSourceType(dataSource.value().name());
        }
        try {
          	//DataSource注解修饰的方法的执行
            return point.proceed();
        } finally {
            // 销毁数据源 在执行方法之后
            DynamicDataSourceContextHolder.clearDataSourceType();
        }
    }
}

  12. 测试方法

    package com.mashibing.mult;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;
import java.util.Map;


@RestController
public class EmpController {

    @Autowired
    JdbcTemplate jdbcTemplate;

    @GetMapping("/local")
    @DataSource(value = DataSourceType.LOCAL)
    public List<Map<String, Object>> local(){
        List<Map<String, Object>> maps = jdbcTemplate.queryForList("select * from emp");
        return maps;
    }
    @GetMapping("/remote")
    @DataSource(value = DataSourceType.REMOTE)
    public List<Map<String, Object>> remote(){
        List<Map<String, Object>> maps = jdbcTemplate.queryForList("select * from emp");
        return maps;
    }

}

  13. 启动项目的过程中会发生循环依赖的问题，需要让springboot默认注入数据源的DataSourceAutoConfiguration类失效

    package com.mashibing;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;

@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
public class SpringbootDatabaseApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootDatabaseApplication.class, args);
    }
}

  14. 此时输入http://localhost:8080/remote和http://localhost:8080/local会获取到不同的查询结果，说明配置的多数据源生效

6 springboot整合mybatis

  1. Dependencies中多选一项MyBatis Framework

    <!--pom依赖中会自动增加下面的依赖-->
<dependency>
  <groupId>org.mybatis.spring.boot</groupId>
  <artifactId>mybatis-spring-boot-starter</artifactId>
  <version>2.1.3</version>
</dependency>

  2. Emp：实体类

    package com.mashibing.entity;

import java.sql.Date;
import java.util.Objects;

public class Emp {
    private Integer empno;
    private String ename;
    private String job;
    private Integer mgr;
    private Date hiredate;
    private Double sal;
    private Double comm;
    private Integer deptno;

    public Emp() {
    }

    public Emp(Integer empno, String ename) {
        this.empno = empno;
        this.ename = ename;
    }

    public Emp(Integer empno, String ename, String job, Integer mgr, Date hiredate, Double sal, Double comm, Integer deptno) {
        this.empno = empno;
        this.ename = ename;
        this.job = job;
        this.mgr = mgr;
        this.hiredate = hiredate;
        this.sal = sal;
        this.comm = comm;
        this.deptno = deptno;
    }

    public Integer getEmpno() {
        return empno;
    }

    public void setEmpno(Integer empno) {
        this.empno = empno;
    }

    public String getEname() {
        return ename;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    public Integer getMgr() {
        return mgr;
    }

    public void setMgr(Integer mgr) {
        this.mgr = mgr;
    }

    public Date getHiredate() {
        return hiredate;
    }

    public void setHiredate(Date hiredate) {
        this.hiredate = hiredate;
    }

    public Double getSal() {
        return sal;
    }

    public void setSal(Double sal) {
        this.sal = sal;
    }

    public Double getComm() {
        return comm;
    }

    public void setComm(Double comm) {
        this.comm = comm;
    }

    public Integer getDeptno() {
        return deptno;
    }

    public void setDeptno(Integer deptno) {
        this.deptno = deptno;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Emp)) return false;
        Emp emp = (Emp) o;
        return Objects.equals(empno, emp.empno) &&
                Objects.equals(ename, emp.ename) &&
                Objects.equals(job, emp.job) &&
                Objects.equals(mgr, emp.mgr) &&
                Objects.equals(hiredate, emp.hiredate) &&
                Objects.equals(sal, emp.sal) &&
                Objects.equals(comm, emp.comm) &&
                Objects.equals(deptno, emp.deptno);
    }

    @Override
    public int hashCode() {

        return Objects.hash(empno, ename, job, mgr, hiredate, sal, comm, deptno);
    }

    @Override
    public String toString() {
        return "Emp{" +
                "empno=" + empno +
                ", ename='" + ename + '\'' +
                ", job='" + job + '\'' +
                ", mgr=" + mgr +
                ", hiredate=" + hiredate +
                ", sal=" + sal +
                ", comm=" + comm +
                ", deptno=" + deptno +
                '}';
    }
}

  3. EmpMapper：Mapper接口

    package com.mashibing.mapper;

import com.mashibing.entity.Emp;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;
//@Mapper有两个作用，1是会将下方接口实例化后交给spring管理，2是允许使用注解方式，不必再定义xml
@Mapper
//@Repository作用为交给spring容器管理，但此处@Mapper已经达到了这个目的，本身不用再写@Repository，不过发现不写@Repository会导致自动注入EmpMapper处编译报错，虽然不影响启动和执行
@Repository
public interface EmpMapper {

    List<Emp> selectEmp();

    Emp selectEmpById(Integer empno);

    Integer addEmp(Emp emp);

    Integer updateEmp(Emp emp);

    Integer deleteEmp(Integer empno);
}

  4. 在resources下创建Emp.xml文件

    <?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mashibing.mapper.EmpMapper">

    <select id="selectEmp" resultType="Emp">
    select * from emp
  </select>

    <select id="selectEmpById" resultType="Emp">
    select * from emp where empno = #{empno}
    </select>

    <insert id="addEmp" parameterType="Emp">
    insert into emp (empno,ename) values (#{empno},#{ename})
    </insert>

    <update id="updateEmp" parameterType="Emp">
    update emp set ename=#{ename} where empno = #{empno}
    </update>

    <delete id="deleteEmp" parameterType="int">
    delete from emp where empno = #{empno}
</delete>
</mapper>

  5. yaml配置文件

    spring:
  datasource:
    username: root
    password: c50hst
    url: jdbc:mysql://localhost:3306/demo?serverTimezone=UTC&useUnicode=true@characterEncoding=utf-8
    driver-class-name: com.mysql.jdbc.Driver
mybatis:
  #配置文件位置
  mapper-locations: classpath:*.xml
  #相当于mybatis配置文件中的typeAliases，定义之后，xml中就可以使用类名替代类的全限定名，如果在xml中都使用的是全限定类名，此项就不必定义
  type-aliases-package: com.mashibing.entity

  6. 编写controller进行测试

    package com.mashibing.contoller;

import com.mashibing.entity.Emp;
import com.mashibing.mapper.EmpMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class EmpController {
    @Autowired
    private EmpMapper empMapper;

    //选择全部用户
    @GetMapping("/selectEmp")
    public String selectEmp(){
        List<Emp> emps = empMapper.selectEmp();
        for (Emp Emp : emps) {
            System.out.println(Emp);
        }
        return "ok";
    }
    //根据id选择用户
    @GetMapping("/selectEmpById")
    public String selectEmpById(){
        Emp emp = empMapper.selectEmpById(1234);
        System.out.println(emp);
        return "ok";
    }
    //添加一个用户
    @GetMapping("/addEmp")
    public String addEmp(){
        empMapper.addEmp(new Emp(1234,"heheda"));
        return "ok";
    }
    //修改一个用户
    @GetMapping("/updateEmp")
    public String updateEmp(){
        empMapper.updateEmp(new Emp(1234,"heihei"));
        return "ok";
    }
    //根据id删除用户
    @GetMapping("/deleteEmp")
    public String deleteEmp(){
        empMapper.deleteEmp(1234);
        return "ok";
    }
}
含低调
关注
专栏目录
【追光者系列】Springboot 2.0选择HikariCP作为默认数据库连接池的理由
weixin_34205826的博客
04-26 6643
摘要: 本文非原创，是笔者搜集了一些HikariCP相关的资料整理给大家的介绍，主要讲解了为什么sb2选择了hikariCP以及HikariCP为什么这么快。 1.这是一个系列，有兴趣的朋友可以持续关注 2.如果你有HikariCP使用上的问题，可以给我留言，我们一起沟通讨论 3.希望大家可以提供我一些案例，我也希望可以支持你们做一些调优
SpringBoot数据库操作
weixin_34128839的博客
01-31 1万+
本篇概述 上一篇中我们已经介绍了在SpringBoot项目中怎么修改默认配置参数，并且我们还掌握了怎么获取配置文件中自定义参数。在这一篇中我们将介绍SpringBoot对数据库的操作。既然是对数据库的操作，那难免有一些配置的参数。例如数据库的连接、数据库账号及数据库密码等。所以掌握上篇中的内容很重要。除此之外，我们还要介绍一下用什么样的技...
JDBC连接数据库 ---- Java进阶篇
RONG_YAO的博客
05-31 267
一.jdbc基本概念 jdbc的全称：Java DataBase Connectivity 通俗的讲就是：使用Java代码发送sql语句，就是jdbc 使用jdbc发送sql语句的前提: 登录数据库服务器(数据库的ip，端口，数据库的用户名，密码) private string url = "JDBC:mysql://localhost:3306/demo06"; ...
SpringBoot的数据库操作
zhangbijun1230的专栏
05-14 9168
SpringBoot的数据库操作 1.添加依赖，一个是我们数据库也要用到的data-jpa(简化程序与数据库之间的交互)，一个数据库驱动。（文件名：pom.xml）,基本的配置在建好项目的时候就有了，只需把这个添加。我只是针对这个范围，其他项目也要找自己加 <dependency> <groupId>org.springframework.boot&...
SpringBoot实现简单的登录注册（超级详细）
我的青春一去不复返
05-22 5万+
第一步：建立简单的项目 第二步：建一个简单的数据表 第三步：配置文件如下： pom.xml文件配置： <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://mav
国产数据库+ Springboot操作示例
03-16
在“国产数据库+ Springboot操作示例”中，我们可能涉及到的国产数据库有如OceanBase、TiDB、GBase、神通数据库等。这些数据库均具有高性能、高可用性和扩展性，且支持SQL标准，能够满足企业级应用的需求。其中，...
26、SpringBoot操作数据库.pdf
04-30
SpringBoot操作数据库的相关知识点： 1. SpringData简介：SpringData是Spring家族中的一个核心项目，它的目的是为了简化数据访问层（Data Access Layer）的编程工作。它支持SQL数据库和NoSQL数据库，为各种数据库...
springboot-curd:springboot操作数据库
04-28
使用jpa操作数据库 GirlRespority.java interface GirlRespority extends JpaRespority<Girl>{} 使用mybatis操作数据库 UserDao.java @Insert( "insert into t_user(id,name,age) values(#{id},#{name},#{age})" ) ...
Springboot连接数据库的demo
域清风
08-21 2093
SpringBoot的简单使用 1.启动类 @SpringBootApplication 是spring boot的核心注解，包含了@ComponentScan、@Configuration@EnableAutoConfiguration注解。 @ComponentScan 组件扫描，可自动发现和装配一些Bean。@Configuration 等同于spring的XML配置文件； @EnableA...
SpringBoot中操作数据库
怕什么真理无穷，进一寸有一寸的欢喜。即使开了一辆老掉牙的破车，只要在前行就好，偶尔吹点小风，这就是幸
01-30 2835
1：创建springboot的web项目。 2：加入依赖 <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>2.2.1</version> </de
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操作数据库
wunianisme的博客
03-31 1786
SpringData简介 对于数据访问层，无论是SQL还是NoSQL，在SpringBoot 底层都是采用SpringData来进行封装的。 官网地址：https://spring.io/projects/spring-data 使用IDEA构建项目时，我们可以勾选SpringData相关依赖。 如上图界面所示，Spring提供了很多工具供我们使用，它封装了大量的模板，在Template En...
IDEA搭建SpringBoot并实现简单数据库操作
JavaFeng
03-05 1万+
文章目录前言IDEA搭建SpringBoot新建项目配置及启动配置启动简单功能的实现页面输出文本或返回JSON跳转模板（templates文件夹下的HTML）实现JPA增删查改数据库表创建实体类Dao查询接口控制器方法HTML模板页面效果展示坑和知识点 前言 此文章讲解使用IDEA搭建SpringBoot项目，并实现简单的增删查改功能，在搭建过程中遇到了很多坑。 SpringBoot真的是非常的简...
springboot实现最基础的登录注册功能(步骤详细，逻辑清晰)
qq_44697268的博客
08-15 3万+
springboot实现最基础的登录注册功能
jdbc:mysql://localhost:3306/student?serverTimezone=CTT&useUnicode=true&characterEncoding=utf-8时报错
NorthSmile的博客
04-05 7281
在学习连接池的时候需要配置tomcat/conf/context.xml文件， 我刚就因为我一个转义字符，被搞到崩溃！！！ 一直找不到哪里出错 在网上搜了半天以后终于解决： mysql的url在填写时一定注意将&改为&amp;(转义字符) jdbc:mysql://localhost:3306/student?serverTimezone=CTT&amp;useUnicod...
Spring Boot集成Mybatis实现数据库操作
夜影风个人空间
05-14 6586
1. 引言 在项目开发中， 我们经常需要使用数据库操作， 而针对Java开发中的数据库持久化技术和框架包括：基础JDBC、JPA、MyBatis、Hibernate等。 近期接手一个项目开发工作， 使用Spring Boot + Mybatis技术进行开发， 现就Spring Boot与Mybatis集成的相关配置与操作记录做一下记录。 1.1 开发环境 JDK 1.8 Intelli...
5.C-Demo-排序
最新发布
09-20
5.C-Demo-排序_快速排序
springboot 查询数据库
07-30
回答: 在SpringBoot中查询数据库需要进行以下步骤： 1. 创建SpringBoot项目并添加数据库相关的依赖。 2. 配置SpringBoot核心配置文件，包括数据库连接信息和MyBatis配置。 3. 编写数据库实体类（Pojo层）和DAO层。 4...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值