springboot整合Druid之二：com.alibaba.druid

        <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.2</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.16</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.10</version>
        </dependency>
        <dependency>
            <groupId>com.oracle.ojdbc</groupId>
            <artifactId>ojdbc8</artifactId>
            <scope>runtime</scope>
        </dependency>

package com.example.mybatis.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.EnableTransactionManagement;

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

@Configuration
@EnableTransactionManagement
public class DatasourceConfig {

    @Autowired
    private JdbcConfig jdbcConfig;

    @Bean(name = "dataSource")
    @Primary //在同樣的DataSource中，首先使用被標註的DataSource
    public DataSource dataSource() {
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setUrl(jdbcConfig.getUrl());
        druidDataSource.setUsername(jdbcConfig.getUserName());
        druidDataSource.setPassword(jdbcConfig.getPassword());
        druidDataSource.setInitialSize(jdbcConfig.getInitialSize());
        druidDataSource.setMinIdle(jdbcConfig.getMinIdle());
        druidDataSource.setMaxActive(jdbcConfig.getMaxActive());
        druidDataSource.setTimeBetweenEvictionRunsMillis(jdbcConfig.getTimeBetweenEvictionRunsMillis());
        druidDataSource.setMinEvictableIdleTimeMillis(jdbcConfig.getMinEvictableIdleTimeMillis());
        druidDataSource.setValidationQuery(jdbcConfig.getValidationQuery());
        druidDataSource.setTestWhileIdle(jdbcConfig.isTestWhileIdle());
        druidDataSource.setTestOnBorrow(jdbcConfig.isTestOnBorrow());
        druidDataSource.setTestOnReturn(jdbcConfig.isTestOnReturn());
        druidDataSource.setMaxPoolPreparedStatementPerConnectionSize(jdbcConfig.getMaxPoolPreparedStatementPerConnectionSize());
        try {
            druidDataSource.setFilters(jdbcConfig.getFilters());
        } catch (SQLException e) {
            System.out.println(e);
        }
        return druidDataSource;
    }

    @PropertySource(value = "classpath:jdbc.properties")
    @Component
    public static class JdbcConfig {
        /**
         * 數據庫用戶名
         */
        @Value("${spring.datasource.username}")
        private String userName;
        /**
         * 驅動名稱
         */
        @Value("${spring.datasource.driver-class-name}")
        private String driverClass;
        /**
         * 數據庫連接url
         */
        @Value("${spring.datasource.url}")
        private String url;
        /**
         * 數據庫密碼
         */
        @Value("${spring.datasource.password}")
        private String password;

        /**
         * 數據庫連接池初始化大小
         */
        @Value("${spring.datasource.initialSize}")
        private int initialSize;

        /**
         * 數據庫連接池最小最小連接數
         */
        @Value("${spring.datasource.minIdle}")
        private int minIdle;

        /**
         * 數據庫連接池最大連接數
         */
        @Value("${spring.datasource.maxActive}")
        private int maxActive;

        /**
         * 獲取連接等待超時的時間
         */
        @Value("${spring.datasource.maxWait}")
        private long maxWait;

        /**
         * 多久檢測一次
         */
        @Value("${spring.datasource.timeBetweenEvictionRunsMillis}")
        private long timeBetweenEvictionRunsMillis;

        /**
         * 連接在池中最小生存的時間
         */
        @Value("${spring.datasource.minEvictableIdleTimeMillis}")
        private long minEvictableIdleTimeMillis;

        /**
         * 測試連接是否有效的sql
         */
        @Value("${spring.datasource.validationQuery}")
        private String validationQuery;

        /**
         * 申請連接的時候檢測，如果空閒時間大於timeBetweenEvictionRunsMillis，檢測連接是否有效
         */
        @Value("${spring.datasource.testWhileIdle}")
        private boolean testWhileIdle;

        /**
         * 申請連接時,檢測連接是否有效
         */
        @Value("${spring.datasource.testOnBorrow}")
        private boolean testOnBorrow;

        /**
         * 歸還連接時,檢測連接是否有效
         */
        @Value("${spring.datasource.testOnReturn}")
        private boolean testOnReturn;

        /**
         * PSCache大小
         */
        @Value("${spring.datasource.maxPoolPreparedStatementPerConnectionSize}")
        private int maxPoolPreparedStatementPerConnectionSize;

        /**
         * 通過別名的方式配置擴展插件
         */
        @Value("${spring.datasource.filters}")
        private String filters;

        public String getUserName() {
            return userName;
        }

        public void setUserName(String userName) {
            this.userName = userName;
        }

        public String getDriverClass() {
            return driverClass;
        }

        public void setDriverClass(String driverClass) {
            this.driverClass = driverClass;
        }

        public String getUrl() {
            return url;
        }

        public void setUrl(String url) {
            this.url = url;
        }

        public String getPassword() {
            return password;
        }

        public void setPassword(String password) {
            this.password = password;
        }

        public int getInitialSize() {
            return initialSize;
        }

