Spring环境下MyBatis支持多个Datasource参考实现

页面导航:首页 > 软件编程 > Java编程 > Spring环境下MyBatis支持多个Datasource参考实现

Spring环境下MyBatis支持多个Datasource参考实现

来源: 作者: 时间:2016-01-18 15:52 【

需求背景最近接到一个项目,需要改造一个老的系统。该老系统以Oracle为存储,巨量的PL SQL代码实现业务代码,C实现Socket Server,作为Client和PL SQL的桥梁。不出所料,该老系统最大的问题

需求背景

最近接到一个项目,需要改造一个老的系统。该老系统以Oracle为存储,巨量的PL/SQL代码实现业务代码,C实现Socket Server,作为Client和PL/SQL的桥梁。不出所料,该老系统最大的问题是PL/SQL代码量巨大(上万的Procedure好几个),且毫无组织可言,实在改不动了,其次是性能有问题。改动的方向是,把PL/SQL从Oracle中踢出,用Java改写相关业务逻辑,放到Web Server中,不过Oracle中的Schema不动。

到目前位置,改造老系统和笔者要分享的主题没啥关系。问题来了,老系统有三套,A,B,C,就是说有三个Oracle,Schema以及PL/SQL完全相同,但是数据没有啥关系,完全独立的三个数据库。历史的问题,不好评说,但是只是为了解决性能问题,搞了三套,客户被分配到不同的套系统,和传统的游戏开个服务器一个思路。

我们有3个方案:
1. 部署三套WebServer,对应三个数据库,客户端连接到不同的Web Server,和原来架构相同。数据库和Server都继续分。
2. 把三个数据库整合为一个数据库,部署一套Web Server。数据和,Server和。
3. 保持三套Oracle数据库不变,一个Web Server,但是Server需要把三个Oracle都管理起来。

方案1最简单,最容易,但是当性能已经不再是问题的时候还是部署三套Web Server,实在是有些说不过去,运维工作增加,客户端维护不同的版本(服务器地址),不太愿意选择,暂时备选。

方案2很难,非常的难。原来的三个Oracle数据库,完全独立,没有全局的主键,基本上无法区分开数据。放弃!

方案3是个折中的方案,中国人讲究中庸之道。最终我们选择了方案3。

设计思路

方案3要解决的问题是同一个Server如何集成3个数据库,具体来说,就是Spring里面如何管理3个Shema完全相同的Datasouce。我们的Server的技术选型是常见的Spring+MyBatis。管理多个Shema不同的Datasouce,网上有很多例子,Schema相同这叫分库吗,貌似很少?那进一步在Spring环境下呢?没有找到。强调Spring只想知道一个Mapper,而非3个。是因为,Spring只想知道一个Mapper,而非3个。

其中的关键技术难点如下:

如何识别什么样的数据应该存到哪一个Oracle数据库?
我们的解法是根据用户所在的位置来判断,用户在A库,那么后续的操作针对A库,在B库就操作B库。最开始登录的时候先探测用户到底存在于哪一个库。我们认为用户名+密码应该是跨三个数据库唯一的。如何动态切换数据库?
代理,用代理来实现。Spring容器内注册的就是一个代理而已,代理被调用的时候,我们截获调用,根据登录时候获得的环境(哪一个库),来动态切换,委托给背后的MyBatis Mapper来执行。

下图是我画的切换的示意图。偷懒的原因,我只画了A,B两套,实战中是A,B,C。

使用代理实现动态切换

实例代码

识别应该存于哪一个数据库

稍微改造一下Shiro访问用户信息的地方,增加环境的属性。注意两点,一是遍历数据源,探测用户所在的数据库,而是直接用SqlSessionFactory的bean name作为环境名,够简单直白!

Shiro Realm代码如下:

public class ShiroRealm extends AuthorizingRealm {
    @Autowired
    private UserService userService;
    @Autowired
    private SecureService secureService;
    @Autowired
    private AuthorizationService authorizationService;

