微服务开发（2）-- SpringBoot整合JDBC&Druid&MyBatis

最新推荐文章于 2024-05-04 00:45:13 发布
最新推荐文章于 2024-05-04 00:45:13 发布
阅读量174 收藏
点赞数
分类专栏： 图灵学院
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014437791/article/details/102918974
版权

SpringBoot整合JDBC

代码实现
  1. 导入maven依赖
<?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://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>tuling</artifactId>
        <groupId>com.xiyou</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>chajian</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
    </dependencies>

</project>
  • 因为我们在根项目中已经导入了相关的spring-boot的依赖，所以这里我们只导入自己的相关maven依赖
  1. 配置相关的数据源
server:
  port: 8889

spring:
  datasource:
    username: root
    data-password: root
    url: jdbc:mysql://127.0.0.1:3307/test
    driver-class-name: com.mysql.jdbc.Driver
  1. 测试
package com.xiyou.chajian.controller;

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

import javax.sql.DataSource;

/**
 * @author 92823
 */
@RestController
public class MyDataSourceController {

    @Autowired
    private DataSource dataSource;

    @GetMapping("/test")
    public String test () {
        System.out.println(dataSource.getClass());
        return "ok";
    }

}
  • 这里我们发现注入的dataSource已经是注入了相关的配置。
SpringBoot自动整个JDBC的原理：
  • 我们在第三篇的时候分析了SpringBoot自动注入的原理，这里大概分析下
    在这里插入图片描述
    上面的类是我们数据源的自动装配：即DataSourceAutoConfiguration的配置类，我们圈出来的就是我们自动集成进去的数据源
  • 数据源的自动装配：

（1）Hikari数据源

	/**
	 * Hikari DataSource configuration.
	 */
	@ConditionalOnClass(HikariDataSource.class)
	@ConditionalOnMissingBean(DataSource.class)
	@ConditionalOnProperty(name = "spring.datasource.type", havingValue = "com.zaxxer.hikari.HikariDataSource", matchIfMissing = true)
	static class Hikari {

		@Bean
		@ConfigurationProperties(prefix = "spring.datasource.hikari")
		public HikariDataSource dataSource(DataSourceProperties properties) {
			HikariDataSource dataSource = createDataSource(properties,
					HikariDataSource.class);
			if (StringUtils.hasText(properties.getName())) {
				dataSource.setPoolName(properties.getName());
			}
			return dataSource;
		}

	}

（2）Tomcat连接池的数据源

	/**
	 * Tomcat Pool DataSource configuration.
	 */
	@ConditionalOnClass(org.apache.tomcat.jdbc.pool.DataSource.class)
	@ConditionalOnMissingBean(DataSource.class)
	@ConditionalOnProperty(name = "spring.datasource.type", havingValue = "org.apache.tomcat.jdbc.pool.DataSource", matchIfMissing = true)
	static class Tomcat {
        
        //配置tomcat 连接池的数据源
		@Bean
		@ConfigurationProperties(prefix = "spring.datasource.tomcat")
		public org.apache.tomcat.jdbc.pool.DataSource dataSource(
				DataSourceProperties properties) {
			org.apache.tomcat.jdbc.pool.DataSource dataSource = createDataSource(
					properties, org.apache.tomcat.jdbc.pool.DataSource.class);
			DatabaseDriver databaseDriver = DatabaseDriver
					.fromJdbcUrl(properties.determineUrl());
			String validationQuery = databaseDriver.getValidationQuery();
			if (validationQuery != null) {
				dataSource.setTestOnBorrow(true);
				dataSource.setValidationQuery(validationQuery);
			}
			return dataSource;
		}

	}

（3）Dbcp2连接池的数据源

	/**
	 * DBCP DataSource configuration.
	 */
	@ConditionalOnClass(org.apache.commons.dbcp2.BasicDataSource.class)
	@ConditionalOnMissingBean(DataSource.class)
	@ConditionalOnProperty(name = "spring.datasource.type", havingValue = "org.apache.commons.dbcp2.BasicDataSource", matchIfMissing = true)
	static class Dbcp2 {

		@Bean
		@ConfigurationProperties(prefix = "spring.datasource.dbcp2")
		public org.apache.commons.dbcp2.BasicDataSource dataSource(
				DataSourceProperties properties) {
			return createDataSource(properties,
					org.apache.commons.dbcp2.BasicDataSource.class);
		}

	}