        public void setInitialSize(int initialSize) {
            this.initialSize = initialSize;
        }

        public int getMinIdle() {
            return minIdle;
        }

        public void setMinIdle(int minIdle) {
            this.minIdle = minIdle;
        }

        public int getMaxActive() {
            return maxActive;
        }

        public void setMaxActive(int maxActive) {
            this.maxActive = maxActive;
        }

        public long getMaxWait() {
            return maxWait;
        }

        public void setMaxWait(long maxWait) {
            this.maxWait = maxWait;
        }

        public long getTimeBetweenEvictionRunsMillis() {
            return timeBetweenEvictionRunsMillis;
        }

        public void setTimeBetweenEvictionRunsMillis(long timeBetweenEvictionRunsMillis) {
            this.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
        }

        public long getMinEvictableIdleTimeMillis() {
            return minEvictableIdleTimeMillis;
        }

        public void setMinEvictableIdleTimeMillis(long minEvictableIdleTimeMillis) {
            this.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
        }

        public String getValidationQuery() {
            return validationQuery;
        }

        public void setValidationQuery(String validationQuery) {
            this.validationQuery = validationQuery;
        }

        public boolean isTestWhileIdle() {
            return testWhileIdle;
        }

        public void setTestWhileIdle(boolean testWhileIdle) {
            this.testWhileIdle = testWhileIdle;
        }

        public boolean isTestOnBorrow() {
            return testOnBorrow;
        }

        public void setTestOnBorrow(boolean testOnBorrow) {
            this.testOnBorrow = testOnBorrow;
        }

        public boolean isTestOnReturn() {
            return testOnReturn;
        }

        public void setTestOnReturn(boolean testOnReturn) {
            this.testOnReturn = testOnReturn;
        }

        public int getMaxPoolPreparedStatementPerConnectionSize() {
            return maxPoolPreparedStatementPerConnectionSize;
        }

        public void setMaxPoolPreparedStatementPerConnectionSize(int maxPoolPreparedStatementPerConnectionSize) {
            this.maxPoolPreparedStatementPerConnectionSize = maxPoolPreparedStatementPerConnectionSize;
        }

        public String getFilters() {
            return filters;
        }

        public void setFilters(String filters) {
            this.filters = filters;
        }
    }
}

package com.example.mybatis.config;

import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
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;

@Configuration
public class DruidConfig {

    @Bean
    public ServletRegistrationBean druidServlet() { // 主要實現WEB監控的配置處理
        ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(
                new StatViewServlet(), "/druid/*"); // 現在要進行druid監控的配置處理操作
        servletRegistrationBean.addInitParameter("allow", ""); // 白名單
        servletRegistrationBean.addInitParameter("deny", "192.168.1.200"); // 黑名單
        servletRegistrationBean.addInitParameter("loginUsername", "admin"); // 用戶名
        servletRegistrationBean.addInitParameter("loginPassword", "admin"); // 密碼
        servletRegistrationBean.addInitParameter("resetEnable", "false"); // 是否可以重置數據源
        return servletRegistrationBean ;
    }

