精华内容
下载资源
问答
  • SpringBoot配置数据源 1.创建项目 创建好项目以后,pom文件应该是这样的: <?xml version="1.0" encoding="UTF-8"?> <project xmlns=...

    SpringBoot配置数据源

    1.创建项目

    1557144041757

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    创建好项目以后,pom文件应该是这样的:

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.1.4.RELEASE</version>
            <relativePath/> <!-- lookup parent from repository -->
        </parent>
        <groupId>com.fgr</groupId>
        <artifactId>datasource-dome</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>datasource-dome</name>
        <description>Demo project for Spring Boot</description>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-actuator</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-jdbc</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>com.h2database</groupId>
                <artifactId>h2</artifactId>
                <scope>runtime</scope>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>
    

    2.编写DatasourceDomeApplication类

    package com.fgr.datasourcedome;
    
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.CommandLineRunner;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    import javax.sql.DataSource;
    import java.sql.Connection;
    import java.sql.SQLException;
    
    @SpringBootApplication
    @Slf4j
    public class DatasourceDomeApplication implements CommandLineRunner {
    
        @Autowired
        private DataSource dataSource;
    
        public static void main(String[] args) {
            SpringApplication.run(DatasourceDomeApplication.class, args);
        }
    
    
        @Override
        public void run(String... args) throws Exception {
            showConnection();
        }
    
        private void showConnection() throws SQLException {
            log.info(dataSource.toString());
            Connection connection = dataSource.getConnection();
            log.info(connection.toString());
            connection.close();
        }
    }
    

    3.运行项目查看输出信息:

    2019-05-06 20:16:55.045  INFO 3040 --- [           main] c.f.d.DatasourceDomeApplication          : HikariDataSource (null)
    2019-05-06 20:16:55.045  INFO 3040 --- [           main] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Starting...
    2019-05-06 20:16:55.141  INFO 3040 --- [           main] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Start completed.
    2019-05-06 20:16:55.143  INFO 3040 --- [           main] c.f.d.DatasourceDomeApplication          : HikariProxyConnection@720638621 wrapping conn0: url=jdbc:h2:mem:testdb user=SA
    

    这里可以发现我们只是直接注入了DataSource,并没有做任何的配置,springboot根据我们引入的H2数据库自动为我们配置了H2相关的数据连接。

    由于我们项目中加载了actuator也可以访问http://localhost:8080/actuator/beans查看加载了哪些类:

     "dataSource": {
                        "aliases": [],
                        "scope": "singleton",
                        "type": "com.zaxxer.hikari.HikariDataSource",
                        "resource": "class path resource [org/springframework/boot/autoconfigure/jdbc/DataSourceConfiguration$Hikari.class]",
                        "dependencies": [
                            "spring.datasource-org.springframework.boot.autoconfigure.jdbc.DataSourceProperties"
                        ]
                    },
    

    手动配置数据源

    pom文件

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.fgr</groupId>
        <artifactId>pure-spring-datasource-demo</artifactId>
        <version>1.0-SNAPSHOT</version>
        <properties>
            <spring.version>5.1.3.RELEASE</spring.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>${spring.version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-dbcp2</artifactId>
                <version>RELEASE</version>
            </dependency>
            <dependency>
                <groupId>com.h2database</groupId>
                <artifactId>h2</artifactId>
                <version>RELEASE</version>
                <scope>runtime</scope>
            </dependency>
        </dependencies>
    
    </project>
    

    applicationContext.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd">
    
        <context:component-scan base-package="dome" />
        <!--
        <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource"
              destroy-method="close">
            <property name="driverClassName" value="org.h2.Driver"/>
            <property name="url" value="jdbc:h2:mem:testdb"/>
            <property name="username" value="SA"/>
            <property name="password" value=""/>
        </bean>
        -->
    </beans>
    

    DataSourceDemo.java

    package dome;
    
    import org.apache.commons.dbcp2.BasicDataSourceFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.jdbc.datasource.DataSourceTransactionManager;
    import org.springframework.transaction.PlatformTransactionManager;
    import org.springframework.transaction.annotation.EnableTransactionManagement;
    
    import javax.sql.DataSource;
    import java.sql.Connection;
    import java.sql.SQLException;
    import java.util.Arrays;
    import java.util.Properties;
    
    @Configuration
    @EnableTransactionManagement
    public class DataSourceDemo {
        @Autowired
        private DataSource dataSource;
    
        public static void main(String[] args) throws SQLException {
            ApplicationContext applicationContext =
                    new ClassPathXmlApplicationContext("applicationContext*.xml");
            showBeans(applicationContext);
            dataSourceDemo(applicationContext);
        }
    
        @Bean(destroyMethod = "close")
        public DataSource dataSource() throws Exception {
            Properties properties = new Properties();
            properties.setProperty("driverClassName", "org.h2.Driver");
            properties.setProperty("url", "jdbc:h2:mem:testdb");
            properties.setProperty("username", "sa");
            return BasicDataSourceFactory.createDataSource(properties);
        }
    
        @Bean
        public PlatformTransactionManager transactionManager() throws Exception {
            return new DataSourceTransactionManager(dataSource());
        }
    
        private static void showBeans(ApplicationContext applicationContext) {
            System.out.println(Arrays.toString(applicationContext.getBeanDefinitionNames()));
        }
    
        private static void dataSourceDemo(ApplicationContext applicationContext) throws SQLException {
            DataSourceDemo demo = applicationContext.getBean("dataSourceDemo", DataSourceDemo.class);
            demo.showDataSource();
        }
    
        public void showDataSource() throws SQLException {
            System.out.println(dataSource.toString());
            Connection conn = dataSource.getConnection();
            System.out.println(conn.toString());
            conn.close();
        }
    }
    

    运行以后输出的结果

    在这里插入图片描述

    还可以使用配置文件配置的方式注入bean:

    pom文件不变,applicationContext.xml将注释放开,DataSourceDemo.java改为:

    package dome;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.jdbc.datasource.DataSourceTransactionManager;
    import org.springframework.transaction.PlatformTransactionManager;
    import org.springframework.transaction.annotation.EnableTransactionManagement;
    
    import javax.sql.DataSource;
    import java.sql.Connection;
    import java.sql.SQLException;
    import java.util.Arrays;
    
    @Configuration
    @EnableTransactionManagement
    public class DataSourceDemo {
        @Autowired
        private DataSource dataSource;
    
        public static void main(String[] args) throws SQLException {
            ApplicationContext applicationContext =
                    new ClassPathXmlApplicationContext("applicationContext*.xml");
            showBeans(applicationContext);
            dataSourceDemo(applicationContext);
        }
    
        @Bean
        public PlatformTransactionManager transactionManager() throws Exception {
            return new DataSourceTransactionManager(dataSource);
        }
    
        private static void showBeans(ApplicationContext applicationContext) {
            System.out.println(Arrays.toString(applicationContext.getBeanDefinitionNames()));
        }
    
        private static void dataSourceDemo(ApplicationContext applicationContext) throws SQLException {
            DataSourceDemo demo = applicationContext.getBean("dataSourceDemo", DataSourceDemo.class);
            demo.showDataSource();
        }
    
        public void showDataSource() throws SQLException {
            System.out.println(dataSource.toString());
            Connection conn = dataSource.getConnection();
            System.out.println(conn.toString());
            conn.close();
        }
    }
    

    输出结果为:
    在这里插入图片描述

    展开全文
  • springboot+mybatis手动配置数据源

    万次阅读 2017-10-13 09:44:10
    1.数据源配置 application.properties #datasource spring.datasource.name = test spring.datasource.url = jdbc:mysql://192.168.0.79:3306/hyn_profile?allowMultiQueries=true&useUnicode=true&...

    1.数据源配置 application.properties

    #datasource
    spring.datasource.name = test
    spring.datasource.url = jdbc:mysql://192.168.0.79:3306/hyn_profile?allowMultiQueries=true&useUnicode=true&characterEncoding=utf-8
    spring.datasource.username = root
    spring.datasource.password = hyn12345
    spring.datasource.type = com.alibaba.druid.pool.DruidDataSource
    spring.datasource.driver-class-name = com.mysql.jdbc.Driver
    spring.datasource.filters = stat
    spring.datasource.maxActive = 20
    spring.datasource.initialSize = 1
    spring.datasource.maxWait = 60000
    spring.datasource.minIdle = 1
    spring.datasource.timeBetweenEvictionRunsMillis = 60000
    spring.datasource.minEvictableIdleTimeMillis = 300000
    spring.datasource.validationQuery = SELECT 1 FROM DUAL
    spring.datasource.testWhileIdle = true
    spring.datasource.testOnBorrow = false
    spring.datasource.testOnReturn = false
    spring.datasource.poolPreparedStatements = true
    spring.datasource.maxOpenPreparedStatements = 20

    2.druid数据库连接池配置

    @Configuration
    public class DruidConfig {
        private Logger logger = Logger.getLogger(DruidConfig.class.getName());

        @Value("${spring.datasource.url}")
        private String dbUrl;

        @Value("${spring.datasource.username}")
        private String username;

        @Value("${spring.datasource.password}")
        private String password;

        @Value("${spring.datasource.driver-class-name}")
        private String driverClassName;

        @Value("${spring.datasource.initialSize}")
        private int initialSize;

        @Value("${spring.datasource.minIdle}")
        private int minIdle;

        @Value("${spring.datasource.maxActive}")
        private int maxActive;

        @Value("${spring.datasource.maxWait}")
        private int maxWait;

        @Value("${spring.datasource.timeBetweenEvictionRunsMillis}")
        private int timeBetweenEvictionRunsMillis;

        @Value("${spring.datasource.minEvictableIdleTimeMillis}")
        private int minEvictableIdleTimeMillis;

        @Value("${spring.datasource.validationQuery}")
        private String validationQuery;

        @Value("${spring.datasource.testWhileIdle}")
        private boolean testWhileIdle;

        @Value("${spring.datasource.testOnBorrow}")
        private boolean testOnBorrow;

        @Value("${spring.datasource.testOnReturn}")
        private boolean testOnReturn;

        @Value("${spring.datasource.poolPreparedStatements}")
        private boolean poolPreparedStatements;

        @Value("${spring.datasource.filters}")
        private String filters;

        @Bean
        public ServletRegistrationBean druidServlet() {
            ServletRegistrationBean reg = new ServletRegistrationBean();
            reg.setServlet(new StatViewServlet());
            reg.addUrlMappings("/druid/*");
            reg.addInitParameter("loginUsername", "druid");
            reg.addInitParameter("loginPassword", "druid");
            return reg;
        }

        @Bean
        public FilterRegistrationBean filterRegistrationBean() {
            FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
            filterRegistrationBean.setFilter(new WebStatFilter());
            filterRegistrationBean.addUrlPatterns("/*");
            filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
            filterRegistrationBean.addInitParameter("profileEnable", "true");
            filterRegistrationBean.addInitParameter("principalCookieName", "USER_COOKIE");
            filterRegistrationBean.addInitParameter("principalSessionName", "USER_SESSION");
            return filterRegistrationBean;
        }

        @Bean
        @Primary
        public DataSource druidDataSource() {
            DruidDataSource datasource = new DruidDataSource();

            datasource.setUrl(this.dbUrl);
            datasource.setUsername(username);
            datasource.setPassword(password);
            datasource.setDriverClassName(driverClassName);
            datasource.setInitialSize(initialSize);
            datasource.setMinIdle(minIdle);
            datasource.setMaxActive(maxActive);
            datasource.setMaxWait(maxWait);
            datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
            datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
            datasource.setValidationQuery(validationQuery);
            datasource.setTestWhileIdle(testWhileIdle);
            datasource.setTestOnBorrow(testOnBorrow);
            datasource.setTestOnReturn(testOnReturn);
            datasource.setPoolPreparedStatements(poolPreparedStatements);
            try {
                datasource.setFilters(filters);
            } catch (SQLException e) {
                logger.error("druid configuration initialization filter", e);
            }
            return datasource;
        }
    }

    3.mybatis的sessionfactory和mapperscanner配置

    @Configuration
    @EnableTransactionManagement
    public class SessionFactoryConfig implements TransactionManagementConfigurer {

        /** * mybatis 配置路径 */
        private static String MYBATIS_CONFIG = "mybatis-config.xml";
        @Autowired
        private DataSource dataSource;

        private String typeAliasPackage = "com.pulan.model";

        /**
         * 创建sqlSessionFactoryBean 实例 并且设置configtion 如驼峰命名.等等 设置mapper 映射路径
         * 设置datasource数据源
         *
         * @return
         * @throws Exception
         */
        @Bean(name = "sqlSessionFactory")
        public SqlSessionFactoryBean createSqlSessionFactoryBean() throws Exception {
            SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
            /** 设置mybatis configuration 扫描路径 */
            sqlSessionFactoryBean.setConfigLocation(new ClassPathResource(MYBATIS_CONFIG));
            /** 设置datasource */
            sqlSessionFactoryBean.setDataSource(dataSource);
            /** 设置typeAlias 包扫描路径 */
            sqlSessionFactoryBean.setTypeAliasesPackage(typeAliasPackage);
            //添加XML目录
            ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
            sqlSessionFactoryBean.setMapperLocations(resolver.getResources("classpath:Mapper/*.xml"));
            return sqlSessionFactoryBean;
        }

        @Bean
        public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
            return new SqlSessionTemplate(sqlSessionFactory);
        }

        @Bean
        @Override
        public PlatformTransactionManager annotationDrivenTransactionManager() {
            return new DataSourceTransactionManager(dataSource);
        }

    }


    @Configuration
    //TODO 注意,由于MapperScannerConfigurer执行的比较早,所以必须有下面的注解
    @AutoConfigureAfter(SessionFactoryConfig.class)
    public class MyBatisMapperScannerConfig {
        @Bean
        public MapperScannerConfigurer mapperScannerConfigurer() {
            MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
            mapperScannerConfigurer.setSqlSessionFactoryBeanName("sqlSessionFactory");
            mapperScannerConfigurer.setBasePackage("com.pulan.Dao");
            return mapperScannerConfigurer;
        }
    }


    4.项目结构



    展开全文
  • springboot中 手动创建datasource

    千次阅读 2019-08-29 08:17:17
    第一段 @Value("${spring.datasource.driver-class-name}") String driverClass; @Value("${spring.datasource.url}") String url; @Value("${spring.datasource.username}") String userName;...

    第一段 

    @Value("${spring.datasource.driver-class-name}")
        String driverClass;
        @Value("${spring.datasource.url}")
        String url;
        @Value("${spring.datasource.username}")
        String userName;
        @Value("${spring.datasource.password}")
        String passWord;
    
        @Bean(name = "dataSource")
        public DataSource dataSource() {
    
            DriverManagerDataSource dataSource = new DriverManagerDataSource();
            dataSource.setDriverClassName(driverClass);
            dataSource.setUrl(url);
            dataSource.setUsername(userName);
            dataSource.setPassword(passWord);
            return dataSource;
        }

    第二段 

    @Configuration
    public class DataSourceConfig {
        
      @Bean
      public DataSource getDataSource() {
        DataSourceBuilder dataSourceBuilder = DataSourceBuilder.create();
        dataSourceBuilder.driverClassName("org.h2.Driver");
        dataSourceBuilder.url("jdbc:h2:mem:test");
        dataSourceBuilder.username("SA");
        dataSourceBuilder.password("");
        return dataSourceBuilder.build();
      }
    }

     

    展开全文
  • 由于项目要求,需要根据不同用户查询不同的sqlite数据源,所以想到通过JAVA实现手动创建MyBatis SqlSession,从而实现数据库查询; 由于此次碰到问题比较多,借鉴了很多博客,所以觉得有必要总结一下。 创建...

    背景描述

    由于项目要求,需要根据不同用户查询不同的sqlite数据源,所以想到通过JAVA实现手动创建MyBatis  SqlSession,从而实现数据库查询;

    由于此次碰到问题比较多,借鉴了很多博客,所以觉得有必要总结一下。

    创建SqlSession的两种方式

    1、SqlSessionFactoryBean创建SqlSessionFactory,可配置mapper.xml扫描路径

    创建SqlSession代码

    //导入的第三方包
    import com.alibaba.druid.pool.DruidDataSource;
    import org.apache.ibatis.mapping.Environment;
    import org.apache.ibatis.session.Configuration;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    import org.apache.ibatis.transaction.TransactionFactory;
    import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory;
    import org.mybatis.spring.SqlSessionFactoryBean;
    
    import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
    import org.springframework.core.io.support.ResourcePatternResolver;
    public SqlSession createSqlSession(ShiroUser shiroUser) {
            StringBuffer jdbcUrl = new StringBuffer(jdbcBaseUrl);
            StringBuffer dbFilePath = getDbFilePath(shiroUser);
            jdbcUrl.append(dbFilePath);
            //创建连接池
            DruidDataSource dataSource = new DruidDataSource();
            dataSource.setDriverClassName(driverClassName);
            dataSource.setUrl(jdbcUrl.toString());
            SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
            factoryBean.setDataSource(dataSource);
            ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
            SqlSessionFactory sqlSessionFactory = null;
            SqlSession session = null;
            try {
                factoryBean.setMapperLocations(resolver.getResources("classpath:sqliteMapper/*.xml"));
                factoryBean.setTypeAliasesPackage("com.kyee.pis.db.entity");
                sqlSessionFactory = factoryBean.getObject();
                session = sqlSessionFactory.openSession();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return session;
        }

    业务代码调用

    public PageList<PhysicalCar> getUploadList(ShiroUser shiroUser, PhysicalCar physicalCar, PageBounds pageBounds) {
            PageList<PhysicalCar> list = null;
            SqlSession sqlSession = null;
            try {
                sqlSession = createSqlSession(shiroUser);
                PhysicalCarMapper physicalCarMapper = sqlSession.getMapper(PhysicalCarMapper.class);
                list = physicalCarMapper.getUploadList(physicalCar,pageBounds);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if(sqlSession != null){
                    sqlSession.close(); //必须关闭
                }
            }
            return list;
        }

    2、SqlSessionFactoryBuilder创建SqlSessionFactory,须保证mapper接口与xml文件在同一包下

    创建SqlSession代码

    //导入的第三方包
    import com.alibaba.druid.pool.DruidDataSource;
    import org.apache.ibatis.mapping.Environment;
    import org.apache.ibatis.session.Configuration;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    import org.apache.ibatis.transaction.TransactionFactory;
    import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory;
    import org.mybatis.spring.SqlSessionFactoryBean;
    
    import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
    import org.springframework.core.io.support.ResourcePatternResolver;
    public SqlSession createSqlSession2(ShiroUser shiroUser) {
            StringBuffer jdbcUrl = new StringBuffer(jdbcBaseUrl);
            StringBuffer dbFilePath = getDbFilePath(shiroUser);
            jdbcUrl.append(dbFilePath);
            //创建连接池
            DruidDataSource dataSource = new DruidDataSource();
            dataSource.setDriverClassName(driverClassName);
            dataSource.setUrl(jdbcUrl.toString());
            //事务
            TransactionFactory transactionFactory = new JdbcTransactionFactory();
    
            //创建环境
            Environment environment = new Environment("development", transactionFactory, dataSource);
            //创建配置
            Configuration configuration = new Configuration(environment);
            //开启驼峰规则
            configuration.setMapUnderscoreToCamelCase(true);
            //加入资源(Mapper接口)
            configuration.addMapper(PhysicalCarMapper.class);
            //获取session工厂
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(configuration);
            SqlSession session = sqlSessionFactory.openSession();
            return session;
        }

    业务调用代码与方法一相同

    解决报错Invalid bound statement (not found)

    session创建正常情况下,获取到mapper以后调用对应的dao方法报错

    问题原因

    mapper.xml与mapper接口在同一包下时,代码编译以后xml文件并没有编译到target目录下,原因为pom默认只会编译resource文件夹下的xml文件,不编译src/main/java下的xml文件

    问题解决

    配置pom文件,使得可以编译src/main/java下的xml文件,具体代码如下

    <resources>
    	<resource>
    		<directory>src/main/java</directory>
    		<includes>
    		<include>**/*.xml</include>
    		</includes>
    	</resource>
    </resources>

     

    展开全文
  • [Shardingsphere]数据源初始化

    千次阅读 2020-01-08 15:17:34
    文章目录数据源初始化1.sharding-jdbc2...工厂类ShardingDataSourceFactory.createDataSource()方法在创建Sharding-JDBC的数据源实现类ShardingDataSource的同时还创建了ShardingRule、ShardingRuntimeContext两个核...
  • sharding-jdbc系列之 数据源配置(一)

    万次阅读 2018-07-31 12:09:21
    spring boot Yaml方式 @Bean(name="testDataSource") publicDataSourcetestDataSource()throwsIOException{ Stringyml="jdbc/testDataSource.yaml";...ResourcecertResource=newClassPa...
  • 讲一下思路,就不贴代码了,完整代码都在https://github.com/kyrotiko/switch-datasource第一步:动态切换数据源 思路: mybatis 执行大致流程 接口调用 >>> SqlSessionTemplate >>> 获取...
  • 数据库连接池HikariCP创建数据源demo

    万次阅读 2016-05-21 15:46:57
    HiKariCP的数据源配置: <!-- Hikari Datasource --> < bean id = "dataSourceHikari" class = "com.zaxxer.hikari.HikariDataSource" destroy-method = "shutdown" > <!-- ${db.driverClass}" />...
  • springboot 链接多数据库,动态获取数据源信息

    千次阅读 热门讨论 2019-04-09 18:12:32
    结果发现大部分都是配置的主从库这种数据源固定的情况,不符合我的需求,假设我们有这样一种需求,后端需要从一个数据库的配置表里动态的读取其它mysql数据库的链接配置信息,并根据链接信息动态创建数据库链接,...
  • CxGrid动态创建录入表单,不关联DataSource。 CxGrid动态创建录入表单,不关联DataSource。
  • 动态切换数据源解决办法:原来的配置文件里的数据源集合的key用的是DataSourceType,而我手动装配数据源用的是 ![图片说明](https://img-ask.csdn.net/upload/201611/29/1480429699_315678.png) 装配数据源地方的...
  • .properties资源文件,数据源的配置项直接从这里读取jdbc_driverClassName=com.mysql.jdbc.Driver jdbc_url=jdbc:mysql://xxx.xx.x.xxx:xxxx/gic?useUnicode=true&characterEncoding=utf-8 jdbc_username=gic ...
  • 数据源实际上就是学过的数据库连接池 数据源(连接池)的作用: ①提高程序性能 ②事先实例化数据源,初始化部分连接资源 ③使用连接资源时从数据源中获取 ④使用完毕后将连接资源归还给数据源 步骤: 1、在 ...
  • 以前写过一篇教程,Springboot AOP方式切换多数据源(主从两库类似情况使用最佳): https://blog.csdn.net/qq_35387940/article/details/100122788 网上大多流传的springboot系列的切换多数据源都是以上那种写死...
  • Hibernate-手动初始化数据源连接

    千次阅读 2017-02-15 12:10:45
    不使用任何文件,用代码动态创建数据源连接: 第一种方法:使用datasource和数据库方言初始化SessionFactory对象 步骤: 一、创建datasource,这里使用c3p0的ComboPooledDataSource。 二、创建SessionFactory,这里...
  • 作者:dongyx        由于我们的UDB数据源是独占型的...本文主要介绍在SuperMap iDesktop中如何创建Oracle数据型数据源以及常见问题的解决方法。目前我们iDesktop产品所支持的...
  • VC6.0 MFC 动态创建ODBC数据源

    千次阅读 2014-03-10 23:29:06
    VC6.0 MFC 动态创建ODBC数据源   点击打开转载链接时注意事项,在看懂转载文章并参考实现其代码并编译通过后虽 然建立了相应的数据源但并不会在相应的文件夹建立相应的数据,这需你下载 Micrsoft Access 2003在相应...
  • 解决事务内不能切换数据源: 可以在被调用方方法或者类上创建一个新事务: @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRES_NEW) 外部事务回滚,内部不会回滚,内部回滚,外部...
  • SpringBoot静态数据源指的是将多个数据源信息配置在配置文件中,在项目启动时加载配置文件中的多个数据源,并实例化多个数据源Bean,再通过分包/Aop达到切换数据源的目的 如果想要新增或者修改数据源,必须修改配置文件,...
  • 手动配置和自动配置ODBC数据源(C++)

    千次阅读 2019-07-14 12:10:10
    一般来说,我们在使用ODBC时,都是手动配置数据源,也就是使用电脑自带的ODBC数据源窗口进行手动配置。当我们在进行项目开发的时候,编好的代码给用户时,用户需要重新配置数据源,十分麻烦,为了方便,我们可以通过...
  • 不同数据源之间,事物管理,多个数据源之间同时commit或者同时rollback 兼容不同的连接池(dbpc,druid) 兼容mybatis,JPA 等不同的方式 (spring- boot -starter) 以上就是该项目实现的所有功能,因代码量和篇幅...
  • TransactionStatus 的时候,先手动切换数据源。事务的提交和回滚要安装创建顺序的逆顺序来提交或回滚。 原因分析:当第一次创建 TransactionStatus 的时候会调用 doGetTransaction()方法,这个方法会获取...
  • SpringBoot多数据源切换,AOP实现动态数据源切换 操作数据一般都是在DAO层进行处理,可以选择直接使用JDBC进行编程 或者是使用多个DataSource 然后创建多个SessionFactory,在使用Dao层的时候通过不同的...
  •  在Oracle Home这选项下,没有自动识别到Oracle Home目录,于是手动指定Oracle Home路径。   点击“确定”,退出PL/SQL Developer,再次登录。    还是选择不到数据库TNS,尝试无数据库登录,...
  • 本文介绍两种切换数据库的方法。 方法1:数据库信息都配置在spring xml中,适用于一般数据库切换。...方法2:将数据库信息配置在默认数据源中,适用于切换数据库操作同一方法,相当于批量执行方法。...
  • java项目配置多数据源

    千次阅读 2019-05-26 13:59:36
    有些web应用需要连接多个数据源,本文讲解一下如何使用多个数据源,大题思路是这样的,系统启动的时候创建多个数据源,然后具体执行sql的时候去切换数据源执行对应的sql。如何切换数据源呢?spring提供了一个...
  • Spring Boot2.x + Druid动态数据源切换

    千次阅读 2018-09-26 12:05:44
    数据源配置 &lt;!-- alibaba的druid数据库连接池 --&gt; &lt;dependency&gt; &lt;groupId&gt;com.alibaba&lt;/groupId&gt; &lt;artifactId&gt;druid-spring-boot...
  • springboot整合mybatis,动态数据源配置

    千次阅读 2017-09-16 22:36:52
    用springboot微服务构建,整合mybatis,查询数据库,由于数据保存在两个数据库,所以项目中通过service实现类所在包或者通过自定义注解进行动态的切换数据源。配置如下1. 引入依赖 <groupId>com.lancy</groupId> ...
  • spring + druid 配置动态配置数据源以及多数据源切换功能实现 数据源连接池使用druid 其他的数据源基本原理相同 spring中配置默认数据源连接池如下: <!-- 数据源配置, 使用 BoneCP 数据库连接池 --> &...
  • spring多数据源解决方案

    万次阅读 多人点赞 2018-07-02 18:10:46
    在平时开发过程中,很多内部的项目都是直接访问多个数据库,这样平时一个项目一个数据库就不够用了,spring支持多数据源。笔者这里记录三种平时常看到的多数据源整合方式。 第一种:复制多个bean 情景:数据库的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 197,866
精华内容 79,146
关键字:

手动创建数据源