2. 程式人生 > >Mybatis動態資料來源實現

Mybatis動態資料來源實現

阿新 • • 發佈：2019-01-24

Mybatis資料庫檔案配置是在專案啟動時初始化資料工廠的，初始化過程僅為1次，當資料庫地址改變時需修改配置檔案重新啟動專案，無法動態載入資料來源。
Mybatis連線資料庫底層核心庫SqlSessionFactory，專案初始化也是生成該類，並快取，該需求需要通過程式設計根據不同資料來源動態生成SqlSessionFactory例項。
核心程式碼：

        String driver="oracle.jdbc.driver.OracleDriver",url="jdbc:oracle:thin:@127.0.0.1:1521:orcl";
        ///mysql
        //driver = "com.mysql.jdbc.Driver"
 
;
        //url = "jdbc:mysql://"+hotel.getIp()+":"+hotel.getPort()+"/"+hotel.getDatabase();
        //初始化資料庫屬性
        Properties properties = new Properties();
        properties.setProperty("jdbc.driver",driver);  
        properties.setProperty("jdbc.url", url);  
        properties.setProperty("jdbc.username"
 
,hotel.getUsername());  
        properties.setProperty("jdbc.password",hotel.getPassword());
        Reader reader = Resources.getResourceAsReader(HotelFactory.configuration);
        //建立資料工廠
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = builder.build
 
(reader, properties);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        HotelMapper hotelMapper = sqlSession.getMapper(HotelMapper.class);
        hotelMapper.getHotelById(1);
        //釋放會話
        sqlSession.clearCache();
        sqlSession.close();

configuration.xml Mybatis配置檔案

<?xml version="1.0" encoding="UTF-8" ?>   
<!DOCTYPE configuration   
PUBLIC "-//mybatis.org//DTD Config 3.0//EN" 
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <typeAliases>
        <!--給實體類起一個別名 user 
        <typeAlias type="entity.Hotel" alias="Hotel" />
        <typeAlias type="entity.Room" alias="Room" />
        -->
    </typeAliases>
    <!--資料來源配置  使用mysql資料庫 -->
    <environments default="HD">
        <environment id="HD">
            <transactionManager type="JDBC" />
            <dataSource type="POOLED">
                <!-- 併發最大連線數 預設10-->
                <property name="poolMaximumActiveConnections" value="1000"/>
                <property name="driver" value="${jdbc.driver}" />
                <property name="url" value="${jdbc.url}" />
                <property name="username" value="${jdbc.username}" />
                <property name="password" value="${jdbc.password}" />
            </dataSource>
        </environment>

<!--        <environment id="HO">  
            <transactionManager type="JDBC" />  
            <dataSource type="POOLED">  
                <property name="driver" value="oracle.jdbc.driver.OracleDriver" />  
                <property name="url" value="jdbc:oracle:thin:@192.168.1.17:1521:orcl" />  
                <property name="username" value="hotel" />  
                <property name="password" value="q123" />  
            </dataSource>  
        </environment>   -->
    </environments>
    <mappers>
        <!-- userMapper.xml裝載進來  同等於把“dao”的實現裝載進來 -->
        <mapper resource="mapper/HotelMapper.xml"/>
        <mapper resource="mapper/RestaurantMapper.xml"/>
        <mapper resource="mapper/RoomsMapper.xml"/>
        <mapper resource="mapper/MeetingsMapper.xml"/>
    </mappers>
</configuration>

HotelMapper

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="mapper.HotelMapper">
    <select id="getHotelById" resultType="entity.Hotel">
        select * from HOTEL
        where ID = #{id,jdbcType=DECIMAL}
    </select>
</mapper>

    public interface HotelMapper {
        Hotel getHotelById(@Param("id") int id);
    }


SqlSessionFactory只是記載的資料庫的連線屬性，並未與資料庫連線，並不佔用資料庫及系統資源。

SQLSession便於資料庫建立連線了，每次讀取資料後若不釋放，資料庫的連線數不斷增加，當超過資料庫的最大連線數或者記憶體溢位均會導致程式崩潰。

每次連線都需要初始化，過於麻煩，可封裝套資料工廠，快取相關資訊。

設計思路1：快取SqlSessionFactory，通過java動態代理釋放資料庫資源即SqlSession。（適用多點，SqlSession數量不可控情況）
設計思路2：快取SqlSessionFactory及SqlSession，SqlSession會預設快取已呼叫的方法，通過sqlSession.clearCache()清空預設快取，保證讀取的是實時資料庫。（適用單點或少數站點機，SqlSession數量可控情況）

設計思路1核心程式碼：
資料工廠DataSourceFactory程式碼：

package factory;

import java.io.Reader;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketAddress;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import entity.Hotel;

@SuppressWarnings("finally")
public class DataSourceFactory {