    @Bean
    public FilterRegistrationBean filterRegistrationBean() {
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean() ;
        filterRegistrationBean.setFilter(new WebStatFilter());
        filterRegistrationBean.addUrlPatterns("/*"); // 所有請求進行監控處理
        filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.css,/druid/*");
        return filterRegistrationBean ;
    }

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

package com.example.mybatis.config;

import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;
import java.io.IOException;

@Configuration
@EnableTransactionManagement // 啓註解事務管理，等同於xml配置方式的 <tx:annotation-driven />
public class SessionFactoryConfig {

    private static String MYBATIS_CONFIG = "mybatis-config.xml";
    static final String PACKAGE = "com.example.mybatis.entity";
    static final String MAPPER_LOCATION = "classpath:mapper/*.xml";

    @Autowired
    private DataSource dataSource;

    @Bean(name = "sqlSessionFactory")
    public SqlSessionFactoryBean createSqlSessionFactoryBean() throws IOException {
        final SqlSessionFactoryBean sqlSessionFactory = new SqlSessionFactoryBean();
        // 設置mybatis configuration 掃描路徑
        sqlSessionFactory.setConfigLocation(new ClassPathResource(MYBATIS_CONFIG));
        // 設置datasource
        sqlSessionFactory.setDataSource(dataSource);
        sqlSessionFactory.setTypeAliasesPackage(PACKAGE);
        sqlSessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources(MAPPER_LOCATION));
        return sqlSessionFactory;
    }
}

package com.example.mybatis.mapper;

import com.example.mybatis.entity.Dept;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

//@Mapper
public interface DeptMapper {

   List<Dept> getAll();
   Dept getOne(Integer deptno);
   void insert(Dept dept);
   void update(Dept dept);
   void delete(Integer deptno);
}

<?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.example.mybatis.mapper.DeptMapper">
    <resultMap id="dept" type="com.example.mybatis.entity.Dept">
        <result column="deptno" property="deptno"></result>
        <result column="dname" property="dname"></result>
        <result column="loc" property="loc"></result>
    </resultMap>
    
    <sql id="base-columns">
        deptno,dname,loc
    </sql>
    <select id="queryAllDepts" resultMap="dept">
        select deptno,dname,loc from dept
    </select>

    <select id="getAll" resultMap="dept">
        select
        <include refid="base-columns"></include>
        from dept
    </select>

    <select id="getOne" resultMap="dept" parameterType="java.lang.Integer">
        select
        <include refid="base-columns"></include>
        from dept
        where deptno=#{deptno}
    </select>

    <insert id="insert" parameterType="com.example.mybatis.entity.Dept">
        insert into dept (deptno,dname,loc) values (#{deptno},#{dname},#{loc})
    </insert>

    <update id="update" parameterType="com.example.mybatis.entity.Dept">
    update dept set
        <if test="dname!=null and dname!=''">dname=#{dname},</if>
        <if test="loc!=null and loc!=''">loc=#{loc},</if>
        deptno=#{deptno}
     where  deptno = #{deptno}
    </update>

    <delete id="delete" parameterType="java.lang.Integer">
        delete from dept where  deptno = #{deptno}
    </delete>

</mapper>

package com.example.mybatis.service;

import com.example.mybatis.entity.Dept;
import com.example.mybatis.mapper.DeptMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
public class DeptService {

    @Autowired
    private DeptMapper deptMapper;

    public List<Dept> getAll(){
        return deptMapper.getAll();
    }
    public Dept getOne(Integer deptno){
        return deptMapper.getOne(deptno);
    }
    public void insert(Dept dept){
        deptMapper.insert(dept);
    }
    @Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT,timeout=36000,rollbackFor=Exception.class)
    public void update(Dept dept){
        deptMapper.update(dept);
        deptMapper.delete(60);
        int i = 122/0;
    }
    @Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT,timeout=36000,rollbackFor=Exception.class)
    public void delete(Integer deptno){
        deptMapper.delete(deptno);
        int i = 122/0;
    }
}

#數據庫配置
spring.datasource.url=jdbc:oracle:thin:@localhost:1521:orcl
spring.datasource.username=scott
spring.datasource.password=bruce123
spring.datasource.driver-class-name=oracle.jdbc.driver.OracleDriver
# 連接池配置
# 初始化大小，最小，最大
spring.datasource.initialSize=5
spring.datasource.minIdle=5
spring.datasource.maxActive=20
# 配置獲取連接等待超時的時間
spring.datasource.maxWait=60000
# 配置間隔多久才進行一次檢測，檢測需要關閉的空閒連接，單位是毫秒
spring.datasource.timeBetweenEvictionRunsMillis=60000
# 配置一個連接在池中最小生存的時間，單位是毫秒
spring.datasource.minEvictableIdleTimeMillis=300000
# 測試連接是否有效的sql
spring.datasource.validationQuery=select 1 from dual
# 建議配置爲true，不影響性能，並且保證安全性
# 申請連接的時候檢測，如果空閒時間大於timeBetweenEvictionRunsMillis，執行validationQuery檢測連接是否有效
spring.datasource.testWhileIdle=true
# 申請連接時執行validationQuery檢測連接是否有效
spring.datasource.testOnBorrow=false
# 歸還連接時執行validationQuery檢測連接是否有效
spring.datasource.testOnReturn=false
# 要啓用PSCache，必須配置大於0，當大於0時，poolPreparedStatements自動觸發修改爲true
spring.datasource.maxPoolPreparedStatementPerConnectionSize=20
# 屬性類型是字符串，通過別名的方式配置擴展插件，常用的插件有：
# 監控統計用的filter:stat
# 日誌用的filter:log4j
# 防禦sql注入的filter:wall
spring.datasource.filters=stat,wall

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>

        <!-- 使用jdbc的getGeneratedKeys獲取數據庫自增主鍵值 -->
        <setting name="useGeneratedKeys" value="true" />

        <!-- 使用列別名替換列名 默認:true -->
        <setting name="useColumnLabel" value="true" />

        <!-- 開啓駝峯命名轉換:Table{create_time} -> Entity{createTime} -->
        <setting name="mapUnderscoreToCamelCase" value="true" />

        <!-- 打印查詢語句 -->
        <setting name="logImpl" value="STDOUT_LOGGING" />
    </settings>
    <typeAliases>
        <typeAlias alias="Integer" type="java.lang.Integer" />
        <typeAlias alias="Long" type="java.lang.Long" />
        <typeAlias alias="HashMap" type="java.util.HashMap" />
        <typeAlias alias="LinkedHashMap" type="java.util.LinkedHashMap" />
        <typeAlias alias="ArrayList" type="java.util.ArrayList" />
        <typeAlias alias="LinkedList" type="java.util.LinkedList" />
    </typeAliases>

</configuration>