（4）我们可以通过spring.datasource.type来指定具体的数据源

    //通过spring.dataSource.tpye 来指定装配的数据源
	@ConditionalOnMissingBean(DataSource.class)
	@ConditionalOnProperty(name = "spring.datasource.type")
	static class Generic {

		@Bean
		public DataSource dataSource(DataSourceProperties properties) {
			return properties.initializeDataSourceBuilder().build();
		}

	}
  • 我们这时候可以再来看下jdbcTemplate的配置
@Configuration
@ConditionalOnClass({ DataSource.class, JdbcTemplate.class })
@ConditionalOnSingleCandidate(DataSource.class)
@AutoConfigureAfter(DataSourceAutoConfiguration.class)
@EnableConfigurationProperties(JdbcProperties.class)
public class JdbcTemplateAutoConfiguration {

	@Configuration
	static class JdbcTemplateConfiguration {

		private final DataSource dataSource;

		private final JdbcProperties properties;

		JdbcTemplateConfiguration(DataSource dataSource, JdbcProperties properties) {
			this.dataSource = dataSource;
			this.properties = properties;
		}
        
        //jdbcTemplate 配置
		@Bean
		@Primary
		@ConditionalOnMissingBean(JdbcOperations.class)
		public JdbcTemplate jdbcTemplate() {
			JdbcTemplate jdbcTemplate = new JdbcTemplate(this.dataSource);
			JdbcProperties.Template template = this.properties.getTemplate();
			jdbcTemplate.setFetchSize(template.getFetchSize());
			jdbcTemplate.setMaxRows(template.getMaxRows());
			if (template.getQueryTimeout() != null) {
				jdbcTemplate
						.setQueryTimeout((int) template.getQueryTimeout().getSeconds());
			}
			return jdbcTemplate;
		}

	}

    
	@Configuration
	@Import(JdbcTemplateConfiguration.class)
	static class NamedParameterJdbcTemplateConfiguration {

		@Bean
		@Primary
		@ConditionalOnSingleCandidate(JdbcTemplate.class)
		@ConditionalOnMissingBean(NamedParameterJdbcOperations.class)
		public NamedParameterJdbcTemplate namedParameterJdbcTemplate(
				JdbcTemplate jdbcTemplate) {
			return new NamedParameterJdbcTemplate(jdbcTemplate);
		}

	}

}

这就是为什么我们可以直接注入JdbcTemplate了。

SpringBoot整合Druid以及Druid的监控

（1）加入druid的依赖

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

<!--//自定义属性绑定配置-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>
  • 其中spring-boot-configuration-processor的作用是我们默认使用的是yml文件，但是有时候要用xml或者properties文件，就需要这个依赖
  • 注意如果要用properties文件的属性，注入到类的属性中，需要在配置类的开头加上@PropertySource(“classpath:your.properties”)，其余用法与加载yml的配置一样

（2）这里我们需要在yml文件中进行配置，我们先直接对其进行配置
在这里插入图片描述

  • 仔细观察我们发现这样写属性无法映射，因为配置的名字有很多在PO类中是不存在的，PO类如下：
    在这里插入图片描述
  • 我们可以看下注入的结果：
    在这里插入图片描述
    很明显没有映射进去。我们应该怎么映射呢？
    （3）配置我们自己的druid的数据源属性，自己映射
server:
  port: 8889

spring:
  datasource:
    druid:
      username: root
      password: root
      jdbcUrl: jdbc:mysql://127.0.0.1:3307/test
      driverClassName: com.mysql.jdbc.Driver
      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
      #   配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
      filters: stat,wall,log4j
      maxPoolPreparedStatementPerConnectionSize: 20
      useGlobalDataSourceStat: true
      connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500
  • 新增自己将要映射的PO类：
package com.xiyou.chajian.po;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * @author 92823
 */
@Data
@Component
@ConfigurationProperties(prefix = "spring.datasource.druid")
public class DruidDataSourceProperties {

    private String username;

    private String password;

    private String jdbcUrl;

    private String driverClassName;

    private Integer initialSize;

    private Integer maxActive;

    private Integer minIdle;

    private long maxWait;

    private boolean poolPreparedStatements;
}

这里我们利用@ConfigurationProperties(prefix = “spring.datasource.druid”)自动将yml中配置的属性注入到了该类中。

（4）定制config配置类，这里我们注入了数据源，也配置了一个Servlet负责跳转到druid的监控页面，一个过滤器负责拦截请求，去除静态资源等不过滤的字段

