精华内容
下载资源
问答
  • druid使用
    千次阅读
    2021-01-12 17:27:55

    阿里巴巴开源的 Druid 是 Java 语言的数据库连接池,提供了强大的监控和扩展功能。

    本文讲述如何在 Spring Boot 项目中使用 Druid 数据库连接池。

    教程基于文章 《Spring Boot MyBatis 学习教程》 配套的源代码进行扩展,添加 Druid 数据库连接池和监控的功能。如果读者对于 Spring Boot 如何使用 MyBatis 还不了解,可以先完成文章 《Spring Boot MyBatis 学习教程》 的阅读和学习。

    添加依赖

    pom.xml 文件添加当前最新版本的 Druid 依赖:

    <dependency>
    	<groupId>com.alibaba</groupId>
    	<artifactId>druid-spring-boot-starter</artifactId>
    	<version>1.2.4</version>
    </dependency>
    

    形成新的 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://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.4.1</version>
            <relativePath/> <!-- lookup parent from repository -->
        </parent>
        <groupId>me.leehao</groupId>
        <artifactId>mybatisdemo</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>mybatisdemo</name>
        <description>Demo project for Mybatis</description>
        <properties>
            <java.version>1.8</java.version>
        </properties>
        <dependencies>
            <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.1.4</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid-spring-boot-starter</artifactId>
                <version>1.2.4</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <scope>runtime</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
        </dependencies>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    </project>
    

    Druid 配置

    application.yml 配置如下:

    server:
      port: 6080
    
    spring:
      datasource:
        druid:
          username: root
          password: 12345678
          url: jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC
          driver-class-name: com.mysql.cj.jdbc.Driver
          initial-size: 8
          max-active: 16
          min-idle: 1
          max-wait: 60000
    
          web-stat-filter:
            enabled: true
            url-pattern: /*
            exclusions: "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*,"
    
          stat-view-servlet:
            enabled: true
            login-username: admin
            login-password: admin
            reset-enable: false
            url-pattern: /druid/*
    
    mybatis:
      mapper-locations: classpath:mapping/*Mapper.xml
      type-aliases-package: me.leehao.mybatisdemo.entity
    
    logging:
      level:
        me:
          leehao:
            mybatisdemo:
              mapper : debug
    

    其中,数据库连接基本配置:

    • username:数据库用户名称
    • password:数据库密码
    • url:JDBC 连接字符串
    • driver-class-name:数据库驱动类名称

    连接池配置:

    • initial-size:连接池建立时创建的初始化连接数
    • max-active:连接池中最大的活跃连接数
    • min-idle:连接池中最小的连接数
    • max-wait:获取连接等待超时的时间

    Druid 内置一个 StatViewServlet 用于展示 Druid 的统计信息,对 StatViewServlet 的配置,主要是配置 stat-view-servlet,包括:

    • enabled:是否启用 StatViewServlet (监控页面),默认为 false
    • login-username:监控页面登录的用户名称
    • login-password:监控页面登录的用户密码
    • reset-enable:是否允许清空统计数据
    • url-pattern:根据配置中的 url-pattern 来访问内置监控页面,例如 /druid/*,则内置监控页面的首页是 /druid/index.html

    Druid 提供 WebStatFilter 用于采集 web-jdbc 关联监控的数据。对 WebStatFilter 进行配置,主要是配置 web-stat-filter,包括:

    • enabled:是否启用 WebStatFilter,默认值 false
    • url-pattern:需要监控的 url
    • exclusions:需要排除一些不必要的 url,比如 *.js,/jslib/*

    运行测试

    浏览器打开地址:http://localhost:6080/druid/index.html,其中,端口 6080 为上面 application.yml 配置的 server.port。使用 admin 用户和 admin 密码登录 Druid 的监控页面。

    随机调用几次 http://localhost:6080/user/1 接口,可以看到监控页面有相关的监控展示:

    其他监控数据这里不再阐述,可以参考官方文档。

    参考资料

    • https://github.com/alibaba/druid
    • https://github.com/alibaba/druid/tree/master/druid-spring-boot-starter/
    • https://github.com/alibaba/druid/wiki/%E9%85%8D%E7%BD%AE_StatViewServlet%E9%85%8D%E7%BD%AE
    • https://github.com/alibaba/druid/wiki/%E9%85%8D%E7%BD%AE_%E9%85%8D%E7%BD%AEWebStatFilter
    • https://github.com/alibaba/druid/wiki/Druid%E8%BF%9E%E6%8E%A5%E6%B1%A0%E4%BB%8B%E7%BB%8D
    更多相关内容
  • Druid使用

    千次阅读 2019-09-21 22:39:34
    springboot使用jpa连接mysql数据库,使用druid监控

    Druid使用

    简介

    Druid是java中的数据库连接池,是阿里巴巴的一个开源项目。Druid还提供了实时监控功能,有数据源监控,sql监控,sql防火墙,web应用监控等。下面是springboot使用jpa连接mysql,然后使用Druid数据库连接池

    pom文件依赖

        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-jpa</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-devtools</artifactId>
                <scope>runtime</scope>
            </dependency>
    
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid-spring-boot-starter</artifactId>
                <version>1.1.16</version>
            </dependency>
    
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <scope>runtime</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>
    
    

    properties文件配置

    Druid配置有很多,关于连接池的一些配置

    spring.datasource.url=jdbc:mysql://localhost:3306/test?characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai
    spring.datasource.username=root
    spring.datasource.password=123456
    spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
    #使用druid的话,需要多配制一个属性spring.datasource.type
    spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
    
    ##连接池的配置信息
    # 初始化大小,最小或最大
    spring.datasource.druid.initial-size=5
    spring.datasource.druid.min-idle=5
    spring.datasource.druid.max-active=20
    ##配置获取连接池等待超时的时间
    spring.datasource.druid.max-wait=60000
    ##配置间隔多久才进行一次检测,检测需要关闭的空闲连接,单位是毫秒
    spring.datasource.druid.time-between-eviction-runs-millis=60000
    #配置一个连接池中最小生存时间,单位是毫秒
    spring.datasource.druid.min-evictable-idle-time-millis=300000
    spring.datasource.druid.validation-query=SELECT 1 FROM DUAL
    spring.datasource.druid.test-while-idle=true
    spring.datasource.druid.test-on-borrow=false
    spring.datasource.druid.test-on-return=false
    #打开PSCache,并且指定每个连接上PSCache的大小
    spring.datasource.druid.pool-prepared-statements=true
    spring.datasource.druid.max-pool-prepared-statement-per-connection-size=20
    #配置监控统计拦截的filters,去掉后监控界面sql无法统计,wall用于防火墙
    spring.datasource.druid.filters=stat,wall
    
    ##JPA配置
    ## validate 加载hibernate时,验证创建数据表结构
    ## create 每次加载hibernate,重新创建数据表结构,这会导致数据表数据丢失
    ## create-drop 加载hibernate时创建,退出时删除表结构
    ## update  加载hibernate自动更新数据库结构
    ## none   启动时不做任何操作
    spring.jpa.hibernate.ddl-auto=create
    ## 控制台打印
    spring.jpa.show-sql=true
    
    

    Druid工具类

    Druid还需要一些工具类才能使用
    DruidConfig.java

    @Configuration
    public class DruidConfig {
        @Value("${spring.datasource.url}")
        private String dbUrl;
    
        @Value("${spring.datasource.username}")
        private String username;
    
        @Value("${spring.datasource.password}")
        private String password;
    
        @Value("${spring.datasource.driver-class-name}")
        private String driverClassName;
    
        @Value("${spring.datasource.druid.initial-size}")
        private  int initialSize;
    
        @Value("${spring.datasource.druid.min-idle}")
        private int minIdle;
    
        @Value("${spring.datasource.druid.max-active}")
        private int maxActive;
    
        @Value("${spring.datasource.druid.max-wait}")
        private int maxWait;
    
        @Value("${spring.datasource.druid.time-between-eviction-runs-millis}")
        private int timeBetweenEvictionRunsMillis;
    
        @Value("${spring.datasource.druid.min-evictable-idle-time-millis}")
        private int minRvictableIdleTimeMillis;
    
        @Value("${spring.datasource.druid.validation-query}")
        private String validationQuery;
    
        @Value("${spring.datasource.druid.test-while-idle}")
        private boolean testWhileIdle;
    
        @Value("${spring.datasource.druid.test-on-borrow}")
        private boolean testOnBorrow;
    
        @Value("${spring.datasource.druid.test-on-return}")
        private boolean testOnReturn;
    
        @Value("${spring.datasource.druid.pool-prepared-statements}")
        private boolean poolPreparedStatements;
    
        @Value("${spring.datasource.druid.max-pool-prepared-statement-per-connection-size}")
        private int maxPoolPreparedStatementPerConnectionSize;
    
        @Value("${spring.datasource.druid.filters}")
        private String filters;
        
    
        @Bean
        @Primary
        public DataSource dataSource(){
            DruidDataSource dataSource = new DruidDataSource();
    
            dataSource.setUrl(this.dbUrl);
            dataSource.setUsername(username);
            dataSource.setPassword(password);
            dataSource.setDriverClassName(driverClassName);
    
            dataSource.setInitialSize(initialSize);
            dataSource.setMinIdle(minIdle);
            dataSource.setMaxActive(maxActive);
            dataSource.setMaxWait(maxWait);
            dataSource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
            dataSource.setMinEvictableIdleTimeMillis(minRvictableIdleTimeMillis);
            dataSource.setValidationQuery(validationQuery);
            dataSource.setTestWhileIdle(testWhileIdle);
            dataSource.setTestOnBorrow(testOnBorrow);
            dataSource.setTestOnReturn(testOnReturn);
            dataSource.setPoolPreparedStatements(poolPreparedStatements);
            dataSource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
            try{
                dataSource.setFilters(filters);
            }catch (SQLException e){
    
            }
            return dataSource;
        }
    }
    

    Druid过滤器

    @WebFilter(filterName="druidWebStatFilter",urlPatterns = "/*",
        initParams  = {
            @WebInitParam(name = "exclusions", value = "*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*")
    })//忽略资源
    
    public class DruidFilter extends WebStatFilter {
    }
    
    

    DruidServlet,用于过滤管理页面ip等信息

    @WebServlet(urlPatterns = "/druid/*",
        initParams = {
            @WebInitParam(name="allow",value = ""), //IP白名单(若没有配置或者为空,则允许所有访问)
                @WebInitParam(name="deny",value = ""), //IP黑名单(deny优先于allow )
                @WebInitParam(name = "loginUserName", value = "admin"),  //登录druid管理页用户名
                @WebInitParam(name="loginPassword", value = "value") //登录druid管理页密码
        })
    public class DruidServlet extends StatViewServlet {
    }
    

    还有一个重要的点,需要在启动类加上注解@ServletComponentScan,否则无法扫描到DruidServlet

    City实体类

    @Entity
    @Table(name = "city")
    public class City {
    
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Integer cityId;
    
        @Column(nullable = false)
        private String cityName;
        private String cityIntroduce;
    
        public City(String cityName, String cityIntroduce) {
            this.cityName = cityName;
            this.cityIntroduce = cityIntroduce;
        }
    
        public Integer getCityId() {
            return cityId;
        }
    
        public void setCityId(Integer cityId) {
            this.cityId = cityId;
        }
    
        public String getCityName() {
            return cityName;
        }
    
        public void setCityName(String cityName) {
            this.cityName = cityName;
        }
    
        public String getCityIntroduce() {
            return cityIntroduce;
        }
    
        public void setCityIntroduce(String cityIntroduce) {
            this.cityIntroduce = cityIntroduce;
        }
    }
    
    

    CityRepository类,继承JpaRepository类,具有简单的操作数据库函数

    public interface CityRepository extends JpaRepository<City, Integer> {
    
    }
    
    
    

    创建CityController,并注入CityRepository

    
    @RestController
    public class CityController {
        @Autowired
        private CityRepository cityRepository;
    
        @GetMapping("save")
        public String saveCity(String cityName, String cityIntroduce){
            City city = new City(cityName, cityIntroduce);
            cityRepository.save(city);
            return "sucess";
        }
    
        @GetMapping("deleteCityById")
        public String deleteCity(int cityId){
            cityRepository.deleteById(cityId);
            return "success";
        }
    
        @GetMapping("updateCity")
        public String updateCity(int citId, String cityName, String cityIntroduce){
            City city = new City(cityName,cityIntroduce);
            city.setCityId(citId);
            cityRepository.save(city);
            return "success";
        }
    
        @GetMapping("getCityById")
        public City getCityById(Integer cityId){
            City city = cityRepository.getOne(cityId);
            return city;
        }
    }
    

    在这里插入图片描述

    总结

    访问localhost:8080/druid就会进入druid监控界面,就可以查看许多监控数据。不过druid的配置语句是真的多且复杂,还有工具类,需要把properties里面的数据全部取过来,放入DataSource中,要手打的话确实非常麻烦我觉得应该有一种目前我还不知道的简便方法.

    展开全文
  • Druid使用教程.md

    2021-11-18 14:33:59
    apache-druid-0.15.0-incubating-bin.tar.gz版本的安装和配合kafka摄取数据的步骤
  • druid使用

    千次阅读 2019-09-02 18:14:18
    DruidDataSource dds = new DruidDataSource(); dds.setUrl(druidProperties.getUrl()); dds.setUsername(druidProperties.getUsername()); dds.setPassword(druidProperties.getPassword()); dds....

    boot2

    核心依赖

    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.0.7.RELEASE</version>
            <relativePath/>
        </parent>
        
            <!-- druid数据库连接池 -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.1.17</version>
            </dependency>
    
    

    配置

    spring:
      datasource:
        fun:
          username: root
          password: 123456
          driverClassName: com.mysql.jdbc.Driver
          url: jdbc:mysql://localhost:3306/test?allowMultiQueries=true&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;autoReconnect=true&amp;failOverReadOnly=false
    
          # 配置Druid的其他参数,以下配置必须增加一个配置文件才能有效
          type: com.alibaba.druid.pool.DruidDataSource
          # 初始化大小,最小,最大
          initialSize: 1
          minIdle: 1
          maxActive: 20
          # 获取连接等待超时的时间
          maxWait: 60000
          # 配置间隔多久才进行一次检测,检测需要关闭的空闲连接,单位是毫秒
          timeBetweenEvictionRunsMillis: 60000
          # 配置一个连接在池中最小生存的时间,单位是毫秒
          minEvictableIdleTimeMillis: 300000
          validationQuery: SELECT 1
          testWhileIdle: true
          testOnBorrow: false
          testOnReturn: false
          poolPreparedStatements: true
          # 配置监控统计拦截的filters,去掉后监控界面sql无法统计,'wall'用于防火墙
          filters: stat, wall
          # 打开PSCache,并且指定每个连接上PSCache的大小
          maxPoolPreparedStatementPerConnectionSize: 20
          # 通过connectProperties属性来打开mergeSql功能;慢SQL记录
          connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500
          # 合并多个DruidDataSource的监控数据
          useGlobalDataSourceStat: true
    

    DruidConfig

    
    @Slf4j
    @Configuration
    @MapperScan(basePackages = {"org.study.mybatis.dao.mapper"},sqlSessionTemplateRef = "funSqlSessionTemplate")
    public class DruidConfig {
    
        @Autowired
        private Environment env;
        @Autowired
        private DruidConfigProperties druidProperties;
    
        @Bean(name = "fun")
        public DataSource druid() {
            DruidDataSource dds = new DruidDataSource();
            dds.setUrl(druidProperties.getUrl());
            dds.setUsername(druidProperties.getUsername());
            dds.setPassword(druidProperties.getPassword());
            dds.setDriverClassName(druidProperties.getDriverClassName());
    
            dds.setInitialSize(druidProperties.getInitialSize());
            dds.setMinIdle(druidProperties.getMinIdle());
            dds.setMaxActive(druidProperties.getMaxActive());
            dds.setMaxWait(druidProperties.getMaxWait());
            dds.setTimeBetweenEvictionRunsMillis(druidProperties.getTimeBetweenEvictionRunsMillis());
            dds.setMinEvictableIdleTimeMillis(druidProperties.getMinEvictableIdleTimeMillis());
            dds.setValidationQuery(druidProperties.getValidationQuery());
    
            dds.setTestWhileIdle(druidProperties.getTestWhileIdle());
            dds.setTestOnBorrow(druidProperties.getTestOnBorrow());
            dds.setTestOnReturn(druidProperties.getTestOnReturn());
            dds.setPoolPreparedStatements(druidProperties.getPoolPreparedStatements());
            dds.setMaxPoolPreparedStatementPerConnectionSize(druidProperties.getMaxPoolPreparedStatementPerConnectionSize());
    
            try {
                dds.setFilters(druidProperties.getFilters());
                dds.init();
            } catch (SQLException e) {
                log.error(e.getMessage(), e);
            }
    
            return dds;
        }
    
        /**
         * 根据数据源创建SqlSessionFactory
         */
        @Bean("funSqlSessionFactory")
        public SqlSessionFactory funSqlSessionFactory(@Qualifier("fun") DataSource dataSource) throws Exception {
            SqlSessionFactoryBean fb = new SqlSessionFactoryBean();
            fb.setDataSource(dataSource);// 指定数据源(这个必须有,否则报错)
            fb.setTypeAliasesPackage(env.getProperty("mybatis.type.aliases.package.fun"));// 指定基包
            fb.setMapperLocations(new PathMatchingResourcePatternResolver()
                    .getResources(env.getProperty("mybatis.mapper.locations.fun")));
    
            return fb.getObject();
        }
    
        /**
         * 配置事务管理器
         */
        @Bean(name = "funTransactionManager")
        public DataSourceTransactionManager transactionManager(@Qualifier("fun") DataSource dataSource) throws Exception {
            return new DataSourceTransactionManager(dataSource);
        }
    
        /**
         * session连接模板
         */
        @Bean(name = "funSqlSessionTemplate")
        public SqlSessionTemplate sqlSessionTemplate(@Qualifier("funSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
            SqlSessionTemplate template = new SqlSessionTemplate(sqlSessionFactory); // 使用上面配置的Factory
            return template;
        }
    
        //配置Druid的监控
        //1、配置一个管理后台的Servlet
        @Bean
        public ServletRegistrationBean statViewServlet(){
            ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");
            Map<String,String> initParams = new HashMap<>();
            initParams.put("loginUsername","admin");
            initParams.put("loginPassword","123456");
            initParams.put("allow","");//默认就是允许所有访问
            initParams.put("deny","192.168.15.21");
            bean.setInitParameters(initParams);
            return bean;
        }
    
        //2、配置一个web监控的filter
        @Bean
        public FilterRegistrationBean webStatFilter(){
            FilterRegistrationBean bean = new FilterRegistrationBean();
            bean.setFilter(new WebStatFilter());
            Map<String,String> initParams = new HashMap<>();
            initParams.put("exclusions","*.js,*.css,/druid/*");
            bean.setInitParameters(initParams);
            bean.setUrlPatterns(Arrays.asList("/*"));
            return  bean;
        }
    
    }
    
    

    启动项目后,访问http://localhost:8080/druid/index.html
    用户名使用配置的admin,123456
    在这里插入图片描述

    看sql监控和url监控
    在这里插入图片描述

    代码 https://github.com/mingwulipo/mybatis-demo

    展开全文
  • Druid使用步骤及详细案例(赞)

    千次阅读 2020-08-03 16:12:43
    文章目录一、Druid使用步骤:1.1 导入 jar 包:1.2 定义配置文件:1.3 加载配置文件:1.4 从数据库连接池工厂中获取连接池对象:1.5 获取连接对象:二、Druid 在项目中的部分:2.1 导入 jar 文件:2.2 定义配置文件:2.3 ...

    Druid(德鲁伊) 是什么? 与 c3p0 和 dbcp 类似,Druid 是阿里的 Druid 数据库连接池。

    一、Druid 的使用步骤:

    1.1 导入 jar 包:

    druid-1.1.20.jar

    1.2 定义配置文件:

    a、编写 properties 文件。
    b、文件名是任意的,可以在任意的目录下。

    1.3 加载配置文件:

    加载 druid.properties 文件到我们的项目中。

    1.4 从数据库连接池工厂中获取连接池对象:

    a、数据库连接池工厂 -> DruidDataSourceFactory。
    b、获取连接池对象 -> createDataSource(Properties 对象)。

    1.5 获取连接对象:

    getConnection();

    二、Druid 在项目中的部分:

    项目目录结构:
    在这里插入图片描述

    2.1 导入 jar 文件:

    在这里插入图片描述

    2.2 定义配置文件:

    druid.properties:

    	driverClassName=com.mysql.cj.jdbc.Driver
    	url=jdbc:mysql://localhost:3306/db_druid?useSSL=false&serverTimezone=UTC
    	username=root
    	password=root
    	initialSize=3
    	maxActive=5
    	maxWait=3000
    

    2.3 加载配置文件:

    public static DataSource ds;
    
        static {
            Properties properties = new Properties();
            /**
             *  利用反射获取类加载器,以此来得到加载项目中的其他文件
             */
            InputStream resourceAsStream = JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties");
            try {
                // 加载配置文件 druid.properties
                properties.load(resourceAsStream);
                // 获取连接池对象
                ds = DruidDataSourceFactory.createDataSource(properties);
            } catch (IOException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if(resourceAsStream != null) {
                    try {
                        resourceAsStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    
    

    2.4 从数据库连接池工厂中获取连接池对象:

    	public static DataSource getDataSource(){
    	        return ds;
    	}
    
    

    2.5 获取连接对象:

        /**
         *  从连接池中获取一个数据库的连接
         * @return
         * @throws SQLException
         */
        public static Connection getConnection() throws SQLException {
            return ds.getConnection();
        }
    
    

    2.6 关闭数据库连接:

    
        /**
         *
         *  关闭数据库的连接
         * @param set
         * @param connection
         * @param statement
         * @throws SQLException
         */
        public static void close(ResultSet set, Connection connection, Statement statement) throws SQLException {
            if(set != null) {
                set.close();
            }
    
            if(connection != null){
                connection.close();
            }
    
            if(statement != null) {
                statement.close();
            }
        }
    

    三、帖子点赞数 完整项目:

    3.1 数据库设计:

    在这里插入图片描述
    在这里插入图片描述

    3.2 项目目录结构:

    在这里插入图片描述

    3.3 JDBCUtils:

    package com.xptx.druid.utils;
    
    import com.alibaba.druid.pool.DruidDataSource;
    import com.alibaba.druid.pool.DruidDataSourceFactory;
    
    import javax.sql.DataSource;
    import java.io.IOException;
    import java.io.InputStream;
    import java.sql.Connection;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.sql.Statement;
    import java.util.Properties;
    
    public class JDBCUtils {
    
        public static DataSource ds;
    
        static {
            Properties properties = new Properties();
            /**
             *  利用反射获取类加载器,以此来得到加载项目中的其他文件
             */
            InputStream resourceAsStream = JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties");
            try {
                // 加载配置文件 druid.properties
                properties.load(resourceAsStream);
                // 获取连接池对象
                ds = DruidDataSourceFactory.createDataSource(properties);
            } catch (IOException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if(resourceAsStream != null) {
                    try {
                        resourceAsStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    
        public static DataSource getDataSource(){
            return ds;
        }
    
    
        /**
         *  从连接池中获取一个数据库的连接
         * @return
         * @throws SQLException
         */
        public static Connection getConnection() throws SQLException {
            return ds.getConnection();
        }
    
    
        /**
         *
         *  关闭数据库的连接
         * @param set
         * @param connection
         * @param statement
         * @throws SQLException
         */
        public static void close(ResultSet set, Connection connection, Statement statement) throws SQLException {
            if(set != null) {
                set.close();
            }
    
            if(connection != null){
                connection.close();
            }
    
            if(statement != null) {
                statement.close();
            }
        }
    }
    
    

    3.4 Dao :

    package com.xptx.druid.dao;
    
    import com.xptx.druid.entity.Tip;
    import com.xptx.druid.utils.JDBCUtils;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    public class TipDao {
    
        /**
         *  在帖子中添加一条记录
         */
    
        public void add(Tip tip) throws SQLException {
            Integer id = tip.getId();
            String name = tip.getName();
            Integer good = tip.getGood();
            Integer bad = tip.getBad();
            Date time = tip.getDate();
    
            /**
             *  将日期进行格式化,转换成 String 字符串形式
             */
            SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd");
            String time1 = f.format(time);
    
    
            String title = tip.getTitle();
            // 获取连接
            Connection conn = JDBCUtils.getConnection();
            String sql = "insert into tip values (?,?,?,?,?,2,?)";
            PreparedStatement pstam = conn.prepareStatement(sql);
            pstam.setInt(1,id);
            pstam.setString(2,name);
            pstam.setInt(3,good);
            pstam.setInt(4,bad);
            pstam.setString(5,time1);
            pstam.setString(6,title);
            int result = pstam.executeUpdate();
            if(result > 0) {
                System.out.println("添加成功!");
            }
            JDBCUtils.close(null,conn,pstam);
        }
    
        /**
         *  删除指定用户的所有帖子
         */
    
        public void delete(String name) throws SQLException {
            Connection conn = JDBCUtils.getConnection();
            String sql = "delete from tip where tname = ?";
            PreparedStatement pstam = conn.prepareStatement(sql);
            pstam.setString(1,name);
            int result = pstam.executeUpdate();
            if(result > 0) {
                System.out.println("删除成功!");
            } else {
                System.out.println("删除失败!");
            }
            JDBCUtils.close(null,conn,pstam);
        }
    
    
        /**
         *  将小潘同学的点赞数 + 20%
         *
         */
    
        public void update(String name) throws SQLException {
            Connection conn = JDBCUtils.getConnection();
            String sql = "update tip set tgood = 1.2 * tgood where tname = ?";
            PreparedStatement pstam = conn.prepareStatement(sql);
            pstam.setString(1,name);
            pstam.executeUpdate();
            JDBCUtils.close(null,conn,pstam);
        }
    
        /**
         *  查询帖子中带有 “同学” 字样的帖子
         */
        public void select(String info) throws SQLException {
            Connection conn = JDBCUtils.getConnection();
            String sql = "select * from tip where tname LIKE ?";
            PreparedStatement pstam = conn.prepareStatement(sql);
            pstam.setString(1,"%"+info+"%");
            ResultSet resultSet = pstam.executeQuery();
            while (resultSet.next()) {
                Integer id = resultSet.getInt(1);
                String name = resultSet.getString(2);
                Integer good = resultSet.getInt(3);
                Integer bad = resultSet.getInt(4);
                String time = resultSet.getString(5);
                String title = resultSet.getString(7);
                System.out.println(id +"----" +name + "----" + good +"----" + bad + "----" + time + "----" +title );
            }
            JDBCUtils.close(resultSet,conn,pstam);
        }
    
    }
    
    

    3.5 Entity :

    package com.xptx.druid.entity;
    
    import java.util.Date;
    
    public class Tip {
        private Integer id;
        private String name;
        private Integer good;
        private  Integer bad;
        private Date date;
        private String title;
    
        public Tip() {
        }
    
        public Tip(Integer id, String name, Integer good, Integer bad, Date date, String title) {
            this.id = id;
            this.name = name;
            this.good = good;
            this.bad = bad;
            this.date = date;
            this.title = title;
        }
    
        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 getGood() {
            return good;
        }
    
        public void setGood(Integer good) {
            this.good = good;
        }
    
        public Integer getBad() {
            return bad;
        }
    
        public void setBad(Integer bad) {
            this.bad = bad;
        }
    
        public Date getDate() {
            return date;
        }
    
        public void setDate(Date date) {
            this.date = date;
        }
    
        public String getTitle() {
            return title;
        }
    
        public void setTitle(String title) {
            this.title = title;
        }
    
        @Override
        public String toString() {
            return "Tip{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", good=" + good +
                    ", bad=" + bad +
                    ", date=" + date +
                    ", title='" + title + '\'' +
                    '}';
        }
    }
    
    

    3.6 Test:

    package com.xptx.druid.test;
    
    import com.xptx.druid.dao.TipDao;
    import com.xptx.druid.entity.Tip;
    
    import java.sql.SQLException;
    import java.util.Date;
    
    public class Test {
        public static void main(String[] args) throws SQLException {
            Tip tip = new Tip(3,"赵四同学",1,123,new Date(),"小美眉对我笑了");
            TipDao tipDao = new TipDao();
    //        tipDao.add(tip);
    //        tipDao.delete("xptx");
    //        tipDao.update("小潘同学");
            tipDao.select("同学");
        }
    }
    
    

    四、后记:

    本文只是 Druid(德鲁伊) 的一个简单实用,该数据库连接池的强大之处还没有运用到,比如 Druid 的监控功能,这也是 Druid 比 c3p0 和 dbcp 连接池厉害的地方,由于博主比较菜,之后再进一步学习 Druid 强大的地方。

    如果该文对您有帮助,是小潘的荣幸,不如点个赞,点个关注给点鼓励,嘻嘻,在此先谢过啦。

    展开全文
  • 数据库连接池及Druid使用步骤

    千次阅读 2022-04-28 16:08:40
    数据库连接池简介及Druid使用步骤
  • 1. 确保 Druid 集群和 Hadoop 集群能够正常通信 2. 在 E-MapReduce Druid 集群的每个节点的 /usr/local/servi
  • 步骤如下加密java -cp ./druid-1.1.10.jar com.alibaba.druid.filter.config.ConfigTools 你的
  • Druid 使用国产数据库,神通数据库适配 关于国产数据库 近年来迅速崛起,但是资料稀缺,希望对大家有所帮助。 另一个兄弟对Druid规整的简介 由于Druid仅包括14种连接方式 出自Druid jar包中 druid-driver.properties...
  • Druid使用步骤

    千次阅读 2022-04-03 18:14:29
    2.定义配置文件druid.properties driverClassName=com.mysql.jdbc.Driver url=jdbc:mysql:///db1?useSSL=false&useServerPrepStmts=true username=root password=123456 # 初始化连接池数量 initialSize=5 #
  • spring实现druid使用ssh连接数据库

    千次阅读 2020-12-26 18:00:53
    引入ssh代理jar com.jcraft jsch 0.1.55 2.重载BeanPostProcessor类,在druid连接数据库前设置ssh隧道,druid连接时使用ssh隧道进行mysql连接。注意spring框架中初始化化com.alibaba.druid.pool.DruidDataSource前,...
  • Springboot Druid 使用Slf4j输出可执行SQL

    千次阅读 2019-06-29 09:44:20
    前言 在开发中,为了数据安全,所有SQL语句肯定是用占位符的,但是在实际开发中,...并且还是有参数的(替换了占位符),而Druid就支持此功能(Druid的主要功能可不是这个),所以此文主要讲Springboot环境下使用Druid...
  • 自己改写了jar包里的类重新编译过了,maven引入直接用
  • Druid使用说明书

    千次阅读 2015-06-25 14:39:46
    欢迎大家使用Druid,常见问题在这里解答,希望对大家有所帮助。 1. Druid是什么? Druid是Java语言中最好的数据库连接池。Druid能够提供强大的监控和扩展功能。 2. 在哪里下载druid 正式版本下载: ...
  • Druid使用配置

    千次阅读 2018-05-18 22:59:53
    一、介绍 什么是Druid Druid是Java语言中最好的数据库连接池。Druid能够提供强大的监控和扩展功能。 GitHub地址 https://github.com/alibaba/druid 正式版本下载地址: ...
  • 附件是完整的druid配置,包括自定义RSA秘钥加密用户名和密码
  • # com.alibaba.druid使用踩坑解决

    万次阅读 2020-03-11 12:28:19
    com.alibaba.druid使用踩坑解决 1.加入依赖 <dependency> <!--自动配置--> <groupId>com.alibaba</groupId> <artifactId>druid-spring-boot-starter</artifactId> <...
  • Apache Druid (incubating) 安装及使用

    千次阅读 2019-07-22 05:28:29
    主要对Druid进行了简要的介绍,包括概念和架构,以及常见的问题。接着以Single-service的方式自定义配置进行了部署和安装,以及对安装的后的Druid的简要使用
  • Druid使用详解

    千次阅读 2018-08-03 17:39:33
    一、关于Druid Druid是一个JDBC组件,它包括三部分:  DruidDriver 代理Driver,能够提供基于Filter-Chain模式的插件体系。  DruidDataSource 高效可管理的数据库连接池。  SQLParser  Druid...
  • druid使用常见问题

    千次阅读 2016-11-21 17:58:17
    欢迎大家使用Druid,常见问题在这里解答,希望对大家有所帮助。 1. Druid是什么? Druid是Java语言中最好的数据库连接池。Druid能够提供强大的监控和扩展功能。 2. 在哪里下载druid 正式版本下载: ...
  • 从JDBC到Druid 0、从ODBC开始谈起 在JDK1.0刚开始发布时,并没有跟着发布一个连接数据库的API,那么那时的开发人员,如果想要连接到数据库的话,该怎么做呢?那时的通常做法是使用另一个数据库驱动管理器——ODBC。 ...
  • Druid系列 《二》Druid使用与安装

    千次阅读 2018-08-31 10:45:35
    2.1加载数据到Druid Druid支持流式(实时)和基于文件(批量)的数据提取方式。... Stream push - 使用Tranquility(向Druid发送流的客户端)将实时数据流推送到Druid。如果你的数据集来自于流式...
  • Druid是Java语言中最好的数据库连接池。这篇文章主要介绍了Spring Boot使用Druid连接池的示例代码,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • druid使用

    2019-01-22 11:37:59
    druid在互联网公司中的应用,主要应用于实时数仓方向,特点:吃内存查询快
  • 使用Druid配置密码加解密

    千次阅读 2022-03-01 11:16:07
    1.引进Druid包 2.对密码进行加密 public static void main(String[] args) throws Exception{ String[] arr = ConfigTools.genKeyPair(512); System.out.println("privateKey:"+arr[0]); System.out.println(...
  • Apache Druid 集群搭建及使用【超全面】

    千次阅读 多人点赞 2021-01-01 23:07:19
    一、Druid 简介 1.1 大数据分析平台架构分类 数据分析的基础架构可以分为以下几类: 使用Hadoop/Spark 进行分析 将Hadoop/Spark 的结果导入 RDBMS 中提供数据分析;补充说明:RDBMS一般指关系数据库管理系统 ...
  • Druid使用ConfigFilter

    千次阅读 2016-11-03 13:49:16
    ConfigFilter的作用包括: 从配置文件中读取配置从远程http文件中读取配置为数据库密码提供... 1 配置ConfigFilter ... bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init
  • 数据库连接池Druid使用总结

    万次阅读 2017-03-30 11:48:25
    3、综合性能,扩展性等方面,可考虑使用druid或者hikariCP连接池 ,比较方便对jdbc接口进行监控跟踪等。 4、可开启prepareStatement缓存,对性能会有大概20%的提升。 psCache是connection私有的,所以不存在线程竞争...
  • Druid连接池的使用讲解

    千次阅读 2022-04-27 22:07:30
    Druid连接池的使用讲解,跟JDBC比起来是不是很简单,哈哈
  • Druid源码(druid-1.2.8.zip)

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 161,786
精华内容 64,714
关键字:

druid使用