    @PostConstruct
    public void initAlgorithms() {
        AllowAllCredentialsMatcher credentialsMatcher = new AllowAllCredentialsMatcher();
        setCredentialsMatcher(credentialsMatcher);
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        UsernamePasswordToken pairToken = (UsernamePasswordToken) token;
        String userName = pairToken.getUsername();
        String password = new String(pairToken.getPassword());

        // determine env
        Map envMappers = EnvMapperFactoryBean.getAllMappers(UserMapper.class);
        for (String env : envMappers.keySet()) {
            User user = validUser((UserMapper) envMappers.get(env), userName, password);
            if (user != null) {
                ShiroUser shiroUser = new ShiroUser(user.getId(), userName, user.getBranchId(), env);

                String salt = user.getSalt();
                byte[] saltBytes = Hex.decode(salt);

                return new SimpleAuthenticationInfo(shiroUser, user.getPassword(), ByteSource.Util.bytes(saltBytes),
                        getName());
            }
        }

        return null;
    }

    private User validUser(UserMapper userMapper, String userName, String password) {
        UserExample example = new UserExample();
        example.createCriteria().andNameEqualTo(userName);

        List users = userMapper.selectByExample(example);
        if (users.isEmpty()) {
            return null;
        }

        User user = users.get(0);
        String salt = user.getSalt();
        String tempEncoded = secureService.hash(password, salt);
        if (user.getPassword().equals(tempEncoded)) {
            return user;
        } else {
            return null;
        }
    }

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        ShiroUser shiroUser = (ShiroUser) principals.getPrimaryPrincipal();
        User user = userService.queryUserByName(shiroUser.getName());

        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();

        List roles = authorizationService.queryRoleByUserId(user.getId());
        if (roles.size() > 0) {
            List roleNames = ObjectProcessor.getFieldList(roles,
                    new ObjectProcessor.FieldValueGetter() {
                        @Override
                        public String getValue(Role role) {
                            return role.getName();
                        }
                    });
            info.addRoles(roleNames);

            List roleIds = ObjectProcessor.getFieldList(roles,
                    new ObjectProcessor.FieldValueGetter() {
                        @Override
                        public Integer getValue(Role role) {
                            return role.getId();
                        }
                    });
            List privileges = authorizationService.queryPrivilegeByRoleId(roleIds);
            if (privileges.size() > 0) {
                List privilegeKeys = ObjectProcessor.getFieldList(privileges,
                        new ObjectProcessor.FieldValueGetter() {
                            @Override
                            public String getValue(Privilege item) {
                                return item.getCategory() + ":" + item.getCode();
                            }
                        });
                info.addStringPermissions(privilegeKeys);
            }
        }

        return info;
    }

    public static class ShiroUser implements Serializable, Principal {
        private static final long serialVersionUID = 3316911162161110480L;

        private Integer id;
        private String name;
        private Integer branchId;
        private String env;

        public ShiroUser(Integer id, String name, Integer branchId, String env) {
            this.id = id;
            this.name = name;
            this.branchId = branchId;
            this.env = env;
        }

        public Integer getId() {
            return id;
        }

        public String getName() {
            return name;
        }

        public Integer getBranchId() {
            return branchId;
        }

        public String getEnv() {
            return env;
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            if (obj == null) {
                return false;
            }
            if (getClass() != obj.getClass()) {
                return false;
            }
            ShiroUser other = (ShiroUser) obj;
            if (name == null) {
                if (other.name != null) {
                    return false;
                }
            } else if (!name.equals(other.name)) {
                return false;
            }
            return true;
        }

        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + ((name == null) ? 0 : name.hashCode());
            return result;
        }

        @Override
        public String toString() {
            return name;
        }
    }

}

Spring Mapper Proxy注册以及动态切换数据源

我们用了Shiro,可以在任意地方获取用户信息,背后的本质是一个ThreadLocal变量。注意Proxy的背后会有很多帮工—-真正的Mybatis Mapper,启动的时候需要安装上。

代码如下:
public class EnvMapperFactoryBean implements FactoryBean, ApplicationContextAware {
private static final Logger log = LoggerFactory.getLogger(EnvMapperFactoryBean.class);