package com.xiyou.chajian.config;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import com.xiyou.chajian.po.DruidDataSourceProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
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.sql.DataSource;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

/**
 * @author 92823
 */
@Configuration
// 自动注入到该类中, 该注解负责开启@ConfigurationProperties
@EnableConfigurationProperties(value = DruidDataSourceProperties.class)
public class DruidDataSourceConfig {

    @Autowired
    private DruidDataSourceProperties druidDataSourceProperties;

    /**
     * 注入数据源的相关信息
     * @return
     */
    @Bean
    public DataSource dataSource() {
        System.out.println("这时候已经注入了: " + druidDataSourceProperties);
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setUsername(druidDataSourceProperties.getUsername());
        druidDataSource.setPassword(druidDataSourceProperties.getPassword());
        druidDataSource.setUrl(druidDataSourceProperties.getJdbcUrl());
        druidDataSource.setDriverClassName(druidDataSourceProperties.getDriverClassName());
        druidDataSource.setInitialSize(druidDataSourceProperties.getInitialSize());
        druidDataSource.setMinIdle(druidDataSourceProperties.getMinIdle());
        druidDataSource.setMaxActive(druidDataSourceProperties.getMaxActive());
        druidDataSource.setMaxWait(druidDataSourceProperties.getMaxWait());
        druidDataSourceProperties.setPoolPreparedStatements(druidDataSourceProperties.isPoolPreparedStatements());
        return druidDataSource;
    }


    /**
     * 配置数据源的监控
     * 配置了一个Servlet
     */
    @Bean
    public ServletRegistrationBean statViewServlet() {
        // 该Servlet是人家提供的。
        ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(),"/druid/*");
        Map<String, Object> initParameters = new HashMap<>();
        initParameters.put("loginUsername","admin");
        initParameters.put("loginPassword","123456");
        // 设置用户名和密码
        bean.setInitParameters(initParameters);
        return bean;
    }

    /**
     * 配置一个过滤器
     */
    public FilterRegistrationBean filterRegistrationBean() {
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(new WebStatFilter());
        // 设置过滤的路径
        filterRegistrationBean.setUrlPatterns(Arrays.asList("/*"));
        // 去除不用过滤的路径
        Map<String, Object> initParams = new HashMap<>();
        initParams.put("exclusions", "*.js,*.css,/druid/*");
        filterRegistrationBean.setInitParameters(initParams);
        return filterRegistrationBean;
    }
}
  • 注意，这里的注解@EnableConfigurationProperties负责开启注解@ConfigurationProperties
    （5）观察结果：
  • 可以看到数据源已经注入
这时候已经注入了: DruidDataSourceProperties(username=root, password=root, jdbcUrl=jdbc:mysql://127.0.0.1:3307/test, driverClassName=com.mysql.jdbc.Driver, initialSize=5, maxActive=20, minIdle=5, maxWait=60000, poolPreparedStatements=true)
  • 访问http://localhost:8889/druid/，可以看到对应的监控页面
    在这里插入图片描述
    其中用户名密码就是我们在conf中配置的
Map<String, Object> initParameters = new HashMap<>();
        initParameters.put("loginUsername","admin");
        initParameters.put("loginPassword","123456");
        // 设置用户名和密码
        bean.setInitParameters(initParameters);

SpringBoot整合myBatis

代码实现

（1）pom文件

<?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://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>tuling</artifactId>
        <groupId>com.xiyou</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>mybatis</artifactId>

    <dependencies>
        <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>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.0</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
            <version>5.1.46</version>
        </dependency>
    </dependencies>

</project>

（2）数据库结构

CREATE TABLE `t_users` (
  `user_name` varchar(20) DEFAULT NULL,
  `age` int(100) DEFAULT NULL,
  `id` int(10) NOT NULL AUTO_INCREMENT,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=17 DEFAULT CHARSET=utf8;

（3）yml文件

server:
  port: 8080

spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://127.0.0.1:3306/test
    driver-class-name: com.mysql.jdbc.Driver

# 配置mybatis
mybatis:
  configuration:
    # 开启驼峰命名
    map-underscore-to-camel-case: true
  # 指定配置文件的位置
  mapper-locations: classpath:/mappers/*.xml
  • 注意：这里我们开启了驼峰命名，就是说我们可以将下划线和驼峰相互转换
  • 另外我们开启了xml文件的位置指定，这样我们就可以用xml的形式写sql了

（4）Mapper文件

package com.xiyou.mapepr;

import com.xiyou.po.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

import java.util.List;

/**
 * @author
 */
@Mapper
public interface UserMapper {

    @Select("select * from t_users")
    List<User> selectUsers();

    public User selectUserById(Integer id);
}
  • 我们可以看到这里我们一个用了注解的模式，一个映射到了xml文件中
  • 这里我们是在类上面写了@Mapper而没有在配置类上写@MapperScan

（5）user.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.xiyou.mapepr.UserMapper">
    <select id="selectUserById" parameterType="Integer" resultType="com.xiyou.po.User">
        select * from t_users where id = #{id}
    </select>
</mapper>
  • 该文件是在resources/mappers/user.xml

（6）启动类

package com.xiyou;

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

/**
 * @author
 */
@SpringBootApplication
public class MyBatisApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyBatisApplication.class, args);
    }
}