    //酒店資料工作快取數量
    private static final int MaxDataSourceSize=10;
    //埠超時時間
    private static final int TimeOut = 2000;

    //酒店資料工廠快取
    private static Map<Integer,SqlSessionFactory> dataSoruce;

    static{
        dataSoruce = new HashMap<Integer, SqlSessionFactory>(MaxDataSourceSize);
    }

    //刪除第一個元素
    private static void removeFirstMap(){
        for (Integer key : dataSoruce.keySet()) {  
            dataSoruce.remove(key);
            break;
        }  
    }

    //刪除酒店快取
    public static void removeHotel(int hotelid){
        dataSoruce.remove(hotelid);
    }

    //檢測連線是否可用

    public static boolean isConnection(Hotel hotel){
        Boolean result = false;
        try{
            //檢查埠是否開放
            Socket client = new Socket();
            SocketAddress socketAddress = new InetSocketAddress(hotel.getIp(),Integer.parseInt(hotel.getPort()));
            client.connect(socketAddress,TimeOut);
            client.close();

            result = true;
        }
        catch(Exception e){
            e.printStackTrace();
            result = false;
        }
        finally{
            return result;
        }
    }

    public static boolean isConnection(Integer id){
        Boolean result = false;
        try{
            Hotel hotel = HotelFactory.getHotelById(id);
            if(hotel != null){
                //檢查埠是否開放
                Socket client = new Socket();
                SocketAddress socketAddress = new InetSocketAddress(hotel.getIp(),Integer.parseInt(hotel.getPort()));
                client.connect(socketAddress,TimeOut);
                client.close();
                result = true;
            }
        }
        catch(Exception e){
            e.printStackTrace();
            result = false;
        }
        finally{
            return result;
        }
    }

    private static SqlSessionFactory createSqlSessionFactory(Integer id){
        SqlSessionFactory _sqlSessionFactory = null;
        try{
            Hotel hotel = HotelFactory.getHotelById(id);
            if(hotel != null && isConnection(hotel)){
                //資料庫匹配           Oracle/Mysql
                String driver="oracle.jdbc.driver.OracleDriver",url="jdbc:oracle:thin:@"+hotel.getIp()+":"+hotel.getPort()+":"+hotel.getSid();
                ///mysql
                //driver = "com.mysql.jdbc.Driver";
                //url = "jdbc:mysql://"+hotel.getIp()+":"+hotel.getPort()+"/"+hotel.getDatabase();
                //初始化資料庫屬性
                Properties properties = new Properties();
                properties.setProperty("jdbc.driver",driver);  
                properties.setProperty("jdbc.url", url);  
                properties.setProperty("jdbc.username",hotel.getUsername());  
                properties.setProperty("jdbc.password",hotel.getPassword());
                Reader reader = Resources.getResourceAsReader(HotelFactory.configuration);
                //建立資料工廠
                SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
                _sqlSessionFactory = builder.build(reader, properties);
            }
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally{
            return _sqlSessionFactory;
        }
    }

    //根據酒店id獲取Mapper
    @SuppressWarnings("unchecked")
    public static <T> T getMapper(Integer id,Class<?> clazz){
        if(isConnection(id)){
            SqlSessionFactory sqlSessionFactory = dataSoruce.get(id);
            if(sqlSessionFactory==null){
                //建立資料工廠
                sqlSessionFactory = createSqlSessionFactory(id);
                if(sqlSessionFactory != null){
                    //排序演算法 刪除Map序列第一個元素，並將當前元素移至Map序列的首位
                    if(dataSoruce.size()>=MaxDataSourceSize){
                        removeFirstMap();
                    }
                    dataSoruce.put(id, sqlSessionFactory);
                }
                else
                    return null;
            }
            /*else{
                //排序演算法 將當前元素移至Map序列的首位
                dataSoruce.remove(id);
                dataSoruce.put(id, sqlSessionFactory);
            }*/
            SqlSession sqlSession = sqlSessionFactory.openSession();
            Object idal = sqlSession.getMapper(clazz);
            return (T)IDALProxy.bind(idal, sqlSession);
        }
        else
            return null;
    }

    //動態載入  SqlSession提交，釋放
    public static class IDALProxy implements InvocationHandler {
        private Object idal;
        private SqlSession sqlSession;

        private IDALProxy(Object idal, SqlSession sqlSession) {
            this.idal = idal;
            this.sqlSession = sqlSession;
        }

        public static Object bind(Object idal, SqlSession sqlSession) {
            return Proxy.newProxyInstance(idal.getClass().getClassLoader(),idal.getClass().getInterfaces(), new IDALProxy(idal, sqlSession));
        }

        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Object object = null;
            try {
                object = method.invoke(idal, args);
            } catch(Exception e) {
                sqlSession.rollback();
                e.printStackTrace();

            } finally {
                sqlSession.commit();
                sqlSession.clearCache();
                sqlSession.close();
            }
            return object;
        }
    }

}

