精华内容
下载资源
问答
  • AOP开发时事务控制一定要同一个数据源 否则事务不生效 /** * 采用ThreadLocal封装Connection * @author yanyan * */ public class ConnectionManager { //声明一个Connection类型的ThreadLocal private ...

    AOP开发时事务控制一定要为同一个数据源 否则事务不生效

    /**
     * 采用ThreadLocal封装Connection
     * @author yanyan
     *
     */
    public class ConnectionManager {
        //声明一个Connection类型的ThreadLocal
        private static ThreadLocal<Connection> connectionHolder=new ThreadLocal<Connection>();
    
        public static Connection getConnection(){
        //通过TheadLocal的get方法来获取当前线程连接对象的实例
            Connection conn=connectionHolder.get();
            if(conn==null){
                try{
                //获取数据库驱动
                Class.forName("com.mysql.jdbc.Driver");
     conn = DriverManager.getConnection( "jdbc:mysql://localhost:3306/test", "username","password");  
     
    
                //设置数据库连接对象
                    connectionHolder.set(conn);
                }catch (Exception e) {
                    throw new ApplicationException("系统错误,请联系管理员!");
                }
            }
    
            return conn;
        }
    
        //关闭数据库连接
        public static void closeConnection(){
            Connection conn=connectionHolder.get();
    
            if(conn!=null){
                try{
                    conn.close();
                    //从集合中清除
                    connectionHolder.remove();
                }catch(SQLException e){
                    e.printStackTrace();
                }
            }
        }
    
        /**
         * 手动提交事务
         * @param conn
         */
        public static void beginTransaction(Connection conn){
            try{
                if(conn !=null){
                    if(conn.getAutoCommit()){
                        conn.setAutoCommit(false);
                    }
                }
            }catch(SQLException e){}
        }
    
        /**
         * 
         * 提交事务
         * @param conn
         */
        public static void commitTransaction(Connection conn){
            try{
                if(conn !=null){
                    if(!conn.getAutoCommit()){
                        conn.commit();
                    }
                }
            }catch(SQLException e){}
        }
    
        /**
         * 回滚事务
         * @param conn
         */
        public static void rollbackTransaction(Connection conn){
            try{
                if(conn!=null){
                    if(!conn.getAutoCommit()){
                        conn.rollback();
                    }
                }
            }catch(SQLException e){}
        }
    
        /**
         * 重置connection状态
         * @param conn
         */
        public static void resetConnection(Connection conn){
            try{
                if(conn!=null){
                    if(conn.getAutoCommit()){
                        conn.setAutoCommit(false);
                    }else{
                        conn.setAutoCommit(true);
                    }
                }
            }catch(SQLException e){}
        }
    
    
        //关闭preparedStatement
        public static void close(Statement pstmt){
            if(pstmt !=null){
                try {
                    pstmt.close();
                } catch (SQLException e) {
    
                    e.printStackTrace();
                }
            }
        }
        //关闭ResultSet
        public static void close(ResultSet rs){
            if(rs !=null){
                try {
                    rs.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
    
    展开全文
  • 思路: 使用AbstractRoutingDataSource数据源(路由数据源),数据源切换存在。 AbstractRoutingDataSource 会管理一个map {路由键: 数据源}。调用determineCurrentLookupKey方法。根据路由键切换数据源。 创建...

    源码

    参考文献

    思路: 使用AbstractRoutingDataSource数据源(路由数据源),为多数据源切换存在。

    AbstractRoutingDataSource 会管理一个map {路由键: 数据源}。调用determineCurrentLookupKey方法。根据路由键切换数据源。

    1. 创建一个静态Map来保存 所有的数据源key为租户id val为数据源
        /**
         * 租户id, 数据源
         */
        public static final Map<Object, Object> dataSourceMap = new ConcurrentHashMap<>();
    
    1. 创建一个静态map 存放当前登录用户信息
    
        /**
         * token, user 用户信息中包含租户id
         */
        public static final Map<String, User> userMap = new ConcurrentHashMap<>();
    
    1. 重写AbstractRoutingDataSource
    package com.dynamic.data.source.config;
    
    import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
    
    import javax.sql.DataSource;
    import java.util.Map;
    
    /**
     * 开发公司:联信
     * 版权:联信
     * <p>
     * Annotation
     *
     * @author 刘志强
     * @created Create Time: 2021/2/2
     */
    public class DynamicDataSource  extends AbstractRoutingDataSource {
        /**
         * 确定目标数据源
         * 如果不希望数据源在启动配置时就加载好,可以定制这个方法,从任何你希望的地方读取并返回数据源
         * 比如从数据库、文件、外部接口等读取数据源信息,并最终返回一个DataSource实现类对象即可
         */
        @Override
        protected DataSource determineTargetDataSource() {
            return super.determineTargetDataSource();
        }
        /**
         * 确定当前路由键,会根据路由键查找对应的数据源
         * 这里通过设置数据源Key值来切换数据,定制这个方法
         */
        @Override
        protected Object determineCurrentLookupKey() {
            // 从线程副本中获取当前数据源路由键
            return DynamicDataSourceContextHolder.getDataSourceKey();
        }
        /**
         * 设置默认数据源
         * @param defaultDataSource
         */
        public void setDefaultDataSource(Object defaultDataSource) {
            super.setDefaultTargetDataSource(defaultDataSource);
        }
        /**
         * 设置数据源
         * @param dataSources
         */
        public void setDataSources(Map<Object, Object> dataSources) {
            super.setTargetDataSources(dataSources);
            // 将数据源的 key 放到数据源上下文的 key 集合中,用于切换时判断数据源是否有效
            DynamicDataSourceContextHolder.addDataSourceKeys(dataSources.keySet());
        }
    }
    
    
    
    1. 创建一个ThreadLocal contextHolder 存放当前线程路由
    
    package com.dynamic.data.source.config;
    
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.List;
    
    /**
     * 开发公司:联信
     * 版权:联信
     * <p>
     * Annotation
     *
     * @author 刘志强
     * @created Create Time: 2021/2/2
     */
    public class DynamicDataSourceContextHolder {
        private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>() {
            /**
             * 将 master 数据源的 key作为默认数据源的 key
             */
            @Override
            protected String initialValue() {
                return "default";
            }
        };
        /**
         * 数据源的 key集合,用于切换时判断数据源是否存在
         */
        public static List<Object> dataSourceKeys = new ArrayList<>();
        /**
         * 切换数据源
         * @param key
         */
        public static void setDataSourceKey(String key) {
            contextHolder.set(key);
        }
        /**
         * 获取数据源
         * @return
         */
        public static String getDataSourceKey() {
            return contextHolder.get();
        }
        /**
         * 重置数据源
         */
        public static void clearDataSourceKey() {
            contextHolder.remove();
        }
        /**
         * 判断是否包含数据源
         * @param key 数据源key
         * @return
         */
        public static boolean containDataSourceKey(String key) {
            return dataSourceKeys.contains(key);
        }
        /**
         * 添加数据源keys
         * @param keys
         * @return
         */
        public static boolean addDataSourceKeys(Collection<? extends Object> keys) {
            return dataSourceKeys.addAll(keys);
        }
    
    }
    
    
    1. 初始化默认数据源
    package com.dynamic.data.source.config;
    
    import com.alibaba.druid.pool.DruidDataSource;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.mybatis.spring.SqlSessionFactoryBean;
    import org.mybatis.spring.SqlSessionTemplate;
    import org.mybatis.spring.boot.autoconfigure.MybatisProperties;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.boot.jdbc.DataSourceBuilder;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.Primary;
    import org.springframework.core.env.Environment;
    import org.springframework.core.io.ResourceLoader;
    import org.springframework.jdbc.datasource.DataSourceTransactionManager;
    
    import javax.sql.DataSource;
    import java.sql.SQLException;
    import java.util.Properties;
    
    /**
     * 开发公司:联信
     * 版权:联信
     * <p>
     * Annotation
     *
     * @author 刘志强
     * @created Create Time: 2021/2/2
     */
    @Configuration
    public class MybatisConfig {
    
        @Autowired
        private Environment env;
    
        @Value("${spring.datasource.url}")
        private String url;
        @Value("${spring.datasource.username}")
        private String username;
        @Value("${spring.datasource.password}")
        private String password;
    
        @Bean(name = "defaultDataSource")
        @Primary
        public DataSource defaultDataSource(@Qualifier("poolProperties") Properties poolProperties) throws SQLException {
            DruidDataSource dataSource = DataSourceBuilder.create()
                    // 数据库 连接池类型 如果不设置类型默认类型为 com.zaxxer.hikari.HikariDataSource
                    .type(DruidDataSource.class)
                    // 驱动
                    .driverClassName("com.mysql.cj.jdbc.Driver")
                    // 链接
                    .url(url)
                    // 账号
                    .username(username)
                    // 密码
                    .password(password)
                    .build();
            // 加载连接池配置信息
            dataSource.configFromPropety(poolProperties);
            // 初始化
            dataSource.init();
            // 初始化
            DataSourceAdmin.dataSourceMap.put("default",dataSource);
            return dataSource;
        }
    
        /**
         * 创建数据源路由
         *
         * @return
         */
        @Bean("dynamicDataSource")
        public DataSource dynamicDataSource() throws SQLException {
            DynamicDataSource dynamicDataSource = new DynamicDataSource();
            dynamicDataSource.setDefaultDataSource(defaultDataSource(poolProperties()));
            dynamicDataSource.setDefaultTargetDataSource(defaultDataSource(poolProperties()));
            dynamicDataSource.setDataSources(DataSourceAdmin.dataSourceMap);
            return dynamicDataSource;
        }
    
    
        @Bean(name = "sqlSessionFactory")
        @Primary
        public SqlSessionFactory sqlSessionFactory(
                @Qualifier("dynamicDataSource") DataSource dynamicDataSource,
                @Qualifier("mybatisData") MybatisProperties properties,
                ResourceLoader resourceLoader) throws Exception {
            SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
            bean.setDataSource(dynamicDataSource);
            bean.setTypeAliasesPackage(properties.getTypeAliasesPackage());
            bean.setConfigLocation(resourceLoader.getResource(properties.getConfigLocation()));
            bean.setMapperLocations(properties.resolveMapperLocations());
            return bean.getObject();
        }
    
        @Bean(name = "sqlSessionTemplate")
        public SqlSessionTemplate sqlSessionTemplate(
                @Qualifier("sqlSessionFactory") SqlSessionFactory sqlSessionFactory
        ) {
            return new SqlSessionTemplate(sqlSessionFactory);
        }
    
        @Bean(name = "mybatisData")
        @ConfigurationProperties(prefix = "mybatis")
        @Primary
        public MybatisProperties mybatisProperties() {
            MybatisProperties mybatisProperties = new MybatisProperties();
            return mybatisProperties;
        }
    
        @Bean(name = "dataSourceTransactionManager")
        public DataSourceTransactionManager dataSourceTransactionManager(@Qualifier("dynamicDataSource") DataSource dynamicDataSource) {
            return new DataSourceTransactionManager(dynamicDataSource);
        }
    
        @Bean("poolProperties")
        public Properties poolProperties() {
            String prefixPool = "spring.datasource.pool.";
            Properties prop = new Properties();
            prop.put("druid.initialSize", env.getProperty(prefixPool + "initialSize", String.class));
            prop.put("druid.maxActive", env.getProperty(prefixPool + "maxActive", String.class));
            prop.put("druid.minIdle", env.getProperty(prefixPool + "minIdle", String.class));
            prop.put("druid.maxWait", env.getProperty(prefixPool + "maxWait", String.class));
            prop.put("druid.poolPreparedStatements", env.getProperty(prefixPool + "poolPreparedStatements", String.class));
            prop.put("druid.maxPoolPreparedStatementPerConnectionSize", env.getProperty(prefixPool + "maxPoolPreparedStatementPerConnectionSize", String.class));
            prop.put("druid.validationQuery", env.getProperty(prefixPool + "validationQuery", String.class));
            prop.put("druid.validationQueryTimeout", env.getProperty(prefixPool + "validationQueryTimeout", String.class));
            prop.put("druid.testOnBorrow", env.getProperty(prefixPool + "testOnBorrow", String.class));
            prop.put("druid.testOnReturn", env.getProperty(prefixPool + "testOnReturn", String.class));
            prop.put("druid.testWhileIdle", env.getProperty(prefixPool + "testWhileIdle", String.class));
            prop.put("druid.timeBetweenEvictionRunsMillis", env.getProperty(prefixPool + "timeBetweenEvictionRunsMillis", String.class));
            prop.put("druid.minEvictableIdleTimeMillis", env.getProperty(prefixPool + "minEvictableIdleTimeMillis", String.class));
            prop.put("druid.filters", env.getProperty(prefixPool + "filters", String.class));
            return prop;
        }
    }
    
    
    1. 项目初始化 加载租户数据源
    package com.dynamic.data.source.service.impl;
    
    import com.alibaba.druid.pool.DruidDataSource;
    import com.dynamic.data.source.config.DataSourceAdmin;
    import com.dynamic.data.source.config.DataSourceInfo;
    import com.dynamic.data.source.config.DynamicDataSource;
    import com.dynamic.data.source.domain.User;
    import com.dynamic.data.source.mapper.UserMapper;
    import com.dynamic.data.source.service.InitService;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.boot.jdbc.DataSourceBuilder;
    import org.springframework.stereotype.Service;
    
    import javax.sql.DataSource;
    import java.sql.SQLException;
    import java.util.List;
    import java.util.Properties;
    
    /**
     * 开发公司:联信
     * 版权:联信
     * <p>
     * Annotation
     *
     * @author 刘志强
     * @created Create Time: 2021/1/26
     */
    @Service
    @Slf4j
    public class InitServiceImpl implements InitService {
    
        @Autowired
        private UserMapper userMapper;
        @Autowired
        @Qualifier("poolProperties")
        private Properties poolProperties;
        @Autowired
        @Qualifier("dynamicDataSource")
        private DataSource dynamicDataSource;
    
        @Override
        public void initDataSource() {
            List<User> list = userMapper.getUserAll();
            list.forEach(user -> {
                DataSourceInfo dataSourceInfo = new DataSourceInfo();
                dataSourceInfo.setUserId(user.getId());
    
                StringBuilder url = new StringBuilder();
                url.append("jdbc:mysql://").append(user.getDatabaseIp())
                        .append(":3306/")
                        .append(user.getDatabaseName())
                        .append("?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=round&useAffectedRows=true&useSSL=false");
                // 创建数据源
                DruidDataSource dataSource = DataSourceBuilder.create()
                        // 数据库 连接池类型 如果不设置类型默认类型为 com.zaxxer.hikari.HikariDataSource
                        .type(DruidDataSource.class)
                        // 驱动
                        .driverClassName("com.mysql.cj.jdbc.Driver")
                        // 链接
                        .url(url.toString())
                        // 账号
                        .username(user.getDatabaseAccount())
                        // 密码
                        .password(user.getDatabasePassword())
                        .build();
    
                // 加载连接池配置信息
                dataSource.configFromPropety(poolProperties);
                try {
                    log.info("租户数据源初始化{}",user.getUserName());
                    dataSource.init();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
                DataSourceAdmin.dataSourceMap.put(String.valueOf(user.getId()),dataSource);
            });
            // 初始化数据源
            DynamicDataSource dataSource = (DynamicDataSource) dynamicDataSource;
            dataSource.setDataSources(DataSourceAdmin.dataSourceMap);
            dataSource.afterPropertiesSet();
        }
    }
    
    
    1. aop 拦截根据登录信息切换数据源
    package com.dynamic.data.source.config.aop;
    
    import com.dynamic.data.source.config.DataSourceAdmin;
    import com.dynamic.data.source.config.DynamicDataSourceContextHolder;
    import com.dynamic.data.source.domain.User;
    import lombok.extern.slf4j.Slf4j;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.core.annotation.Order;
    import org.springframework.stereotype.Component;
    import org.springframework.util.StringUtils;
    
    import javax.servlet.http.HttpServletRequest;
    
    /**
     * 开发公司:联信
     * 版权:联信
     * <p>
     * Annotation
     *
     * @author 刘志强
     * @created Create Time: 2021/2/2
     */
    @Aspect
    @Component
    @Slf4j
    @Order(-1)
    public class DynamicDataSourceAspect {
        @Autowired
        private HttpServletRequest httpServletRequest;
    
        /**
         * 定义切点Pointcut
         */
        @Pointcut("execution(* com.dynamic.data.source.controller.*.*(..))")
        public void excudeService() {
        }
    
        /**
         * 环绕通知
         * @param pjp
         * @return
         * @throws Throwable
         */
        @Around("excudeService()")
        public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
            log.info("----环绕通知----");
    
            String token = httpServletRequest.getHeader("Authorization");
            if (!StringUtils.isEmpty(token)) {
                User user = DataSourceAdmin.userMap.get(token);
                log.info("当前租户Id:{}", user.toString());
                DynamicDataSourceContextHolder.setDataSourceKey(String.valueOf(user.getId()));
                Object result = pjp.proceed();
                DynamicDataSourceContextHolder.clearDataSourceKey();
                return result;
            } else {
                DynamicDataSourceContextHolder.setDataSourceKey("default");
                Object result = pjp.proceed();
                DynamicDataSourceContextHolder.clearDataSourceKey();
                return result;
            }
        }
    
    }
    
    
    1. 登录 保存token和user绑定信息
    @Override
        public String login(String userName, String password) {
            User user = userMapper.getUserByUserNameAndPassword(userName,password);
            if (user != null) {
                String token = UUID.randomUUID().toString();
                DataSourceAdmin.userMap.put(token,user);
                return token;
            } else {
                return "无此用户";
            }
        }
    
    展开全文
  • 在springBoot 项目中,配置mysql数据源配置,做到可以对数据的操作。 1:application.properties中,添加多个mysql连接: 2:创建DataSourceConfig文件。 @Configuration public class DataSourceConfig...

    在springBoot 项目中,配置mysql数据源配置,做到可以对数据的操作。

    1:application.properties中,添加多个mysql连接:

    2:创建DataSourceConfig文件。

    @Configuration
    public class DataSourceConfig {
        private static Log log = LogFactory.getLog(DataSourceConfig.class);
    
        @Bean(name = "marketDataSource")
        @ConfigurationProperties("spring.datasource.market")
        @Primary//@Primary告诉程序,多数据源哪一个是第一个
        public DataSource marketDataSource(){
            return DataSourceBuilder.create().build();
        }
    
        @Bean(name = "userDataSource")
        @ConfigurationProperties("spring.datasource.user")
        public DataSource userDataSource(){
            return DataSourceBuilder.create().build();
        }
    
    }

    其中需要注意,多数据源的时候,需要给程序指出哪一个是master,所以需要用@primary注解

    3:创建对应的数据源配置,创建MarketDataSource

    @Configuration
    @MapperScan(value = "com.demoBoot.mapper.market_mapper",sqlSessionTemplateRef = "marketSqlSessionTemplate")
    public class MarketDataSource {
        //自动注入数据源
        @Autowired
        @Qualifier("marketDataSource")//表明哪一个才是我想要的数据源
        private DataSource mareketDataSource;
        /**
         * 创建SqlSessionFactory工厂
         */
        @Bean(name = "marketSqlSessionFactory")
        @Primary
        public SqlSessionFactory marketSqlSessionFactory(@Qualifier("marketDataSource") DataSource mareketDataSource) throws Exception{
            SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
            bean.setDataSource(mareketDataSource);
            bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/market_mapper/*.xml"));
            return bean.getObject();
        }
        /**
         * 创建事物
         */
        @Bean(name = "marketTransctionManager")
        @Primary
        public DataSourceTransactionManager marketTransctionManager(@Qualifier("marketDataSource") DataSource mareketDataSource){
            return new DataSourceTransactionManager(mareketDataSource);
        }
        @Bean(name = "test1SqlSessionTemplate")
        @Primary
        public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("marketSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
            return new SqlSessionTemplate(sqlSessionFactory);
        }
    }

    4:创建另外一个数据源文件,内容和上面一致,这里不在重复。

    至此,简单的多数据源就配置成功,需要的maven依赖为:

    <dependency>
       <groupId>org.apahe</groupId>
       <artifactId>mybatis</artifactId>
       <version>3.3.0</version>
    </dependency>
    <dependency>
       <groupId>org.mybatis.spring</groupId>
       <artifactId>mybatis.spring</artifactId>
       <version>1.2.3</version>
    </dependency>
    <dependency>
       <groupId>com.mysql</groupId>
       <artifactId>mysql-connector-java</artifactId>
       <version>5.1.37</version>
    </dependency>
    <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-jdbc</artifactId>
       <version>5.0.9.RELEASE</version>
    </dependency>

     

    展开全文
  • 1、定义枚举 /// <summary> /// 枚举方法 /// </summary> public static enum RadioMailState { All=0, Men = 1, Women = 2 } 2、需要封装后的共同类 ...

    1、定义枚举

     /// <summary>    

     /// 枚举方法    

     /// </summary>    

     public static enum RadioMailState    

    {        
          All=0,         Men = 1,         Women = 2    

    }

    2、需要封装后的共同类

     /// <summary>    

     /// 共同类    

     /// </summary>    

     public class Common    

     {        

          /// <summary>        

          /// 获取性别的封装值        

          /// </summary>        

          /// <param name="mStrFlag">是否包含全部默认值</param>        

          /// <returns></returns>        

         public static Dictionary<RadioMailState, string> getRadioMailState(bool mStrFlag)        

         {            

                Dictionary<RadioMailState, string> dStrRadioMailState = new Dictionary<RadioMailState, string>();            

               if (mStrFlag)            

               {                

                     dStrRadioMailState.Add(RadioMailState.All, "全部");            

               }            

              dStrRadioMailState.Add(RadioMailState.Men, "男");            

              dStrRadioMailState.Add(RadioMailState.Women, "女");            

              return dStrRadioMailState;        

          }    

    }

    3、给调用的下拉控件封装值

        /// <summary>    

        /// 封装对应的按钮    

        /// </summary>    

        public class RadioControler    

       {        

           /// <summary>        

           /// 封装性别的下拉框        

           /// </summary>        

           /// <param name="listControl">下拉控件</param>        

           /// <param name="ifCheckAll">是否添加全部默认值</param>        

           public void LoadRadioMexValue(DropDownList listControl,bool ifCheckAll)        

           {            

                       Dictionary<RadioMailState, string> dStrMexStateValue = Common.getRadioMailState(ifCheckAll);        //声明取值变量                     

                       foreach (KeyValuePair<RadioMailState,string> radiovalue in dStrMexStateValue)                                 //循环取值,并赋值给下拉框            

                       {               

                                  listControl.Items.Add(new ListItem(radiovalue.Value.ToString(), radiovalue.Key.ToString()));            

                       }

                       if(listControl.Items.Count>0)                                                                                                           //如果选项不为空,那么让第一个默认选中            

                      {                

                           listControl.Items[0].Selected=true;            

                      }        

           }    

    }

     

    转载于:https://www.cnblogs.com/BeyondWJsel/archive/2012/02/08/2342761.html

    展开全文
  • 准备工作:导入c3p0和dbutils的jar包 写c3p0的配置文件,-- c3p0-config.xml --放在src下 写c3p0工具类 ... private static ComboPooledDataSource dataSource= new ComboPooledDataSourc...
  • 除了这种方法以外,数据库中间件也是个不错的选择,它的优点是数据库集群对应用来说只暴露单库,不需要切换数据源的代码逻辑。定义数据源线程内容器,用户定义当前线程用的数据源public class ...
  •   给你一个:驱动程序 A,数据源名称 B,用户名称 C,密码 D,数据库表 T,请用 JDBC 检索出表 T 的所有数据。 package mango; import java.sql.*; public class jdbc{ public static String DRIVER = "A";...
  • private static void gv_CustomDrawEmptyForeground(object sender, DevExpress.XtraGrid.Views.Base.CustomDrawEventArgs e) { DevExpress.XtraGrid.Views.Grid.GridView gv = sender as DevExpr...
  • spring动态指定数据源

    2012-12-07 12:12:00
    目前很多项目中只能配置单个数据源,那么如果有多个数据源肿么办?Spring提供了一个抽象类AbstractRoutingDataSource,我们很方便的解决了这个问题。1.写一个DynamicDataSource类继承AbstractRout...
  • static

    2019-12-05 09:28:44
    static定义变量时,无论是全局还是局部,都将其存放在静态数据区。若静态变量未被初始化,则自动初始化为0,但只可初始化一次。 当static修饰全局变量时,静态全局变量生存期整个程序。但其的可见性仅在它所定义...
  • grails3—配置多数据源

    2018-08-19 10:44:36
    如果grails项目中,不同的...在application.yml文件中,增加dataSources属性配置,里面包含每个具体的数据源配置。如下:   如果需要实现不同的domain类连接操作不同的库,在domain类中static mapping下还需要...
  • springboot 要配置一个mysql数据库一个sqlserver数据库 下面是我的配置 ``` spring: datasource: ... jdbc-url: jdbc:mysql://******************... 什么还会报多数据源问题? 麻烦哪位大佬帮帮看一下问题 谢谢
  • 1:在JBoss中配置一个名“FirstDS”的数据源。 2:在JBoss中部署一个Web项目,在项目中通过JNDI查找FirstDS数据源,可以查找到数据源并 能成功访问数据库。 3:但是在Java Project中却无法查找FirstDS数据源。 ...
  • 在用DataGridView控件是,数据源的表头,总不知怎样把E文转换中文,试了多种方法,最后还是觉得下面这种通用。public static DataSet ColumnsNameEngToChi(DataSet ds, string[] DataTableName) { string ...
  • 我的问题是, 能否定义多个数据源, 通过配置或简单编码hibernate实现将所有的insert, update, delete等改变数据的操作都在master database中完成, 所有select操作分配在slave databases中完成。 [b]问题补充:[/b]...
  • public static class ConvertExtensions { #region 数据类型转换扩展方法 /// <summary> /// object 转换成string 包括空的情况 /// </summary> /// <param name="obj"></param> /...
  • public static class ConvertExtensions { #region 数据类型转换扩展方法 /// <summary> /// object 转换成string 包括空的情况 /// </summary> /// <param name=...
  • public static void main(String[] args) throws ClassNotFoundException, SQLException { //加载相应数据库的驱动类 Class.forName("A"); //获得与数据库的连接 Connection conn=DriverManager.getCon...
  • public static String getDBType(){ String retStr=""; ApplicationContext ctx = ApplicationContextUtil.getContext(); if (ctx==null) { return retStr;//如果ctx空,则服务器异常了 }...
  • 阿里云的OSS作为存储方案,...假设某网站的域名www.a.com,那么我们来看看如何部署网站的OSS图片存储方案。 首先,CDN访问OSS资源。 在OSS中新增一个自定义域名static.a.com,搭配CDN作为请求OSS资源的访问域名...
  • 接上篇,什么此种模式下,在spring托管CMT管理的JTA事务中,无法切换数据源,忙活了好久,对着日志流程和源代码,貌似问题出现在下面的代码中:   org.mybatis.spring .SqlSessionUtils public static ...
  • 一、单例模式 该类负责创建自己的对象,同时确保只有单个对象被创建。... //让构造函数 private,这样该类就不会被实例化 private Singleton(){} //获取唯一可用的对象 public static Singl
  • 来源:http://lihengwei453848.blog.163.com/blog/static/36866173200922262811669/<br />  连接池概念:   首先...连接池的出现,开发过程提供了一个很好的管理平台。当程序中需要建立数据库连接
  • static总结

    2018-09-08 15:45:39
    【1】最重要的一条:当同时编译多个文件时,...如果作为static局部变量在函数内定义,它的生存期整个程序,但是其作用域仍与自动变量相同,只能在定义该变量的函数内使用该变量。退出该函数后, 尽管该变量还...
  • 今天在做把传统的ComBox绑定的数据源是List<实体对象>,有很多的页面都是这么处理的,而且实体类不同.心想不能每个页面都吧,后来就想着用泛型与反射机制处理:才写出了这个通用的方法如下:这可以偶花了好几...
  • C++中static

    2020-05-04 15:12:36
    局部变量分配内存空间在栈上,静态局部变量分配内存空间在静态数据存储区上。局部变量生命期是持续到函数运行始末,而静态局部变量的生命期持续整个程序 使用static将全局变量变为静态全局变量: 把全局变量改变...
  • 最近写了一个多数据源的代码,结果在使用的过程中出现了在一个请求中(方法中)两个数据库交替使用的情况,最后情况是数据库切换不过来 并且在项目配置中有懒加载和OpenSessionInViewFilter 数据库一个本地数据库...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 489
精华内容 195
关键字:

数据源为static