（7）User

package com.xiyou.po;

import lombok.Data;

/**
 * @author
 * 实体类对应数据库的t_users信息
 */
@Data
public class User {
    private Integer id;
    private Integer age;
    private String userName;
}

（8）Controller类，用来测试

package com.xiyou.controller;

import com.alibaba.fastjson.JSONObject;
import com.xiyou.mapepr.UserMapper;
import com.xiyou.po.User;
import org.springframework.beans.factory.annotation.Autowired;
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;

/**
 * @author
 */
@RestController
public class TestController {

    @Autowired
    private UserMapper userMapper;

    @GetMapping("/test")
    public String test() {
        List<User> users = userMapper.selectUsers();
        return JSONObject.toJSONString(users);
    }

    @GetMapping("/selectUserById/{id}")
    public String selectUserById(@PathVariable Integer id) {
        User user = userMapper.selectUserById(id);
        return JSONObject.toJSONString(user);
    }
}
源码解析
  • 我们还是一样自动注解么，明显看的类是MybatisAutoConfiguration类
  • 该类为我们导入了：
    （1）SqlSessionFactory
    （2）SqlSessionTemplate
    （3）mapperScanner
@org.springframework.context.annotation.Configuration
@ConditionalOnClass({ SqlSessionFactory.class, SqlSessionFactoryBean.class })
@ConditionalOnSingleCandidate(DataSource.class)
@EnableConfigurationProperties(MybatisProperties.class)
@AutoConfigureAfter(DataSourceAutoConfiguration.class)
public class MybatisAutoConfiguration implements InitializingBean {

    
  1:自动装配了 sqlSessionFactory
  @Bean
  @ConditionalOnMissingBean
  public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
    SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
    factory.setDataSource(dataSource);
    factory.setVfs(SpringBootVFS.class);
    if (StringUtils.hasText(this.properties.getConfigLocation())) {
      factory.setConfigLocation(this.resourceLoader.getResource(this.properties.getConfigLocation()));
    }
    applyConfiguration(factory);
    if (this.properties.getConfigurationProperties() != null) {
      factory.setConfigurationProperties(this.properties.getConfigurationProperties());
    }
    if (!ObjectUtils.isEmpty(this.interceptors)) {
      factory.setPlugins(this.interceptors);
    }
    if (this.databaseIdProvider != null) {
      factory.setDatabaseIdProvider(this.databaseIdProvider);
    }
    if (StringUtils.hasLength(this.properties.getTypeAliasesPackage())) {
      factory.setTypeAliasesPackage(this.properties.getTypeAliasesPackage());
    }
    if (this.properties.getTypeAliasesSuperType() != null) {
      factory.setTypeAliasesSuperType(this.properties.getTypeAliasesSuperType());
    }
    if (StringUtils.hasLength(this.properties.getTypeHandlersPackage())) {
      factory.setTypeHandlersPackage(this.properties.getTypeHandlersPackage());
    }
    if (!ObjectUtils.isEmpty(this.properties.resolveMapperLocations())) {
      factory.setMapperLocations(this.properties.resolveMapperLocations());
    }