酒店工廠HotelFactory程式碼：

package factory;

import java.io.InputStream;
import java.io.Reader;
import java.util.Properties;

import mapper.HotelMapper;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import entity.Hotel;

public class HotelFactory {

    public static SqlSessionFactory sqlSessionFactory = null;
    //資料庫屬性值
    public static final String jdbc_properties="jdbc.properties";
    //資料庫配置檔案
    public final static String configuration = "configuration.xml";

    //建立本地酒店管理資料庫
    static{
        try {
            Properties properties = new Properties();
            InputStream in = Resources.getResourceAsStream(jdbc_properties);
            properties.load(in);
            String driver = properties.getProperty("jdbc.driverClassName");
            String url = properties.getProperty("jdbc.url");
            String username = properties.getProperty("jdbc.username");
            String password = properties.getProperty("jdbc.password");
            properties.setProperty("jdbc.driver",driver);  
            properties.setProperty("jdbc.url", url);  
            properties.setProperty("jdbc.username",username);  
            properties.setProperty("jdbc.password",password);
            Reader reader = Resources.getResourceAsReader(configuration);
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            sqlSessionFactory = builder.build(reader, properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //根據id獲取酒店實體
    @SuppressWarnings("finally")
    public static Hotel getHotelById(Integer id){
        Hotel hotel = null;
        SqlSession sqlSession = null;
        try{
            sqlSession = sqlSessionFactory.openSession();
            hotel = sqlSession.getMapper(HotelMapper.class).getHotelById(id);
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally{
            if(sqlSession != null)
                sqlSession.close();
            return hotel;
        }
    }
}

引用例項：

RoomsMapper roomMapper = getMapper(hotelid);
roomMapper.getRoom();

Hotel實體中存了資料庫的IP地址，埠號等基本資訊，根據hotel生成對應庫的Mapper例項進行資料操作。
通過IDALProxy類對生成Mapper例項的所有方法進行了再次封裝，實現資料庫資源的提交，快取清空和釋放。

相關推薦

Mybatis動態資料來源實現

Mybatis資料庫檔案配置是在專案啟動時初始化資料工廠的，初始化過程僅為1次，當資料庫地址改變時需修改配置檔案重新啟動專案，無法動態載入資料來源。 Mybatis連線資料庫底層核心庫SqlSessionFactory，專案初始化也是生成該類，並快取，該需求需

Spring Boot：實現MyBatis動態資料來源

綜合概述 在很多具體應用場景中，我們需要用到動態資料來源的情況，比如多租戶的場景，系統登入時需要根據使用者資訊切換到使用者對應的資料庫。又比如業務A要訪問A資料庫，業務B要訪問B資料庫等，都可以使用動態資料來源方案進行解決。接下來，我們就來講解如何實現動態資料來源，以及在過程中剖析動態資料來源背後的實現原理

Spring Boot MyBatis 動態資料來源切換、多資料來源，讀寫分離

轉載自:https://blog.csdn.net/u013360850/article/details/78861442本專案使用 Spring Boot 和 MyBatis 實現多資料來源，動態資料來源的切換；有多種不同的實現方式，在學習的過程中發現沒有文章將這些方式和常

SaaS 系統架構，Spring Boot 動態資料來源實現！

這段時候在準備從零開始做一套`SaaS`系統，之前的經驗都是開發單資料庫系統並沒有接觸過SaaS系統，所以接到這個任務的時候也有也些頭疼，不過辦法部比困難多，難得的機會。 在網上找了很多關於`SaaS`的資料，看完後使我受益匪淺，寫文章之前也一直在關注`SaaS`系統的開發，通過幾天的探索也有一些方向。

MyBatis 配置多資料來源實現多個數據庫動態切換

1.配置properties路徑 我的配置檔案   2.配置mybatis資料來源 配置 第二套資料來源 3 動態資料來源的配置 兩個key分別引入了 兩套資料來源，預設使用jsdx_telecom 4.配置SqlSessionFa

Spring Boot + Mybatis 實現動態資料來源

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

Spring+Mybatis多資料來源配置（四）——AbstractRoutingDataSource實現資料來源動態切換

有時候需要在程式中動態切換資料來源，那麼這個系列的之前的博文所闡述的方法就不再使用了，總不能通過程式更改config.properties檔案的dataSource的值，然後再重啟web伺服器以便載入applicationContext.xml檔案。這裡講訴的是如何利用Ab

SpringBoot+Mybatis 實現動態資料來源切換方案

背景 最近讓我做一個大資料的系統，分析了一下，麻煩的地方就是多資料來源切換抽取資料。考慮到可以跨伺服器跨資料庫抽數，再整理資料，就配置了這個動態資料來源的解決方案。在此分享給大家。 實現方案 資料庫配置檔案 我們專案使用的是yml形式的配置檔案，採用的是hikari的資料庫連線池。第一步我們自然是配置多個數據

spring+mybatis+tkmapper+atomikos實現分布式事務(3)-動態切換數據源

springmvc mybatis tkmapper atomiks 動態數據源 本文介紹基於spring+mybatis+tkmapper+atomikos+jta實現分布式事務，由程序動態切換數據源，通過atomikos可實現分布式事務一致性。通過繼承MapperScannerConf

Mybatis動態代理介面實現資料庫操作

  mybatis動態代理實現資料庫的增改刪查功能和pojo包裝類對映   工程結構搭建 在工程src包下建立兩個空包，cn.mybatis.xhchen.entity和cn.mybatis.xhchen.mapper 工程中建立建立檔案集conf

解析配置檔案自動裝配 DataSource + AbstractRoutingDataSource + AOP 實現動態資料來源 上：原理解析，解析資料來源

spring boot 自動裝配會通過 spring.datasource.*為我們自動裝配資料來源，所以想要動態的切換資料來源，第一件事是配置資料來源，其次是怎麼切換？最後何時切換？ 原理解析（使用 AbstractRoutingDataSource 實現） spring-jd

解析配置檔案自動裝配 DataSource + AbstractRoutingDataSource + AOP 實現動態資料來源 下：配置動態資料來源，AOP 進行使用

上篇文章中已經藉助 DynamicDataSourceBuilder 類從配置檔案中解析得到了預設資料來源和動態資料來源，接下來需要配置動態資料來源的“本體”，並藉助 AOP 動態的切換資料來源。 配置動態資料來源 AbstractRoutingDataSource 實現了 In

springboot+mybatis多資料來源配置，AOP註解動態切換資料來源

轉載至：https://blog.csdn.net/xiaosheng_papa/article/details/80218006 親測有效。 注：有些系統中已經配置了單資料來源，現在要轉成多資料來源，可能需要額外的配置。拿我自己當前專案來說： 專案在啟動類中配置了單資料來源：

Mybatis（攔截器實現）通用mapper及全ORM實現（五）-- springboot+mybatis多資料來源設定

本篇實際上和mybatisext專案並沒有太大關係了，但在實際專案中脫離不開多個數據源，尤其是主從分離，同樣網上一些資料大同小異而且大部分並不能真正解決問題，所以單獨提出來說一下 假設我們就是要解決一個主從分離，資料來源定義在了application.properties中

springboot+mybatis多資料來源配置實現

簡單實現了根據註解動態切換資料來源，支援同一個資料庫的宣告式事務，但不支援JTA事務。處理流程： 根據配置的資料來源資訊，建立動態資料來源bean 利用DataSourceAspect處理@DataSource註解，設定當前要使用的具體資料來源 pom.xm

由淺入深分析mybatis通過動態代理實現攔截器（外掛）的原理 ！很值得一看

最近在用mybatis做專案，需要用到mybatis的攔截器功能，就順便把mybatis的攔截器原始碼大致的看了一遍，為了溫故而知新，在此就按照自己的理解由淺入深的理解一下它的設計。  和大家分享一下，不足和謬誤之處歡迎交流。直接入正題。  首先，先不管mybatis的原始碼

Spring Boot + Mybatis 多資料來源配置實現讀寫分離

本文來自網易雲社群作者：王超應用場景：專案中有一些報表統計與查詢功能，對資料實時性要求不高，因此考慮對報表的統計與查詢去操作slave db，減少對master的壓力。根據網上多份資料測試發現總是使用master資料來源，無法切換到slave，經過多次除錯修改現已完美通過，現

spring boot整合mybatis通用mapper實現Druid多資料來源

      在以前的專案中用springMVC加原生的mybatis框架使用過多資料來源的配置，是用xml配置的。在這次的新專案裡面使用到了tk的通用mapper,剛好專案結束，利用空閒時間寫了個全註解的多資料來源配置小demo

jqGrid 單元格編輯 自定義下拉選擇框 動態資料來源 通用實現

jqGrid編輯型別可分為：單元格編輯(Cell editing)、行內編輯(Inline editing)和表單編輯(Form editing)，本文討論單元格編輯模式下，下拉選擇框的通用實現。jqGrid自帶下拉選擇框編輯型別，只要設定edittype='select’並設定editop

JDBC/InvocationHandler動態代理實現資料庫連線池、資料來源

Java的JDBC程式設計中，資料庫的連線和關閉是十分耗費資源的。當對資料庫的訪問不是很頻繁時，可以在每次訪問資料庫時建立一個連線，用完之後關閉。但是，對於一個複雜的資料庫應用，頻繁的建立、關閉連線，會極大的減低系統性能，造成瓶頸。所以可以使用資料庫連線池來達到