Apr01Chell
Apr01Chell

Spring Boot + Spring JPA + JDBC + Druid实现动态数据源切换

Spring Boot + Spring JPA + JDBC + Druid实现动态数据源切换

目录

Spring Boot + Spring JPA + JDBC + Druid实现动态数据源切换

AbstractRoutingDataSource源码分析

需求代码实现

DynamicDataSource

DBContextHolder

DruidDbConfig

DataSourceProperties

AllDataSourcesExecuteSQLDevice

application.properties

参考：https://blog.csdn.net/aiyo92/article/details/101064167#comments_12008727

最后：

总结：

背景：公司开发一个系统，需要满足根据传入的数据库信息和sql，对应的去该库中执行该sql。

关键点：spring-jdbc的AbstractRoutingDataSource抽象类。

AbstractRoutingDataSource源码分析

属性：

  • targetDataSources: 目标数据源

  • defaultTargetDataSource: 默认目标数据源

  • resolvedDataSources: 存储是数据库标识和数据源的映射关系

方法：

  • determineCurrentLookupKey()

  • setTargetDataSources()

  • setDefaultTargetDataSource()

 

分析：

先看关系，AbstractRoutingDataSource继承AbstractDataSource，AbstractDataSource实现DataSource， 既然是实现DataSource接口那就应该有getConnection()这个方法，一看果然有

@Override
public Connection getConnection() throws SQLException {
    return determineTargetDataSource().getConnection();
}
​
@Override
public Connection getConnection(String username, String password) throws SQLException {
    return determineTargetDataSource().getConnection(username, password);
}

getConnection()方法内容也很简单,determineTargetDataSource().getConnection();determineTargetDataSource(): 看名知意，确定目标数据DataSource，再从DataSource中获取Connection。

下面看determineTargetDataSource()方法：

/**
* Retrieve the current target DataSource. Determines the
* {@link #determineCurrentLookupKey() current lookup key}, performs
* a lookup in the {@link #setTargetDataSources targetDataSources} map,
* falls back to the specified
* {@link #setDefaultTargetDataSource default target DataSource} if necessary.
* @see #determineCurrentLookupKey()
*/
protected DataSource determineTargetDataSource() {
    // resolvedDataSources数据源是否为空
    Assert.notNull(this.resolvedDataSources, "DataSource router not initialized");
    // 确定当前数据源的key
    Object lookupKey = determineCurrentLookupKey();
    // 从resolvedDataSources集合中根据key获取DataSource
    DataSource dataSource = this.resolvedDataSources.get(lookupKey);
    if (dataSource == null && (this.lenientFallback || lookupKey == null)) {
        dataSource = this.resolvedDefaultDataSource;
    }
    if (dataSource == null) {
        throw new IllegalStateException("Cannot determine target DataSource for lookup key [" + lookupKey + "]");
    }
    return dataSource;
}

关键代码是determineCurrentLookupKey()方法：

/**
* Determine the current lookup key. This will typically be
* implemented to check a thread-bound transaction context.
* 
Allows for arbitrary keys. The returned key needs
* to match the stored lookup key type, as resolved by the
* {@link #resolveSpecifiedLookupKey} method.
*/
@Nullable
protected abstract Object determineCurrentLookupKey();

这是一个抽象方法，翻译一下注释：确定当前的lookupKey。通常将其实现为检查线程绑定事务的上下文。允许任意key。返回的key需要匹配由resolveSpecifiedLookupKey()方法存储的lookup key类型。

需求代码实现

DynamicDataSource

继承AbstractRoutingDataSource，覆写determineCurrentLookupKey()

package com.zchi.multiple_datasources_dynamic_switch;
​
import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.stat.DruidDataSourceStatManager;
import lombok.extern.slf4j.Slf4j;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
​
import javax.sql.DataSource;
import java.sql.Connection;
import java.util.Map;
import java.util.Set;
​
/**
 * @author zchi
 * @version 1.0
 * @description 动态数据源类
 * @createdate 2021/2/4
 */