    return factory.getObject();
  }

    
  2:配置了sqlSessionTemplate
  @Bean
  @ConditionalOnMissingBean
  public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
    ExecutorType executorType = this.properties.getExecutorType();
    if (executorType != null) {
      return new SqlSessionTemplate(sqlSessionFactory, executorType);
    } else {
      return new SqlSessionTemplate(sqlSessionFactory);
    }
  }

  3：自动装配 导入mapperScanner
  public static class AutoConfiguredMapperScannerRegistrar
      implements BeanFactoryAware, ImportBeanDefinitionRegistrar, ResourceLoaderAware {

    private BeanFactory beanFactory;

    private ResourceLoader resourceLoader;

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

      if (!AutoConfigurationPackages.has(this.beanFactory)) {
        logger.debug("Could not determine auto-configuration package, automatic mapper scanning disabled.");
        return;
      }

      logger.debug("Searching for mappers annotated with @Mapper");

      List<String> packages = AutoConfigurationPackages.get(this.beanFactory);
      if (logger.isDebugEnabled()) {
        packages.forEach(pkg -> logger.debug("Using auto-configuration base package '{}'", pkg));
      }

      ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
      if (this.resourceLoader != null) {
        scanner.setResourceLoader(this.resourceLoader);
      }
      scanner.setAnnotationClass(Mapper.class);
      scanner.registerFilters();
      scanner.doScan(StringUtils.toStringArray(packages));

    }

  }
}

SpringBoot整合Redis