    private Class mapperInterface;
    private ApplicationContext context;

    private static Map> envMappers = new ConcurrentHashMap<>();

    /**
     * Sets the mapper interface of the MyBatis mapper
     *
     * @param mapperInterface
     *            class of the interface
     */
    public void setMapperInterface(Class mapperInterface) {
        this.mapperInterface = mapperInterface;
    }

    /**
     * [email protected]}
     */
    @SuppressWarnings("unchecked")
    public T getObject() throws Exception {
        installEnv();

        return (T) Proxy.newProxyInstance(EnvMapperFactoryBean.class.getClassLoader(),
                new Class[] { mapperInterface }, new MapperProxy());
    }

    public Class getObjectType() {
        return this.mapperInterface;
    }

    public boolean isSingleton() {
        return true;
    }

    private static Object getRealMapper(String env, Class mapperClazz) {
        Map mappers = envMappers.get(env);
        if (mappers.isEmpty()) {
            return null;
        }

        return mappers.get(mapperClazz.getName());
    }

    public static Map getAllMappers(Class mapperClazz) {
        Map result = new HashMap<>();
        String clazzName = mapperClazz.getName();

        for (String env : envMappers.keySet()) {
            Map mappers = envMappers.get(env);
            if (mappers.containsKey(clazzName)) {
                result.put(env, mappers.get(clazzName));
            }
        }

        return result;
    }

    @SuppressWarnings("resource")
    private void installEnv() {
        String[] sqlSessionFactoryNames = context.getBeanNamesForType(SqlSessionFactory.class);
        if (sqlSessionFactoryNames == null || sqlSessionFactoryNames.length == 0) {
            throw new RuntimeException("找不到SqlSessionFactory的配置信息");
        }

        for (String env : sqlSessionFactoryNames) {
            SqlSessionFactory sqlSessionFactory = context.getBean(env, SqlSessionFactory.class);
            SqlSession sqlSession = new SqlSessionTemplate(sqlSessionFactory);
            T mapper = sqlSession.getMapper(mapperInterface);

            if (!envMappers.containsKey(env)) {
                envMappers.put(env, new ConcurrentHashMap<>());
            }

            envMappers.get(env).put(mapperInterface.getName(), mapper);
        }
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        context = applicationContext;
    }

    private class MapperProxy implements InvocationHandler {
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Object object = null;
            try {
                ShiroUser shiroUser = (ShiroUser) SecurityUtils.getSubject().getPrincipal();
                if (shiroUser == null) {
                    throw new RuntimeException("用户没有登陆,无法确认环境");
                }

                String env = shiroUser.getEnv();

                Object mapper = getRealMapper(env, method.getDeclaringClass());
                if (mapper == null) {
                    throw new RuntimeException("找不到对应的mapper");
                }
                object = method.invoke(mapper, args);
            } catch (Exception e) {
                log.error(e.getMessage(), e);
                throw e;
            }
            return object;
        }
    }
}

Spring的配置文件

Spring会配置多个Datasource,多个SqlSessionFactory,一个Scanner。


    
    
    
    
    

    
    
    
    
    



    
    
    



    
    
    
    
    

    
    
    
    
    



    
    
    



    

结语

这是一个通过代理器来实现运行时动态切换实现的经典案例,代理是一个非常有用的设计模式,值得思考和借鉴。

有人会问,有其它的一些解法吗?

关于识别,用户名+密码唯一识别有人可能觉得不妥,可以自己替换为自己想要的识别算法,甚至于丢给客户端自己决定。

关于动态切换,Spring的AbstractRoutingDataSource是个很好的选择,不过不适合我们的场景,我们需要先拿到三个Mybatis的UserMapper来探测具体用哪一个数据库,Datasource太底层了。如果环境由客户端来决定,AbstractRoutingDataSource确实是更好的选择。

 
Tags:

文章评论

最 近 更 新
热 点 排 行
Js与CSS工具
代码转换工具

<