@Slf4j
public class DynamicDataSource extends AbstractRoutingDataSource {
    /**
     * 存放动态数据源
     */
    private Map dynamicTargetDataSources;
​
    /**
     * 存放动态数据源
     */
    private Object dynamicDefaultTargetDataSource;
​
    @Override
    protected Object determineCurrentLookupKey() {
        String datasource = DBContextHolder.getDataSource();
        return datasource;
    }
​
    @Override
    public void setTargetDataSources(Map targetDataSources) {
        super.setTargetDataSources(targetDataSources);
        this.dynamicTargetDataSources = targetDataSources;
    }
​
    @Override
    public void setDefaultTargetDataSource(Object defaultTargetDataSource) {
        super.setDefaultTargetDataSource(defaultTargetDataSource);
        this.dynamicDefaultTargetDataSource = defaultTargetDataSource;
    }
​
    /**
     * @param dataSourceProperties 自己封装的数据库连接信息
     * @return DataSource 数据源
     * @throws Exception 异常
     */
    public DataSource createDataSourceWithCheck(DataSourceProperties dataSourceProperties) throws Exception {
        DataSource dataSourceTemp = null;
        String datasourceId = dataSourceProperties.getId();
        log.info("使用数据源: {} name: {}", datasourceId, dataSourceProperties.getText());
        Map dynamicTargetDataSources2 = this.dynamicTargetDataSources;
        if (dynamicTargetDataSources2.containsKey(datasourceId)) {
            log.info("数据源: {} name: {} 之前已经创建，准备测试数据源是否正常...", datasourceId, dataSourceProperties.getText());
            DruidDataSource druidDataSource = (DruidDataSource) dynamicTargetDataSources2.get(datasourceId);
            boolean rightFlag = true;
            Connection connection = null;
            dataSourceTemp = druidDataSource;
            try {
                log.info(datasourceId + "数据源的概况->当前闲置连接数：" + druidDataSource.getPoolingCount());
                long activeCount = druidDataSource.getActiveCount();
                log.info(datasourceId + "数据源的概况->当前活动连接数：" + activeCount);
                if (activeCount > 0) {
                    log.info(datasourceId + "数据源的概况->活跃连接堆栈信息：" + druidDataSource.getActiveConnectionStackTrace());
                }
                log.info("准备获取数据库连接...");
                connection = druidDataSource.getConnection();
                log.info("数据源 {} 正常", datasourceId);
            } catch (Exception e) {
                log.error(e.getMessage(), e); //把异常信息打印到日志文件
                rightFlag = false;
                log.info("缓存数据源 {} 已失效，准备删除...", datasourceId);
                if (delDatasources(datasourceId)) {
                    log.info("缓存数据源删除成功");
                } else {
                    log.info("缓存数据源删除失败");
                }
            } finally {
                if (null != connection) {
                    connection.close();
                }
            }
            if (rightFlag) {
                log.info("不需要重新创建数据源");
                return dataSourceTemp;
            } else {
                log.info("准备重新创建数据源...");
                dataSourceTemp = createDataSource(dataSourceProperties);
                log.info("重新创建数据源完成");
            }
        } else {
            dataSourceTemp = createDataSource(dataSourceProperties);
        }
        return dataSourceTemp;
    }
​
    /**
     * 创建数据源
     * @param dataSourceProperties 数据源配置
     * @return
     * @throws Exception
     */
    private DataSource createDataSource(DataSourceProperties dataSourceProperties) throws Exception {
        String key = dataSourceProperties.getId();
        log.info("准备创建数据源 {}", key);
        DruidDataSource druidDataSource = null;
        try {
            druidDataSource = new DruidDataSource();
​
            druidDataSource.setName(key);
            druidDataSource.setDriverClassName(dataSourceProperties.getDbdrive());
            druidDataSource.setUrl(dataSourceProperties.getUrl());
            druidDataSource.setUsername(dataSourceProperties.getUsername());
            druidDataSource.setPassword(dataSourceProperties.getPassword());
            // 初始化时建立物理连接的个数。初始化发生在显示调用init方法，或者第一次getConnection时
            druidDataSource.setInitialSize(dataSourceProperties.getInitialSize());
            // 最小连接池数量
            druidDataSource.setMinIdle(dataSourceProperties.getMinIdle());
            // 最大连接池数量
            druidDataSource.setMaxActive(dataSourceProperties.getMaxActive());
            // 获取连接时最大等待时间，单位毫秒。当链接数已经达到了最大链接数的时候，应用如果还要获取链接就会出现等待的现象，等待链接释放并回到链接池，如果等待的时间过长就应该踢掉这个等待，不然应用很可能出现雪崩现象
            druidDataSource.setMaxWait(60000);
            // 配置一个连接在池中最小生存的时间，单位是毫秒
            druidDataSource.setMinEvictableIdleTimeMillis(dataSourceProperties.getMinEvictableIdleTime());
            druidDataSource.setMaxEvictableIdleTimeMillis(dataSourceProperties.getMaxEvictableIdleTime());
​
            // 申请连接时执行validationQuery检测连接是否有效，这里建议配置为TRUE，防止取到的连接不可用
            druidDataSource.setTestOnBorrow(true);
            // 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
            druidDataSource.setTestWhileIdle(true);
            // 属性类型是字符串，通过别名的方式配置扩展插件，常用的插件有：监控统计用的filter:stat日志用的filter:log4j防御sql注入的filter:wall
            druidDataSource.setFilters("stat");
            // 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
            druidDataSource.setTimeBetweenEvictionRunsMillis(60000);
            // 打开druid.keepAlive之后，当连接池空闲时，池中的minIdle数量以内的连接，空闲时间超过minEvictableIdleTimeMillis，则会执行keepAlive操作，即执行druid.validationQuery指定的查询SQL，一般为
            // select * from dual，只要minEvictableIdleTimeMillis设置的小于防火墙切断连接时间，就可以保证当连接空闲时自动做保活检测，不会被防火墙切断
            druidDataSource.setKeepAlive(true); 
​
            // 是否移除泄露的连接/超过时间限制是否回收。
            druidDataSource.setRemoveAbandoned(true);
            // 泄露连接的定义时间(要超过最大事务的处理时间)；单位为秒。这里配置为10min
            druidDataSource.setRemoveAbandonedTimeout(600);
            // 移除泄露连接发生是是否记录日志
            druidDataSource.setLogAbandoned(true);
            // 在请求失败以后是否中断
            druidDataSource.setBreakAfterAcquireFailure(true);
            //请求失败尝试次数
            druidDataSource.setConnectionErrorRetryAttempts(0);
​
            druidDataSource.init();
            Map dynamicTargetDataSources_temp = this.dynamicTargetDataSources;
            // 加入map
            dynamicTargetDataSources_temp.put(key, druidDataSource);
            // 将map赋值给父类的TargetDataSources
            setTargetDataSources(dynamicTargetDataSources_temp);
            // 将TargetDataSources中的连接信息放入resolvedDataSources管理
            super.afterPropertiesSet();
            log.info("数据源 {} 初始化成功", key);
            return druidDataSource;
        } catch (Exception e) {
            druidDataSource.close();
            throw new Exception("数据源" + key + "创建失败: " + e.toString());
        }
    }
​
    /**
     * 删除缓存中的数据源
     *
     * @param datasourceid
     * @return
     */
    public boolean delDatasources(String datasourceid) {
        Map dynamicTargetDataSources2 = this.dynamicTargetDataSources;
        if (dynamicTargetDataSources2.containsKey(datasourceid)) {
            Set druidDataSourceInstances = DruidDataSourceStatManager.getDruidDataSourceInstances();
            for (DruidDataSource druidDataSource : druidDataSourceInstances) {
                if (datasourceid.equals(druidDataSource.getName())) {
                    dynamicTargetDataSources2.remove(datasourceid);
                    DruidDataSourceStatManager.removeDataSource(druidDataSource);
                    druidDataSource.close();
                    setTargetDataSources(dynamicTargetDataSources2);// 将map赋值给父类的TargetDataSources
                    super.afterPropertiesSet();// 将TargetDataSources中的连接信息放入resolvedDataSources管理
                    return true;
                }
            }
            return false;
        } else {
            return false;
        }
    }
}
​

DBContextHolder

/**
 * @author zchi
 * @version 1.0
 * @description 数据源切换类
 * @createdate 2021/2/4
 */
public class DBContextHolder {
​
    // 对当前线程的操作-线程安全的
    private static final ThreadLocal contextHolder = new ThreadLocal();
    // 调用此方法，切换数据源
    public static void setDataSource(String dataSource) {
        contextHolder.set(dataSource);
    }
​
    // 获取数据源
    public static String getDataSource() {
        return contextHolder.get();
    }
​
    // 删除数据源
    public static void clearDataSource() {
        contextHolder.remove();
    }
}

 

DruidDbConfig

package com.zchi.multiple_datasources_dynamic_switch;
​
import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
​
import javax.persistence.EntityManager;
import javax.sql.DataSource;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
​
/**
 * @author zchi
 * @version 1.0
 * @description 数据源配置类 主要功能是创建系统数据源对象和动态数据源对象
 * @createdate 2021/2/4
 */