【微服务】springboot 整合 SA-Token 使用详解
congge
08-04 1万+
springboot 整合 SA-Token 使用详解
springboot整合sharding-jdbc实现分库分表详解
congge
05-21 6971
springboot整合sharding-jdbc实现分库分表详解
SpringBoot2.2.x（八）整合druid
lizc_lizc的博客
04-11 868
本系列文章都是基于SpringBoot2.2.5.RELEASE 依赖 <dependency> <groupId>com.alibaba</groupId> <artifactId>druid-spring-boot-starter</artifactId> <version>1.1.17&lt...
09_12_第七阶段：微服务开发||01-SpringBoot||11整合Druid数据源(默认Hikari)【观看狂神随笔】
qq_40572023的博客
06-23 162
整合Druid 配置自己的数据源 要导入druid <!--druid--> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.2.6</version> </dependency> spring: datasource: type: com.ali
6.Java 微服务实践 - Spring Boot 系列（六）数据库 JDBC
yezichongchongling的博客
10-25 161
1 创建一个项目 引入web jdbc mysql依赖   2 properties中配置链接信息 spring.datasource.url = jdbc:mysql://localhost:3306/test spring.datasource.username = root spring.datasource.password = 123456 spring.datasource...
微服务，微架构[二]之springboot集成jdbc
chunjiying6028的博客
05-11 156
一、在配置连接数据源连接池springboot支持多种方式C3P0，DruidDataSource，c3p0，proxool等等，Druid连接池是采用java编写，在国内使用比较多，同时也经历了很多项目的实战，所以本次演示采用Druid连接池来处理数据源的连接 二、在连接数据源中，一般我们...
微服务 SpringBoot 2.0（七）：使用JdbcTemplates访问Mysql
君哥聊编程
09-28 892
本章讲解了使用JdbcTemplates访问Mysql数据库，实现了数据交互，看上去是不是还是很简单呢？不过光是JdbcTemplates还是不够的，毕竟咱们还是要深入企业主流框架，下一章我将带大家整合Mybatis框架，后面的源代码将整合一个开源的网站来进行讲解，学完这些框架之后，你也能收获一个自己动手的网站，一举多得是不是很有动力
Springboot Mybatis druid mybatis Genereator整合demo
01-17
【Springboot Mybatis Druid mybatis Generator 整合Demo详解】 在现代Java开发中，Spring Boot以其简洁、快速的特性成为了主流的微服务框架。而MyBatis作为一款轻量级的持久层框架，通过XML或注解的方式进行SQL...
【归纳总结】微服务之TK-Mybatis & MapStruct & SPI
Octavius_的博客
04-19 427
TK-Mybatis TK-Mybatis是一个在Mybatis基础之上只做增强，不做改变的工具。为简化开发，提高效率而生。 使用步骤： 1️⃣ 导包 本包： <!--tk-Mybatis--> <dependency> <groupId>tk.mybatis</groupId> <artifactId>mapper-spring-boot-starter</artifactId> <version>2.1
SpringBoot 整合多数据源 （MyBats + Druid）
最新发布
2401_84091289的博客
05-04 798
既已说到spring cloud alibaba，那对于整个微服务架构，如果想要进一步地向上提升自己，到底应该掌握哪些核心技能呢？就个人而言，对于整个微服务架构，像RPC、Dubbo、Spring Boot、Spring Cloud Alibaba、Docker、kubernetes、Spring Cloud Netflix、Service Mesh等这些都是最最核心的知识，架构师必经之路！下图，是自绘的微服务架构路线体系大纲，如果有还不知道自己该掌握些啥技术的朋友，可根据小编手绘的大纲进行一个参考。
jdbi和jdbc_为啥微服务-数据库CRUD推荐使用JDBI开源框架之我见
weixin_39528525的博客
12-18 211
原标题：为啥微服务-数据库CRUD推荐使用JDBI开源框架之我见点击上方 “公众号”可以订阅哦！最近有幸参与PaaS微服务的开发，对于平台推荐 数据库CRUD操作采用JDBI来实现的原因，个人愚见如下，供参考： JDBI简介JDBI是一个基于JDBC构建的便利库，尝试使用集合，beans 等等来暴露操作 Java 中的关系型数据库。JDBI提供两个不同操作样式的 APIs：fluent 和 sql...
Java --- springboot2整合druid
qq_46093575的博客
05-09 308
导入pom写配置类@Bean//加入监控功能//也可以在配置文件中进行配置/*** 配置druid监控页* @return*/@Bean//设置登录账号和密码/*** 配置web——jdbc关联监控的数据* @return*/@Bean测试访问。
springcloud整合Druid数据源
lyy的博客
04-03 1048
数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个。Druid是阿里系提供的一个开源连接池，除在连接池之外，Druid还提供了非常优秀的数据库监控和扩展功能，所以在项目开发中一般会使用 Druid。监控数据库访问性能，通过StatFilter插件，详细统计SQL的执行性能SQL执行日志，Druid提供了不同的LogFilter，能够支持Common-Logging、Log4j和JdkLog 数据库密码加密。
springboot（6）整合Druid
weixin_38380811的博客
03-31 368
springboot（6）整合Druid
09_11_第七阶段：微服务开发||01-SpringBoot||10整合JDBC使用(了解即可)【观看狂神随笔】
qq_40572023的博客
06-23 194
Data 对于Spring来说，就是提取bean Spring Data官网 数据库相关的启动器 JDBC项目案例 创建项目选择web,jdbc,mysql 配置yaml spring: datasource: username: root password: 1234 # jdbc:mysql和https类似 # serverTimezone=UTC解决时区的报错 # useUnicode=true乱码问题 # characterEncod
SSM框架整合Druid由浅入深到SpringBoot接管Druid配置~ 学习SpringBoot的接管思路与思想
Alascanfu的博客
01-26 763
本篇内容：SSM框架整合Druid由浅入深到SpringBoot接管Druid配置 文章专栏：SpringBoot微服务 其原理与项目开发 最近更新：2022年1月25日 SpringBoot快速上手——这个快速上手不一样哦 教会的是方法不是技术~教你学会读官方参考文献 个人简介：一只二本院校在读的大三程序猿，本着注重基础，打卡算法，分享技术作为个人的经验总结性的博文博主，虽然可能有时会犯懒，但是还是会坚持下去的，如果你很喜欢博文的话，建议看下面一行~（疯狂暗示QwQ） ?
MyBatis 执行器（Executor）
书香水墨
10-24 636
八、MyBatis 有哪些执行器（Executor）？ MyBatis 有三种基本的Executor执行器： SimpleExecutor：每执行一次 update 或 select 就开启一个 Statement 对象，用完立刻关闭 Statement 对象； ReuseExecutor：执行 update 或 select，以 SQL 作为 key 查找 Statement 对象，存在就使用，不存在就创建，用完后不关闭 Statement 对象，而是放置于 Map 内供下一次使用。简言之，就是重
Mybatis执行器(Executor)
好记性不如烂笔头
04-08 1522
Executor是MyBatis的核心接口之一，其中定义了数据库操作的基本方法。在实际应用中经常涉及的SqlSession接口的功能，都是基于Executor接口实现的。
mybatis源码解读二-调用过程全解析
dzq584462393的专栏
11-27 725
官方文档 根据前期准备jdbc阶段进行解读 配置 拼接sql语句 加载数据源，获取Connection 获取Statement 执行获取结果 结果转换 关闭 异常处理 示例1：com.dzq.MybatisSessionTest 最基本的功能，根据此示例读源码 public static void main(String[] args) throws IOException { // 配置文件 String resource = "mybatis-config.xml";
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值