@Configuration
public class DruidDbConfig {
​
    @Autowired
    private JpaProperties jpaProperties;
​
    @Autowired
    private DataSourceProperties basicProperties;
​
    @Bean(name = "systemDataSource") // 声明其为Bean实例
    @Primary // 在同样的DataSource中，首先使用被标注的DataSource
    @ConfigurationProperties("spring.datasource.druid")
    public DataSource dataSource() {
        DruidDataSource druidDataSource = new DruidDataSource();
        // 將DataSourceProperties基本的屬性（driverClassName、url、username、password、type）塞进druidDataSource
        afterPropertiesSet(druidDataSource);
        return druidDataSource;
    }
​
    @Bean(name = "dynamicDataSource")
    public DynamicDataSource dynamicDataSource() {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        dynamicDataSource.setDefaultTargetDataSource(dataSource());
        Map targetDataSources = new HashMap<>();
        targetDataSources.put("systemDataSource", dataSource());
        dynamicDataSource.setTargetDataSources(targetDataSources);
        return dynamicDataSource;
    }
​
    @Bean(name = "systemNamedJdbcTemplate")
    @Primary
    public NamedParameterJdbcTemplate systemNamedJdbcTemplate(@Qualifier("systemDataSource") DataSource dataSource) {
        return new NamedParameterJdbcTemplate(dataSource);
    }
​
    @Bean(name = "systemJdbcTemplate")
    @Primary
    public JdbcTemplate systemJdbcTemplate(@Qualifier("systemDataSource") DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
​
    @Bean(name = "dynamicJdbcTemplate")
    @Primary
    public JdbcTemplate jdbcTemplate(@Qualifier("dynamicDataSource") DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
​
    @Bean(name = "dynamicNamedJdbcTemplate")
    public NamedParameterJdbcTemplate dynamicNamedJdbcTemplate(@Qualifier("dynamicDataSource") DataSource dataSource) {
        return new NamedParameterJdbcTemplate(dataSource);
    }
​
    @Bean(name = "entityManagerFactory")
    @Primary
    public LocalContainerEntityManagerFactoryBean entityManageFactory(EntityManagerFactoryBuilder builder) throws SQLException {
        return builder.dataSource(dataSource()).packages("com.dtsz.portalspringboot.pojo.model").properties(jpaProperties.getProperties()).build();
    }
​
    @Bean(name = "entityManager")
    @Primary
    public EntityManager entityManager(EntityManagerFactoryBuilder builder) throws SQLException {
        return entityManageFactory(builder).getObject().createEntityManager();
    }
​
​
    @Bean(name = "dynamicEntityManageFactory")
    public LocalContainerEntityManagerFactoryBean dynamicEntityManageFactory(EntityManagerFactoryBuilder builder) throws SQLException {
        return builder.dataSource(dynamicDataSource()).packages("com.dtsz.portalspringboot.pojo.model").properties(jpaProperties.getProperties()).build();
    }
​
    @Bean(name = "dynamicEntityManage")
    public EntityManager dynamicEntityManage(EntityManagerFactoryBuilder builder) throws SQLException {
        return entityManageFactory(builder).getObject().createEntityManager();
    }
​
    /**
     * 装配事务管理器 (name = "transactionManager")
     * @return
     */
//    @Bean(name="")
//    public DataSourceTransactionManager jdbcTemplateTransactionManager(@Qualifier("dynamicDataSource") DataSource dataSource) {
//        return new DataSourceTransactionManager(dataSource);
//    }
​
    /**
     * 將DataSourceProperties基本的屬性（driverClassName、url、username、password、type）塞进druidDataSource
     * 跟着druid-spring-boot-starter的DruidDataSourceWrapper类学的，具体自己查看体会。
     * @param druidDataSource
     */
    private void afterPropertiesSet(DruidDataSource druidDataSource) {
        if (druidDataSource.getUsername() == null) {
            druidDataSource.setUsername(this.basicProperties.determineUsername());
        }
​
        if (druidDataSource.getPassword() == null) {
            druidDataSource.setPassword(this.basicProperties.determinePassword());
        }
​
        if (druidDataSource.getUrl() == null) {
            druidDataSource.setUrl(this.basicProperties.determineUrl());
        }
​
        if (druidDataSource.getDriverClassName() == null) {
            druidDataSource.setDriverClassName(this.basicProperties.getDriverClassName());
        }
    }
​
}

 

DataSourceProperties

package com.zchi.multiple_datasources_dynamic_switch;
​
import lombok.Data;
import lombok.Getter;
import lombok.Setter;
import org.hibernate.annotations.GenericGenerator;
​
import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Transient;
​
/**
 * @author zchi
 * @version 1.0
 * @description 数据源配置，封装连接数据库的一些信息
 * @createdate 2021/2/4
 */
@Data
@Getter
@Setter
public class DataSourceProperties {
​
    private String id;
    private String code;
    private String name;
    /**
     * 名称
     */
    @Column(name = "TEXT", length = 150)
    private String text;
    /**
     * 数据库名称
     */
    private String database;
    /**
     * 链接地址
     */
    private String url;
​
    private String username;
​
    private String password;
​
    private String dbdrive;
​
    private Integer minActionNum;
​
    private Integer maxActionNum;
​
    // 连接最小存活时间 毫秒
    private Integer minEvictableIdleTime = 300000;
​
    // 连接最大存活时间,必须小于数据库的配置的时间毫秒
    private Integer maxEvictableIdleTime = 900000;
​
    private Integer initialSize;
​
    private Integer minIdle;
​
    private Integer maxActive;
​
}
​

AllDataSourcesExecuteSQLDevice

package com.zchi.multiple_datasources_dynamic_switch;
​
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.neo4j.driver.internal.spi.ConnectionPool;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Component;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.DefaultTransactionDefinition;
​
import javax.sql.DataSource;
import java.util.List;
import java.util.Map;
​
/**
 * @author zchi
 * @version 1.0
 * @description 所有的数据源sql执行器
 * @createdate 2021/2/4
 */
@Slf4j
@Component
@Transactional
public class AllDataSourcesExecuteSQLDevice {
​
    @Autowired
    @Qualifier("systemJdbcTemplate")
    private JdbcTemplate systemJdbcTemplate;
​
    @Autowired
    @Qualifier("systemNamedJdbcTemplate")
    private NamedParameterJdbcTemplate systemNamedJdbcTemplate;
​
    @Autowired
    @Qualifier("dynamicJdbcTemplate")
    private JdbcTemplate dynamicJdbcTemplate;
​
    @Autowired
    @Qualifier("dynamicNamedJdbcTemplate")
    private NamedParameterJdbcTemplate dynamicNamedJdbcTemplate;
​
    @Autowired
    @Qualifier("dynamicDataSource")
    private DynamicDataSource dynamicDataSource;
​
    /**
     * 任意数据源做Select操作
     *
     * @param dataSourceProperties 数据源 若为null则使用系统数据源
     * @param sql        要执行的sql :xxx 形式的占位符
     * @param params     需要替换的参数
     * @return
     * @throws Exception
     */
    public List> doSelect(DataSourceProperties dataSourceProperties, String sql, Map params) throws Exception {
        log.info("执行sql查询doSelect-sql: {},sql_params: {}", sql, JSON.toJSONString(params));
        List> resultList = null;
        if (params == null) {
            resultList = getJdbcTemplate(dataSourceProperties).queryForList(sql);
        } else {
            resultList = getNamedParameterJdbcTemplate(dataSourceProperties).queryForList(sql, params);
        }
        return resultList;
    }
​
    /**
     * 任意数据源做Select操作
     *
     * @param dataSourceProperties 数据源 若为null则使用系统数据源
     * @param sql        要执行的sql ? 形式的占位符
     * @param params     需要替换的参数
     * @return
     * @throws Exception
     */
    public List doSelect(DataSourceProperties dataSourceProperties, String sql, List params) throws Exception {
        log.info("执行sql查询doSelect-sql: {}, sql_params: {}", sql, JSON.toJSONString(params));
        List resultList = null;
        if (params != null) {
            resultList = getJdbcTemplate(dataSourceProperties).queryForList(sql, params.toArray(), Map.class);
        } else {
            resultList = getJdbcTemplate(dataSourceProperties).queryForList(sql, Map.class);
        }
        return resultList;
    }
​
    /**
     * 任意数据源做update操作
     *
     * @param dataSourceProperties 数据源 若为null则使用系统数据源
     * @param sql        要执行的sql :xxx 形式的占位符
     * @param params     需要替换的参数
     * @return
     */
    public int doUpdate(DataSourceProperties dataSourceProperties, String sql, Map params) throws Exception {
        log.info("执行sql更新doUpdate-sql: {}, sql_params: {}", sql, JSON.toJSONString(params));
        int row = 0;
        if (params == null) {
            row = getJdbcTemplate(dataSourceProperties).update(sql);
        } else {
            row = getNamedParameterJdbcTemplate(dataSourceProperties).update(sql, params);
        }
        return row;
    }
​
    /**
     * 任意数据源做update操作
     *
     * @param dataSourceProperties 数据源 若为null则使用系统数据源
     * @param sql        要执行的sql ? 形式的占位符
     * @param params     需要替换的参数
     * @return
     */
    public int doUpdate(DataSourceProperties dataSourceProperties, String sql, Object[] params) throws Exception {
        log.info("执行sql更新doUpdate-sql: {}, sql_params: {}", sql, JSON.toJSONString(params));
        int row = 0;
        if (params == null) {
            row = getJdbcTemplate(dataSourceProperties).update(sql);
        } else {
            row = getJdbcTemplate(dataSourceProperties).update(sql, params);
        }
        return row;
    }
​
    /**
     * 根据数据源获得JdbcTemplate
     *
     * @param dataSourceProperties 数据源
     * @return
     * @throws Exception
     */
    private JdbcTemplate getJdbcTemplate(DataSourceProperties dataSourceProperties) throws Exception {
        if (dataSourceProperties == null) { // 空则使用默认的system数据源
            return systemJdbcTemplate;
        }
        // 切换数据源
        changeDataSource(dataSourceProperties);
        return dynamicJdbcTemplate;
    }
​
    /**
     * 根据数据换获得NamedParameterJdbcTemplate
     *
     *
     * @param dataSourceProperties 数据源
     * @return
     * @throws Exception
     */
    private NamedParameterJdbcTemplate getNamedParameterJdbcTemplate(DataSourceProperties dataSourceProperties) throws Exception {
        if (dataSourceProperties == null) { // 空则使用默认的system数据源
            return systemNamedJdbcTemplate;
        }
        // 切换数据源
        changeDataSource(dataSourceProperties);
        return dynamicNamedJdbcTemplate;
    }
​
​
​
    /**
     * 切换数据源
     *
     * @param dataSourceProperties
     * @return 事务管理器
     * @throws Exception
     */
    private DataSourceTransactionManager changeDataSource(DataSourceProperties dataSourceProperties) throws Exception {
        DataSource dataSource1 = dynamicDataSource.createDataSourceWithCheck(dataSourceProperties);
        DBContextHolder.setDataSource(dataSourceProperties.getId());
        return new DataSourceTransactionManager(dataSource1);
    }
​
    /**
     * 开启事务
     */
    private TransactionStatus beginTransaction(DataSourceTransactionManager transactionManager) {
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        // 设置事务隔离级别
        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
        // 返回事务对象
        TransactionStatus status = transactionManager.getTransaction(def);
        return status;
    }
​
    /**
     * 提交事务
     *
     * @param transactionManager
     * @param status
     */
    private void commitTransaction(DataSourceTransactionManager transactionManager, TransactionStatus status) {
        transactionManager.commit(status);
    }
​
    /**
     * 事务回滚
     *
     * @param transactionManager
     * @param status
     */
    private void rollbackTransaction(DataSourceTransactionManager transactionManager, TransactionStatus status) {
        transactionManager.rollback(status);
    }
}
​ 
  
application.properties
 
  
spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/zchi_test
spring.datasource.username=root
spring.datasource.password=nopassword
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
​
spring.datasource.druid.initial-size=1
spring.datasource.druid.max-active=10
spring.datasource.druid.min-idle=1
spring.datasource.druid.max-wait=-1
 
  
参考：https://blog.csdn.net/aiyo92/article/details/101064167#comments_12008727
 
  
最后：
 
  
感谢上边博主的分享
 
  
总结：
 
  
     
   
  1.  
    本博客在该博主基础上优化了一下默认数据源的注入，默认数据源的druid配置直接在配置文件中配置,不用再修改DruidDbConfig.dataSource()的代码。
     
    2.  
   
  2.  
    DynamicDataSource.createDataSource()异常时close()掉和DynamicDataSource.delDatasources()
     
    3.  
  
 
  
时close()掉。DruidDataSourceStatManager.removeDataSource(druidDataSource);并没有真正的关闭连接导致数据库的session一直存在。
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(代码片段,spring,java,数据库)

        

            

                
    
                    
  • 移动端城市区县二级联动选择功能实现包
                        good2know

                        
    本文还有配套的精品资源，点击获取简介：本项目是一套为移动端设计的jQuery实现方案，用于简化用户在选择城市和区县时的流程。它包括所有必需文件：HTML、JavaScript、CSS及图片资源。通过动态更新下拉菜单选项，实现城市到区县的联动效果，支持数据异步加载。开发者可以轻松集成此功能到移动网站或应用，并可基于需求进行扩展和优化。1.jQuery移动端解决方案概述jQuery技术简介jQuery
    
                    
    • 
                    
  • SpringMVC执行流程（原理），通俗易懂
                        国服冰
SpringMVCspringmvc
                        
    SpringMVC执行流程（原理），通俗易懂一、图解SpringMVC流程二、进一步理解Springmvc的执行流程1、导入依赖2、建立展示的视图3、web.xml4、spring配置文件springmvc-servlet5、Controller6、tomcat配置7、访问的url8、视图页面一、图解SpringMVC流程图为SpringMVC的一个较完整的流程图，实线表示SpringMVC框架提
    
                    
    • 
                    
  • 深入解析JVM工作原理：从字节码到机器指令的全过程
                        

                        
    一、JVM概述Java虚拟机(JVM)是Java平台的核心组件，它实现了Java"一次编写，到处运行"的理念。JVM是一个抽象的计算机器，它有自己的指令集和运行时内存管理机制。JVM的主要职责：加载：读取.class文件并验证其正确性存储：管理内存分配和垃圾回收执行：解释或编译字节码为机器指令安全：提供沙箱环境限制恶意代码二、JVM架构详解JVM由三个主要子系统组成：1.类加载子系统类加载过程分为
    
                    
    • 
                    
  • Spring进阶 - SpringMVC实现原理之DispatcherServlet处理请求的过程
                        倾听铃的声
后端springjavamvc开发语言分布式
                        
    前文我们有了IOC的源码基础以及SpringMVC的基础，我们便可以进一步深入理解SpringMVC主要实现原理，包含DispatcherServlet的初始化过程和DispatcherServlet处理请求的过程的源码解析。本文是第二篇：DispatcherServlet处理请求的过程的源码解析。@pdaiSpring进阶-SpringMVC实现原理之DispatcherServlet处理请求的
    
                    
    • 
                    
  • JVM 内存模型深度解析：原子性、可见性与有序性的实现
                        练习时长两年半的程序员小胡
JVM深度剖析：从面试考点到生产实践jvmjava内存模型
                        
    在了解了JVM的基础架构和类加载机制后，我们需要进一步探索Java程序在多线程环境下的内存交互规则。JVM内存模型（JavaMemoryModel，JMM）定义了线程和主内存之间的抽象关系，它通过规范共享变量的访问方式，解决了多线程并发时的数据一致性问题。本文将从内存模型的核心目标出发，详解原子性、可见性、有序性的实现机制，以及volatile、synchronized等关键字在其中的作用。一、J
    
                    
    • 
                    
  • Flowable 高级扩展：自定义元素与性能优化实战
                        练习时长两年半的程序员小胡
Flowable流程引擎实战指南流程图flowableBPMN流程引擎java
                        
    在前五篇文章中，我们从基础概念、流程设计、API实战、SpringBoot集成，到外部系统协同，逐步构建了Flowable的应用体系。但企业级复杂场景中，原生功能往往难以满足定制化需求——比如需要特殊的审批规则网关、与决策引擎联动实现动态路由，或是在高并发场景下优化流程引擎性能。本文将聚焦Flowable的高级扩展能力，详解如何自定义流程元素、集成规则引擎，并掌握大型系统中的性能调优策略。一、自定
    
                    
    • 
                    
  • 什么是缓存雪崩？缓存击穿？缓存穿透？分别如何解决？什么是缓存预热？
                        daixin8848
缓存redisjava开发语言
                        
    缓存雪崩：在一个时间段内，有大量的key过期，或者Redis服务宕机，导致大量的请求到达数据库,带来巨大压力-给key设置不同的TTL、利用Redis集群提高服务的高可用性、添加多级缓存、添加降级流策略缓存击穿：给某一个key设置了过期时间，当key过期的时间，恰好这个时间点有大量的并发请求访问这个key，可能会瞬间把数据库压垮-互斥锁：缓存失败时，只允许一个请求去加载数据并更新缓存，其他请求阻塞
    
                    
    • 
                    
  • Java | 多线程经典问题 - 售票
                        Ada54

                        
    一、售票需求1）同一个票池2）多个窗口卖票，不能出售同一张票二、售票问题代码实现（线程与进程小总结，请戳：Java|线程和进程，创建线程）step1：定义SaleWindow类实现Runnable接口，覆盖run方法step2：实例化SaleWindow对象，创建Thread对象，将SaleWindow作为参数传给Thread类的构造函数，然后通过Thread.start()方法启动线程step3
    
                    
    • 
                    
  • SpringMVC的执行流程
                        

                        
    1、什么是MVCMVC是一种设计模式。MVC的原理图如下所示M-Model模型（完成业务逻辑：有javaBean构成，service+dao+entity）V-View视图（做界面的展示jsp，html……）C-Controller控制器（接收请求—>调用模型—>根据结果派发页面2、SpringMVC是什么SpringMVC是一个MVC的开源框架，SpringMVC=Struts2+Spring，
    
                    
    • 
                    
  • 2018-09-27 aop相关
                        蒋超_58dc

                        
    1.静态织入，需要使用aspectj专用的compilermaven工程可以采用：https://www.mojohaus.org/aspectj-maven-plugin/2.动态织入，配合spring，创建代理来执行3.
    
                    
    • 
                    
  • JAVA接口机结构解析
                        秃狼
SpringBoot八股文Javajava学习
                        
    什么是接口机在Java项目中，接口机通常指用于与外部系统进行数据交互的中间层，负责处理请求和响应的转换、协议适配、数据格式转换等任务。接口机的结构我们的接口机的结构分为两个大部分，外部接口机和内部接口机，在业务的调度上也是通过mq来实现的，只要的目的就是为了解耦合和做差异化。在接口机中主要的方法就是定时任务，消息的发送和消费，其他平台调用接口机只能提供外部接口机的方法进行调用，外部接口机可以提供消
    
                    
    • 
                    
  • Aop +反射 实现方法版本动态切换
                        

                        
    需求分析在做技术选型的时候一直存在着两个声音，mongo作为数据库比较mysql好，mysql做为该数据比mongo好。当然不同数据库都有有着自己的优势，我们在做技术选型的时候无非就是做到对数据库的扬长避短。mysql最大的优势就是支持事务，事务的五大特性保证的业务可靠性，随之而来的就是事务会产生的问题：脏读、幻读、不可重复度，当然我们也会使用不同的隔离级别来解决。（最典型的业务问题：银行存取钱）
    
                    
    • 
                    
  • 最新阿里四面面试真题46道：面试技巧+核心问题+面试心得
                        风平浪静如码

                        
    前言做技术的有一种资历，叫做通过了阿里的面试。这些阿里Java相关问题，都是之前通过不断优秀人才的铺垫总结的，先自己弄懂了再去阿里面试，不然就是去丢脸，被虐。希望对大家帮助，祝面试成功，有个更好的职业规划。一，阿里常见技术面1、微信红包怎么实现。2、海量数据分析。3、测试职位问的线程安全和非线程安全。4、HTTP2.0、thrift。5、面试电话沟通可能先让自我介绍。6、分布式事务一致性。7、ni
    
                    
    • 
                    
  • 图论算法经典题目解析：DFS、BFS与拓扑排序实战
                        周童學
数据结构与算法深度优先算法图论
                        
    图论算法经典题目解析：DFS、BFS与拓扑排序实战图论问题是算法面试中的高频考点，本博客将通过四道LeetCode经典题目（均来自"Top100Liked"题库），深入讲解图论的核心算法思想和实现技巧。涵盖DFS、BFS、拓扑排序和前缀树等知识点，每道题配有Java实现和易错点分析。1.岛屿数量(DFS遍历)问题描述给定一个由'1'(陆地)和'0'(水)组成的二维网格，计算岛屿的数量。岛屿由水平或
    
                    
    • 
                    
  • 【异常】使用 LiteFlow 框架时，提示错误ChainDuplicateException: [chain name duplicate] chainName=categoryChallenge
                        本本本添哥
002-进阶开发能力java
                        
    一、报错内容Causedby:com.yomahub.liteflow.exception.ChainDuplicateException:[chainnameduplicate]chainName=categoryChallengeatcom.yomahub.liteflow.parser.helper.ParserHelper.lambda$null$0(ParserHelper.java:1
    
                    
    • 
                    
  • Java并发核心：线程池使用技巧与最佳实践！ | 多线程篇(五)
                        bug菌¹
Java实战(进阶版)javaJava零基础入门Java并发线程池多线程篇
                        
    本文收录于「Java进阶实战」专栏，专业攻坚指数级提升，希望能够助你一臂之力，帮你早日登顶实现财富自由；同时，欢迎大家关注&&收藏&&订阅！持续更新中，up！up！up！！环境说明：Windows10+IntelliJIDEA2021.3.2+Jdk1.8本文目录前言摘要正文何为线程池？为什么需要线程池？线程池的好处线程池使用场景如何创建线程池？线程池的常见配置源码解析案例分享案例代码演示案例运行
    
                    
    • 
                    
  • Java 队列
                        tryxr
java开发语言队列
                        
    队列一般用什么哪种结构实现队列的特性数据入队列时一定是从尾部插入吗数据出队列时一定是从头部删除吗队列的基本运算有什么队列支持随机访问吗队列的英文表示什么是队列队列从哪进、从哪出队列的进出顺序队列是用哪种结构实现的Queue和Deque有什么区别Queue接口的方法Queue中的add与offer的区别offer、poll、peek的模拟实现如何利用链表实现队列如何利用顺序表实现队列什么叫做双端队列
    
                    
    • 
                    
  • JVM 内存分配与回收策略：从对象创建到内存释放的全流程
                        

                        
    在JVM的运行机制中，内存分配与回收策略是连接对象生命周期与垃圾收集器的桥梁。它决定了对象在堆内存中的创建位置、存活过程中的区域迁移，以及最终被回收的时机。合理的内存分配策略能减少GC频率、降低停顿时间，是优化Java应用性能的核心环节。本文将系统解析JVM的内存分配规则、对象晋升机制，以及实战中的内存优化技巧。一、对象优先在Eden区分配：新生代的“临时缓冲区”大多数情况下，Java对象在新生代
    
                    
    • 
                    
  • 代码随想录算法训练营第三十五天
                        

                        
    01背包问题二维题目链接01背包问题二维题解importjava.util.Scanner;publicclassMain{publicstaticvoidmain(String[]args){Scannersc=newScanner(System.in);intM=sc.nextInt();intN=sc.nextInt();int[]space=newint[M];int[]value=new
    
                    
    • 
                    
  • 微信公众号回调java_处理微信公众号消息回调
                        weixin_39607620
微信公众号回调java
                        
    1、背景在上一节中，咱们知道如何接入微信公众号，可是以后公众号会与咱们进行交互，那么微信公众号如何通知到咱们本身的服务器呢？咱们知道咱们接入的时候提供的url是GET/mp/entry，那么公众号以后产生的事件将会以POST/mp/entry发送到咱们本身的服务器上。html2、代码实现，此处仍是使用weixin-java-mp这个框架实现一、引入weixin-java-mpcom.github.
    
                    
    • 
                    
  • MySQL复习题
                        

                        
    一.填空题1.关系数据库的标准语言是SQL。2.数据库发展的3个阶段中，数据独立性最高的是阶段数据库系统。3.概念模型中的3种基本联系分别是一对一、一对多和多对多。4.MySQL配置文件的文件名是my.ini或my.cnf。5.在MySQL配置文件中，datadir用于指定数据库文件的保存目录。6.添加IFNOTEXISTS可在创建的数据库已存在时防止程序报错。7.MySQL提供的SHOWCREA
    
                    
    • 
                    
  • [spring6: Mvc-网关]-源码解析
                        

                        
    推荐阅读：[spring6:Mvc-函数式编程]-源码解析GatewayServerMvcAutoConfiguration@AutoConfiguration(after={HttpClientAutoConfiguration.class,RestTemplateAutoConfiguration.class,RestClientAutoConfiguration.class,FilterAu
    
                    
    • 
                    
  • 学C++的五大惊人好处
                        

                        
    为什么要学c++学c++有什么用学习c++的好处有1.中考可以加分2.高考可能直接录取3.就业广且工资高4.在未来30--50年c++一定是一个很受欢迎的职业5.c++成功的例子deepsick等AI智能C++语言兼备编程效率和编译运行效率的语言C++语言是C语言功能增强版,在c语言的基础上添加了面向对象编程和泛型编程的支持既继承了C语言高效，简洁，快速和可移植的传统,又具备类似Java、Go等其
    
                    
    • 
                    
  • Android GreenDao介绍和Generator生成表对象代码
                        

                        
    目录(?)[-]介绍创建工程转载请注明：http://blog.csdn.net/sinat_30276961/article/details/50052109最近无意中发现了GreenDao，然后查看了一些资料后，发现这个数据库框架很适合用，于是乎，查看了官网的api，并自己写了一个小应用总结一下它的使用方法。介绍按照国际惯例，在开篇，总要先介绍一下什么是GreenDao吧。首先需要说明的是Gr
    
                    
    • 
                    
  • Java8 Stream流的sorted()的排序【正序、倒序、多字段排序】
                        Tony666688888
javawindows开发语言
                        
    针对集合排序，java8可以用Stream流的sorted()进行排序。示例Bean以下我们会使用这个Bean来做示例。publicclassOrder{privateStringweight;privateDoubleprice;privateStringdateStr;//忽略getter、setter、构造方法、toString}字段排序首先是比较器Comparator，形式如下：Compa
    
                    
    • 
                    
  • 用代码生成艺术字：设计个性化海报的秘密
                        

                        
    本文围绕“用代码生成艺术字：设计个性化海报的秘密”展开，先概述代码生成艺术字在海报设计中的独特价值，接着介绍常用的代码工具（如HTML、CSS、JavaScript等），详细阐述从构思到实现的完整流程，包括字体样式设计、动态效果添加等，还分享了提升艺术字质感的技巧及实际案例。最后总结代码生成艺术字的优势，为设计师提供打造个性化海报的实用指南，助力提升海报设计的独特性与吸引力，符合搜索引擎SEO标准
    
                    
    • 
                    
  • java实习生40多天有感
                        别拿爱情当饭吃

                        
    从5月15日开始，我开始第一步步入社会，我今年大三，在一家上市互联网公司做一名实习生，主要做java后端开发。开始的时候，觉得公司的环境挺不错的，不过因为公司在CBD，所以隔壁的午饭和晚饭都要20+RMB，而且还吃不饱，这让我感觉挺郁闷的。一到下午，我就会犯困（因为饿）。因此，我又不得不买一些干粮在公司屯着。关于技术，有一个比较大的项目在需求调研当中，我们做实习生，就是辅助项目经理，测试功能，并且
    
                    
    • 
                    
  • 大数据技术笔记—spring入门
                        卿卿老祖

                        
    篇一spring介绍spring.io官网快速开始Aop面向切面编程，可以任何位置，并且可以细致到方法上连接框架与框架Spring就是IOCAOP思想有效的组织中间层对象一般都是切入service层spring组成前后端分离已学方式，前后台未分离：Spring的远程通信：明日更新创建第一个spring项目来源：科多大数据
    
                    
    • 
                    
  • Mac OSX 下的mysql数据库文件存放位置
                        Bruuuces
mysqlmacosx位置存放
                        
    之前我的mysql的系统数据库里的表被我玩坏了，万般无奈之下只得删除所有mysql的东西重新构建数据库。按照网上搜到的内容删除后重装发现数据库没有什么变化。于是自己在每个可能存放数据库文件的目录查找，最终确认目录位置如下:使用HomeBrew安装为/usr/local/var/mysql使用官方下载的dmg镜像安装为/usr/local/mysql删除这个目录再重新安装mysql就会重新生成系统数
    
                    
    • 
                    
  • mac升级mysql_Mac OSX下的MySQL数据库升级
                        weixin_39801714
mac升级mysql
                        
    MacOSX下的数据库升级最麻烦的不过权限的问题.本文的MySQL的安装方式为OSX下DMG磁盘镜像的安装方式,MacPorts/Homebrew的方式大同小异.从5.6.17升级到5.7.18安装目录信息ls-al/usr/local|grepmysqllrwxr-xr-x1rootwheel30B52100:39mysql@->mysql-5.6.17-osx10.7-x86_64drwxr-
    
                    
    • 
                                
  • xml解析
                                    小猪猪08
xml
                                    
    1、DOM解析的步奏 
准备工作： 
   1.创建DocumentBuilderFactory的对象 
   2.创建DocumentBuilder对象 
   3.通过DocumentBuilder对象的parse(String fileName)方法解析xml文件 
   4.通过Document的getElem
    
                                
    • 
                                
  • 每个开发人员都需要了解的一个SQL技巧
                                    brotherlamp
linuxlinux视频linux教程linux自学linux资料
                                    
      
对于数据过滤而言CHECK约束已经算是相当不错了。然而它仍存在一些缺陷，比如说它们是应用到表上面的，但有的时候你可能希望指定一条约束，而它只在特定条件下才生效。 
使用SQL标准的WITH CHECK OPTION子句就能完成这点，至少Oracle和SQL Server都实现了这个功能。下面是实现方式： 
CREATE TABLE books ( 
  id &
    
                                
    • 
                                
  • Quartz——CronTrigger触发器
                                    eksliang
quartzCronTrigger
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2208295 一.概述 
CronTrigger 能够提供比 SimpleTrigger 更有具体实际意义的调度方案，调度规则基于 Cron 表达式，CronTrigger 支持日历相关的重复时间间隔（比如每月第一个周一执行），而不是简单的周期时间间隔。 二.Cron表达式介绍 1）Cron表达式规则表 
Quartz
    
                                
    • 
                                
  • Informatica基础
                                    18289753290
InformaticaMonitormanagerworkflowDesigner
                                    
    1. 
1）PowerCenter Designer：设计开发环境，定义源及目标数据结构；设计转换规则，生成ETL映射。 
2）Workflow  Manager：合理地实现复杂的ETL工作流，基于时间，事件的作业调度 
3）Workflow  Monitor：监控Workflow和Session运行情况，生成日志和报告 
4）Repository  Manager：
    
                                
    • 
                                
  • linux下为程序创建启动和关闭的的sh文件，scrapyd为例
                                    酷的飞上天空
scrapy
                                    
    对于一些未提供service管理的程序  每次启动和关闭都要加上全部路径，想到可以做一个简单的启动和关闭控制的文件 
  
下面以scrapy启动server为例，文件名为run.sh： 
  
  
#端口号，根据此端口号确定PID
PORT=6800
#启动命令所在目录
HOME='/home/jmscra/scrapy/'

#查询出监听了PORT端口
    
                                
    • 
                                
  • 人--自私与无私
                                    永夜-极光

                                    
                今天上毛概课,老师提出一个问题--人是自私的还是无私的,根源是什么? 
  
            从客观的角度来看,人有自私的行为,也有无私的
    
                                
    • 
                                
  • Ubuntu安装NS-3 环境脚本
                                    随便小屋
ubuntu
                                    
      
将附件下载下来之后解压，将解压后的文件ns3environment.sh复制到下载目录下（其实放在哪里都可以，就是为了和我下面的命令相统一）。输入命令： 
  
sudo ./ns3environment.sh >>result 
  
这样系统就自动安装ns3的环境，运行的结果在result文件中，如果提示 
  
  
com
    
                                
    • 
                                
  • 创业的简单感受
                                    aijuans
创业的简单感受
                                    
      
       2009年11月9日我进入a公司实习，2012年4月26日，我离开a公司，开始自己的创业之旅。 
     今天是2012年5月30日，我忽然很想谈谈自己创业一个月的感受。 
当初离开边锋时，我就对自己说：“自己选择的路，就是跪着也要把他走完”，我也做好了心理准备，准备迎接一次次的困难。我这次走出来，不管成败
    
                                
    • 
                                
  • 如何经营自己的独立人脉
                                    aoyouzi
如何经营自己的独立人脉
                                    
    独立人脉不是父母、亲戚的人脉，而是自己主动投入构造的人脉圈。“放长线，钓大鱼”，先行投入才能产生后续产出。       现在几乎做所有的事情都需要人脉。以银行柜员为例，需要拉储户，而其本质就是社会人脉，就是社交！很多人都说，人脉我不行，因为我爸不行、我妈不行、我姨不行、我舅不行……我谁谁谁都不行，怎么能建立人脉？我这里说的人脉，是你的独立人脉。       以一个普通的银行柜员
    
                                
    • 
                                
  • JSP基础
                                    百合不是茶
jsp注释隐式对象
                                    
      
1,JSP语句的声明 
<%! 声明 %> 　　    声明：这个就是提供java代码声明变量、方法等的场所。

表达式 <%= 表达式 %> 　　   这个相当于赋值，可以在页面上显示表达式的结果，

程序代码段/小型指令　<% 程序代码片段 %>  
  
2,JSP的注释 
  
 <!-- --> 
    
                                
    • 
                                
  • web.xml之session-config、mime-mapping
                                    bijian1013
javaweb.xmlservletsession-configmime-mapping
                                    
    session-config 
1.定义： 
<session-config>
 <session-timeout>20</session-timeout>
</session-config> 
2.作用：用于定义整个WEB站点session的有效期限，单位是分钟。 
  
mime-mapping 
1.定义： 
<mime-m
    
                                
    • 
                                
  • 互联网开放平台（1）
                                    Bill_chen
互联网qq新浪微博百度腾讯
                                    
    现在各互联网公司都推出了自己的开放平台供用户创造自己的应用，互联网的开放技术欣欣向荣，自己总结如下： 
1.淘宝开放平台(TOP) 
网址：http://open.taobao.com/ 
依赖淘宝强大的电子商务数据，将淘宝内部业务数据作为API开放出去，同时将外部ISV的应用引入进来。 
目前TOP的三条主线： 
TOP访问网站：open.taobao.com 
ISV后台：my.open.ta
    
                                
    • 
                                
  • 【MongoDB学习笔记九】MongoDB索引
                                    bit1129
mongodb
                                    
    索引 
 
 可以在任意列上建立索引 
 索引的构造和使用与传统关系型数据库几乎一样,适用于Oracle的索引优化技巧也适用于Mongodb 
 使用索引可以加快查询,但同时会降低修改,插入等的性能 
 内嵌文档照样可以建立使用索引 
 测试数据 
  
  
var p1 = {
"name":"Jack",
"age&q
    
                                
    • 
                                
  • JDBC常用API之外的总结
                                    白糖_
jdbc
                                    
     做JAVA的人玩JDBC肯定已经很熟练了，像DriverManager、Connection、ResultSet、Statement这些基本类大家肯定很常用啦，我不赘述那些诸如注册JDBC驱动、创建连接、获取数据集的API了，在这我介绍一些写框架时常用的API，大家共同学习吧。 
  
  
 
 ResultSetMetaData获取ResultSet对象的元数据信息 
 
    
                                
    • 
                                
  • apache VelocityEngine使用记录
                                    bozch
VelocityEngine
                                    
    VelocityEngine是一个模板引擎，能够基于模板生成指定的文件代码。 
  
使用方法如下： 
    VelocityEngine engine = new VelocityEngine();// 定义模板引擎 
    Properties properties = new Properties();// 模板引擎属
    
                                
    • 
                                
  • 编程之美-快速找出故障机器
                                    bylijinnan
编程之美
                                    
    
package beautyOfCoding;

import java.util.Arrays;

public class TheLostID {

	/*编程之美 
	 假设一个机器仅存储一个标号为ID的记录，假设机器总量在10亿以下且ID是小于10亿的整数，假设每份数据保存两个备份，这样就有两个机器存储了同样的数据。
		1.假设在某个时间得到一个数据文件ID的列表，是
    
                                
    • 
                                
  • 关于Java中redirect与forward的区别
                                    chenbowen00
javaservlet
                                    
    在Servlet中两种实现： 
 
forward方式：request.getRequestDispatcher(“/somePage.jsp”).forward(request, response); 
 
redirect方式：response.sendRedirect(“/somePage.jsp”); 
 
forward是服务器内部重定向，程序收到请求后重新定向到另一个程序，客户机并不知
    
                                
    • 
                                
  • [信号与系统]人体最关键的两个信号节点
                                    comsci
系统
                                    
     
 
 
        如果把人体看做是一个带生物磁场的导体,那么这个导体有两个很重要的节点,第一个在头部,中医的名称叫做 百汇穴, 另外一个节点在腰部,中医的名称叫做 命门 
 
        如果要保护自己的脑部磁场不受到外界有害信号的攻击,最简单的
    
                                
    • 
                                
  • oracle 存储过程执行权限
                                    daizj
oracle存储过程权限执行者调用者
                                    
    在数据库系统中存储过程是必不可少的利器，存储过程是预先编译好的为实现一个复杂功能的一段Sql语句集合。它的优点我就不多说了，说一下我碰到的问题吧。我在项目开发的过程中需要用存储过程来实现一个功能，其中涉及到判断一张表是否已经建立，没有建立就由存储过程来建立这张表。 
 
CREATE OR REPLACE PROCEDURE TestProc  
IS  
  fla
    
                                
    • 
                                
  • 为mysql数据库建立索引
                                    dengkane
mysql性能索引
                                    
    前些时候，一位颇高级的程序员居然问我什么叫做索引，令我感到十分的惊奇，我想这绝不会是沧海一粟，因为有成千上万的开发者（可能大部分是使用MySQL的）都没有受过有关数据库的正规培训，尽管他们都为客户做过一些开发，但却对如何为数据库建立适当的索引所知较少，因此我起了写一篇相关文章的念头。  最普通的情况，是为出现在where子句的字段建一个索引。为方便讲述，我们先建立一个如下的表。
    
                                
    • 
                                
  • 学习C语言常见误区 如何看懂一个程序 如何掌握一个程序以及几个小题目示例
                                    dcj3sjt126com
c算法
                                    
    如果看懂一个程序，分三步 
  
1、流程 
  
2、每个语句的功能 
  
3、试数 
  
如何学习一些小算法的程序 
尝试自己去编程解决它，大部分人都自己无法解决 
如果解决不了就看答案 
关键是把答案看懂，这个是要花很大的精力，也是我们学习的重点 
看懂之后尝试自己去修改程序，并且知道修改之后程序的不同输出结果的含义 
照着答案去敲 
调试错误 

    
                                
    • 
                                
  • centos6.3安装php5.4报错
                                    dcj3sjt126com
centos6
                                    
    报错内容如下: 
Resolving Dependencies 
--> Running transaction check 
---> Package php54w.x86_64 0:5.4.38-1.w6 will be installed 
--> Processing Dependency: php54w-common(x86-64) = 5.4.38-1.w6 for 
    
                                
    • 
                                
  • JSONP请求
                                    flyer0126
jsonp
                                    
      
    使用jsonp不能发起POST请求。 
It is not possible to make a JSONP POST request.
JSONP works by creating a <script> tag that executes Javascript from a different domain; it is not pos
    
                                
    • 
                                
  • Spring Security（03）——核心类简介
                                    234390216
Authentication
                                    
    核心类简介 
目录 
1.1     Authentication 
1.2     SecurityContextHolder 
1.3     AuthenticationManager和AuthenticationProvider 
1.3.1  &nb
    
                                
    • 
                                
  • 在CentOS上部署JAVA服务
                                    java--hhf
javajdkcentosJava服务
                                    
        本文将介绍如何在CentOS上运行Java Web服务，其中将包括如何搭建JAVA运行环境、如何开启端口号、如何使得服务在命令执行窗口关闭后依旧运行 
    
第一步：卸载旧Linux自带的JDK 
①查看本机JDK版本 
java -version 
   结果如下 
java version "1.6.0"
    
                                
    • 
                                
  • oracle、sqlserver、mysql常用函数对比[to_char、to_number、to_date]
                                    ldzyz007
oraclemysqlSQL Server
                                    
    oracle                                &n
    
                                
    • 
                                
  • 记Protocol Oriented Programming in Swift of WWDC 2015
                                    ningandjin
protocolWWDC 2015Swift2.0
                                    
    其实最先朋友让我就这个题目写篇文章的时候，我是拒绝的，因为觉得苹果就是在炒冷饭， 把已经流行了数十年的OOP中的“面向接口编程”还拿来讲，看完整个Session之后呢，虽然还是觉得在炒冷饭，但是毕竟还是加了蛋的，有些东西还是值得说说的。 
 
通常谈到面向接口编程，其主要作用是把系统设计和具体实现分离开，让系统的每个部分都可以在不影响别的部分的情况下，改变自身的具体实现。接口的设计就反映了系统
    
                                
    • 
                                
  • 搭建 CentOS 6 服务器(15) - Keepalived、HAProxy、LVS
                                    rensanning
keepalived
                                    
    （一）Keepalived 
 
（1）安装 
 
# cd /usr/local/src
# wget http://www.keepalived.org/software/keepalived-1.2.15.tar.gz
# tar zxvf keepalived-1.2.15.tar.gz
# cd keepalived-1.2.15
# ./configure
# make &a
    
                                
    • 
                                
  • ORACLE数据库SCN和时间的互相转换
                                    tomcat_oracle
oraclesql
                                    
    SCN（System Change Number 简称 SCN）是当Oracle数据库更新后，由DBMS自动维护去累积递增的一个数字，可以理解成ORACLE数据库的时间戳，从ORACLE 10G开始，提供了函数可以实现SCN和时间进行相互转换；  　　 
用途：在进行数据库的还原和利用数据库的闪回功能时，进行SCN和时间的转换就变的非常必要了；   　 
　操作方法：   　　1、通过dbms_f
    
                                
    • 
                                
  • Spring MVC 方法注解拦截器
                                    xp9802
spring mvc
                                    
    应用场景，在方法级别对本次调用进行鉴权，如api接口中有个用户唯一标示accessToken,对于有accessToken的每次请求可以在方法加一个拦截器，获得本次请求的用户，存放到request或者session域。 
python中，之前在python flask中可以使用装饰器来对方法进行预处理，进行权限处理 
先看一个实例,使用@access_required拦截：    
?      
    
                                
    •