精华内容
下载资源
问答
  • 分布式管理

    千次阅读 2019-01-09 18:02:12
    分布式事物管理以及解决方案 1、什么是分布式事务 分布式事务就是指事务的参与者、支持事务的服务器、资源服务器以及事务管理器分别位于不同的分布式系统的不同节点之上。以上是百度百科的解释,简单的说,就是一...

    分布式事物管理以及解决方案

    1、什么是分布式事务

    分布式事务就是指事务的参与者、支持事务的服务器、资源服务器以及事务管理器分别位于不同的分布式系统的不同节点之上。以上是百度百科的解释,简单的说,就是一次大的操作由不同的小操作组成,这些小的操作分布在不同的服务器上,且属于不同的应用,分布式事务需要保证这些小操作要么全部成功,要么全部失败。本质上来说,分布式事务就是为了保证不同数据库的数据一致性。

    2、分布式事务的产生的原因

    2.1、数据库分库分表

    当数据库单表一年产生的数据超过1000W,那么就要考虑分库分表,具体分库分表的原理在此不做解释,以后有空详细说,简单的说就是原来的一个数据库变成了多个数据库。这时候,如果一个操作既访问01库,又访问02库,而且要保证数据的一致性,那么就要用到分布式事务。

    2.2、应用SOA化

    所谓的SOA化,就是业务的服务化。比如原来单机支撑了整个电商网站,现在对整个网站进行拆解,分离出了订单中心、用户中心、库存中心。对于订单中心,有专门的数据库存储订单信息,用户中心也有专门的数据库存储用户信息,库存中心也会有专门的数据库存储库存信息。这时候如果要同时对订单和库存进行操作,那么就会涉及到订单数据库和库存数据库,为了保证数据一致性,就需要用到分布式事务。

    以上两种情况表象不同,但是本质相同,都是因为要操作的数据库变多了!

    3、事务的ACID特性

    3.1、原子性(A)

    所谓的原子性就是说,在整个事务中的所有操作,要么全部完成,要么全部不做,没有中间状态。对于事务在执行中发生错误,所有的操作都会被回滚,整个事务就像从没被执行过一样。

    3.2、一致性(C)

    事务的执行必须保证系统的一致性,就拿转账为例,A有500元,B有300元,如果在一个事务里A成功转给B50元,那么不管并发多少,不管发生什么,只要事务执行成功了,那么最后A账户一定是450元,B账户一定是350元。

    3.3、隔离性(I)

    所谓的隔离性就是说,事务与事务之间不会互相影响,一个事务的中间状态不会被其他事务感知。

    3.4、持久性(D)

    所谓的持久性,就是说一单事务完成了,那么事务对数据所做的变更就完全保存在了数据库中,即使发生停电,系统宕机也是如此。

    4、分布式事务的应用场景

    4.1、支付

    最经典的场景就是支付了,一笔支付,是对买家账户进行扣款,同时对卖家账户进行加钱,这些操作必须在一个事务里执行,要么全部成功,要么全部失败。而对于买家账户属于买家中心,对应的是买家数据库,而卖家账户属于卖家中心,对应的是卖家数据库,对不同数据库的操作必然需要引入分布式事务。

    4.2、在线下单

    买家在电商平台下单,往往会涉及到两个动作,一个是扣库存,第二个是更新订单状态,库存和订单一般属于不同的数据库,需要使用分布式事务保证数据一致性。

    5、常见的分布式事务解决方案

    5.1、基于XA协议的两阶段提交

    XA是一个分布式事务协议,由Tuxedo提出。XA中大致分为两部分:事务管理器和本地资源管理器。其中本地资源管理器往往由数据库实现,比如Oracle、DB2这些商业数据库都实现了XA接口,而事务管理器作为全局的调度者,负责各个本地资源的提交和回滚。XA实现分布式事务的原理如下:

    总的来说,XA协议比较简单,而且一旦商业数据库实现了XA协议,使用分布式事务的成本也比较低。但是,XA也有致命的缺点,那就是性能不理想,特别是在交易下单链路,往往并发量很高,XA无法满足高并发场景。XA目前在商业数据库支持的比较理想,在mysql数据库中支持的不太理想,mysql的XA实现,没有记录prepare阶段日志,主备切换回导致主库与备库数据不一致。许多nosql也没有支持XA,这让XA的应用场景变得非常狭隘。

    5.2、消息事务+最终一致性

    所谓的消息事务就是基于消息中间件的两阶段提交,本质上是对消息中间件的一种特殊利用,它是将本地事务和发消息放在了一个分布式事务里,保证要么本地操作成功成功并且对外发消息成功,要么两者都失败,开源的RocketMQ就支持这一特性,具体原理如下:

    1、A系统向消息中间件发送一条预备消息
    2、消息中间件保存预备消息并返回成功
    3、A执行本地事务
    4、A发送提交消息给消息中间件

    通过以上4步完成了一个消息事务。对于以上的4个步骤,每个步骤都可能产生错误,下面一一分析:

    • 步骤一出错,则整个事务失败,不会执行A的本地操作
    • 步骤二出错,则整个事务失败,不会执行A的本地操作
    • 步骤三出错,这时候需要回滚预备消息,怎么回滚?答案是A系统实现一个消息中间件的回调接口,消息中间件会去不断执行回调接口,检查A事务执行是否执行成功,如果失败则回滚预备消息
    • 步骤四出错,这时候A的本地事务是成功的,那么消息中间件要回滚A吗?答案是不需要,其实通过回调接口,消息中间件能够检查到A执行成功了,这时候其实不需要A发提交消息了,消息中间件可以自己对消息进行提交,从而完成整个消息事务

    基于消息中间件的两阶段提交往往用在高并发场景下,将一个分布式事务拆成一个消息事务(A系统的本地操作+发消息)+B系统的本地操作,其中B系统的操作由消息驱动,只要消息事务成功,那么A操作一定成功,消息也一定发出来了,这时候B会收到消息去执行本地操作,如果本地操作失败,消息会重投,直到B操作成功,这样就变相地实现了A与B的分布式事务。原理如下:

    虽然上面的方案能够完成A和B的操作,但是A和B并不是严格一致的,而是最终一致的,我们在这里牺牲了一致性,换来了性能的大幅度提升。当然,这种玩法也是有风险的,如果B一直执行不成功,那么一致性会被破坏,具体要不要玩,还是得看业务能够承担多少风险。

    5.3、TCC编程模式

    所谓的TCC编程模式,也是两阶段提交的一个变种。TCC提供了一个编程框架,将整个业务逻辑分为三块:Try、Confirm和Cancel三个操作。以在线下单为例,Try阶段会去扣库存,Confirm阶段则是去更新订单状态,如果更新订单失败,则进入Cancel阶段,会去恢复库存。总之,TCC就是通过代码人为实现了两阶段提交,不同的业务场景所写的代码都不一样,复杂度也不一样,因此,这种模式并不能很好地被复用。

    6、总结

    分布式事务,本质上是对多个数据库的事务进行统一控制,按照控制力度可以分为:不控制、部分控制和完全控制。不控制就是不引入分布式事务,部分控制就是各种变种的两阶段提交,包括上面提到的消息事务+最终一致性、TCC模式,而完全控制就是完全实现两阶段提交。部分控制的好处是并发量和性能很好,缺点是数据一致性减弱了,完全控制则是牺牲了性能,保障了一致性,具体用哪种方式,最终还是取决于业务场景。作为技术人员,一定不能忘了技术是为业务服务的,不要为了技术而技术,针对不同业务进行技术选型也是一种很重要的能力!

    转自:https://www.cnblogs.com/wchxj/p/7899712.html

    展开全文
  • 分布式管理环境

    2014-02-18 16:23:06
    分布式管理环境  随着分布式多厂商计算环境的出现创造一种有利于分布式多厂商计算环境有效管理的标准框架便成为一件座予以最优先考虑的事。因此,一些主要厂商通过 开放软件基金会(OSF)制定了一套称为分布式...
    分布式管理环境


      随着分布式多厂商计算环境的出现创造一种有利于分布式多厂商计算环境有效管理的标准框架便成为一件座予以最优先考虑的事。因此,一些主要厂商通过 开放软件基金会(OSF)制定了一套称为分布式管理环境(DME)的、独立于厂商的开放标准。


      DME被认为能最有效地利用当今先进的分布式计算技术、开放标准、互操作性和面向对象的技术DME的标准化框架代表了工业界对于开放管理的应用程序接口(APL)和协议的一致意见DME是一种随技术发展而演进的“活”标准,能把最新的工业发展增加进去。


      1.DME何以能发挥作用


      DME以现有标准为基础。它并不替代其他标准,而是一种既包含现有的SNMP(简单网络管理协议)和CMIP(公共管理信息协议) 标准有支持由网络管理论坛、 X/Open及其他组织开发的补充手段。


      DME是在众多厂商达成一致意见的基础上产生的。因此,DME也反映了你的计算环境,并能驾驭多厂商系统和网络方面的发展。又因为DME是工业异一致意见的产物,所以它会加速你组织内达成一致意见。


      DME是以各方面的要求为基础的这些要求是为达到特定目标并满足实际需求,在工业界以开放的方式逐渐形成的。
    展开全文
  • 本篇文章主要介绍了如何使用Spring+redis实现对session的分布式管理,本文主要是在Spring中实现分布式session,采用redis对session进行持久化管理,感兴趣的小伙伴们可以参考一下
  • 分布式管理环境  随着分布式多厂商计算环境的出现创造一种有利于分布式多厂商计算环境有效管理的标准框架便成为一件座予以最优先考虑的事。因此,一些主要厂商通过 开放软件基金会(OSF)制定了一套称为分布式...
    分布式管理环境


      随着分布式多厂商计算环境的出现创造一种有利于分布式多厂商计算环境有效管理的标准框架便成为一件座予以最优先考虑的事。因此,一些主要厂商通过 开放软件基金会(OSF)制定了一套称为分布式管理环境(DME)的、独立于厂商的开放标准。


      DME被认为能最有效地利用当今先进的分布式计算技术、开放标准、互操作性和面向对象的技术DME的标准化框架代表了工业界对于开放管理的应用程序接口(APL)和协议的一致意见DME是一种随技术发展而演进的“活”标准,能把最新的工业发展增加进去。


      1.DME何以能发挥作用


      DME以现有标准为基础。它并不替代其他标准,而是一种既包含现有的SNMP(简单网络管理协议)和CMIP(公共管理信息协议) 标准有支持由网络管理论坛、 X/Open及其他组织开发的补充手段。


      DME是在众多厂商达成一致意见的基础上产生的。因此,DME也反映了你的计算环境,并能驾驭多厂商系统和网络方面的发展。又因为DME是工业异一致意见的产物,所以它会加速你组织内达成一致意见。


      DME是以各方面的要求为基础的这些要求是为达到特定目标并满足实际需求,在工业界以开放的方式逐渐形成的。
    展开全文
  • 使用Spring+redis实现session的分布式管理

    在Spring中实现分布式 session管理

    本文主要是在Spring中实现分布式session,采用redis对session进行持久化管理,这样当应用部署的时候,不需要在Resin、Tomcat等容器里面进行分布式配置,方便加入新的节点服务器进行集群扩容,session不依赖各节点的服务器,可直接从redis获取。下面是功能的核心代码:

    一、首先在web.xml里面配置

    加入拦截器:

    <!-- 分布式session start -->
        <filter>
            <filter-name>distributedSessionFilter</filter-name>
            <filter-class>DistributedSessionFilter</filter-class>
            <init-param>
                <!-- 必填,密钥.2种方式,1对应为bean,格式为bean:key。2字符串,格式如:afffrfgv-->
                <param-name>key</param-name>
                <param-value>xxxxxxxx</param-value>
            </init-param>
            <init-param>
                <!-- 必填,redis对应的bean,格式为bean:xx-->
                <param-name>cacheBean</param-name>
                <param-value>bean:redisPersistent</param-value>//DistributedBaseInterFace,对应于此接口,进行session的持久化操作
            </init-param>
            <init-param>
                <!-- 必填, -->
                <param-name>cookieName</param-name>
                <param-value>TESTSESSIONID</param-value>
            </init-param>
        </filter>
        <filter-mapping>
            <filter-name>distributedSessionFilter</filter-name>
            <url-pattern>*.do</url-pattern>
        </filter-mapping>
        <!-- 分布式session end -->

    二、拦截器的实现,核心代码如下

    主要有以下的几个类:
    DistributedSessionFilter,
    DistributedSessionManager,
    DistributedHttpSessionWrapper,
    DistributedHttpServletRequestWrapper

    1、DistributedSessionFilter实现Filter:

    import java.io.IOException;
    import java.util.HashMap;
    import java.util.Map;
    
    import javax.servlet.Filter;
    import javax.servlet.FilterChain;
    import javax.servlet.FilterConfig;
    import javax.servlet.ServletException;
    import javax.servlet.ServletRequest;
    import javax.servlet.ServletResponse;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import org.springframework.web.context.WebApplicationContext;
    import org.springframework.web.context.support.WebApplicationContextUtils;
    
    public class DistributedSessionFilter implements Filter {
        private static final Logger log = LoggerFactory.getLogger(DistributedSessionFilter.class);
    
        private String cookieName;
    
        //主要是对session进行管理的操作
        private DistributedSessionManager distributedSessionManager;
    
        private String key;
    }
    

    容器启动时候的初始化方法:

    @Override
        public void init(FilterConfig config) throws ServletException {
            WebApplicationContext wac = WebApplicationContextUtils.getRequiredWebApplicationContext(config
                    .getServletContext());
            String key = config.getInitParameter("key");
            String cookieName = config.getInitParameter("cookieName");
            String cacheBean = config.getInitParameter("cacheBean");
            // 获取bean的名称,配置是"bean:"
            String redisBeanStr = cacheBean.substring(5);
            DistributedBaseInterFace distributedCache = (DistributedBaseInterFace) wac.getBean(redisBeanStr);
    
            // 获取key,有2种配置方式,1对应为bean,格式为bean:key。2字符串
            if (key.startsWith("bean:")) {
                this.key = (String) wac.getBean(key.substring(5));
            } else {
                this.key = key;
            }
            this.cookieName = cookieName;
            this.distributedSessionManager = DistributedSessionManager.getInstance(distributedCache);
    
            //异常处理省略。。。
        }
    
    

    进行实际的请求拦截:

        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
                throws ServletException, IOException {
            DistributedHttpServletRequestWrapper distReq = null;
            try {
                //请求处理
                distReq = createDistributedRequest(servletRequest, servletResponse);
                filterChain.doFilter(distReq, servletResponse);
            } catch (Throwable e) {
                //省略。。。
            } finally {
                if (distReq != null) {
                    try {
                        //处理完成request后,处理session(主要是保存session会话)
                        dealSessionAfterRequest(distReq.getSession());
                    } catch (Throwable e2) {
                        //省略。。。
                    }
                }
            }
        }
    
        //分布式请求
        private DistributedHttpServletRequestWrapper createDistributedRequest(ServletRequest servletRequest,
                ServletResponse servletResponse) throws IOException, ServletException {
            HttpServletRequest request = (HttpServletRequest) servletRequest;
            HttpServletResponse response = (HttpServletResponse) servletResponse;
            String userSid = CookieUtil.getCookie(cookieName, request);
            String actualSid = distributedSessionManager.getActualSid(userSid, request, key);
            if (StringUtil.isBlank(actualSid)) {
                if (StringUtil.isNotBlank(userSid)) {
                    log.info("userSid[{}]验证不通过", userSid);
                }
                // 写cookie
                String[] userSidArr = distributedSessionManager.createUserSid(request, key);
                userSid = userSidArr[0];
                CookieUtil.setCookie(cookieName, userSid, request, response);
                actualSid = userSidArr[1];
            }
            actualSid = "sid:" + actualSid;
            DistributedHttpSessionWrapper distSession = null;
            try {
                Map<String, Object> allAttribute = distributedSessionManager.getSession(actualSid, request.getSession()
                        .getMaxInactiveInterval());
                distSession = new DistributedHttpSessionWrapper(actualSid, request.getSession(), allAttribute);
            } catch (Throwable e) {
                // 出错,删掉缓存数据
                log.error(e.getMessage(), e);
                Map<String, Object> allAttribute = new HashMap<String, Object>();
                distSession = new DistributedHttpSessionWrapper(actualSid, request.getSession(), allAttribute);
                distributedSessionManager.removeSession(distSession);
            }
            DistributedHttpServletRequestWrapper requestWrapper = new DistributedHttpServletRequestWrapper(request,
                    distSession);
            return requestWrapper;
    
        }
    
        // request处理完时操作session
        private void dealSessionAfterRequest(DistributedHttpSessionWrapper session) {
            if (session == null) {
                return;
            }
            if (session.changed) {
                distributedSessionManager.saveSession(session);
            } else if (session.invalidated) {
                distributedSessionManager.removeSession(session);
            } else {
                distributedSessionManager.expire(session);
            }
        }

    2、DistributedSessionManager,主要处理分布式session,核心代码:

    
    class DistributedSessionManager {
        protected static final Logger log = LoggerFactory.getLogger(DistributedSessionManager.class);
    
        private static DistributedSessionManager instance = null;
    
        //redis处理session的接口,自己根据情况实现
        private DistributedBaseInterFace distributedBaseInterFace;
    
        private static byte[] lock = new byte[1];
    
        private DistributedSessionManager(DistributedBaseInterFace distributedBaseInterFace) {
            this.distributedBaseInterFace = distributedBaseInterFace;
        }
    
        public static DistributedSessionManager getInstance(DistributedBaseInterFace redis) {
            if (instance == null) {
                synchronized (lock) {
                    if (instance == null) {
                        instance = new DistributedSessionManager(redis);
                    }
                }
            }
            return instance;
        }
    
        //获取session
        public Map<String, Object> getSession(String sid,int second) {
            String json = this.distributedBaseInterFace.get(sid,second);
            if (StringUtil.isNotBlank(json)) {
                return JsonUtil.unserializeMap(json);
            }
            return new HashMap<String, Object>(1);
        }
    
        //保存session
        public void saveSession(DistributedHttpSessionWrapper session) {
            Map<String, Object> map=session.allAttribute;
            if(MapUtil.isEmpty(map)){
                return;
            }
            String json = JsonUtil.serializeMap(map);
            this.distributedBaseInterFace.set(session.getId(), json, session.getMaxInactiveInterval());
        }
    
        //删除session
        public void removeSession(DistributedHttpSessionWrapper session) {
            distributedBaseInterFace.del(session.getId());
        }
    
        public void expire(DistributedHttpSessionWrapper session) {
            distributedBaseInterFace.expire(session.getId(), session.getMaxInactiveInterval());
        }
    
        /**
         * 创建cookie的sid
         */
        public String[] createUserSid(HttpServletRequest request, String key) {
            //...
        }
    
        public String getActualSid(String userSid, HttpServletRequest request, String key) {
            //...
        }
    }
    
    

    3、DistributedHttpSessionWrapper 实现了 HttpSession,进行分布式session包装,核心代码:

    
    public class DistributedHttpSessionWrapper implements HttpSession {
    
        private HttpSession orgiSession;
    
        private String sid;
    
        boolean changed = false;
    
        boolean invalidated = false;
    
        Map<String, Object> allAttribute;
    
        public DistributedHttpSessionWrapper(String sid, HttpSession session, Map<String, Object> allAttribute) {
            this.orgiSession = session;
            this.sid = sid;
            this.allAttribute = allAttribute;
        }
    
        @Override
        public String getId() {
            return this.sid;
        }
    
        @Override
        public void setAttribute(String name, Object value) {
            changed = true;
            allAttribute.put(name, value);
        }
    
        @Override
        public Object getAttribute(String name) {
            return allAttribute.get(name);
        }
    
        @Override
        public Enumeration<String> getAttributeNames() {
            Set<String> set = allAttribute.keySet();
            Iterator<String> iterator = set.iterator();
            return new MyEnumeration<String>(iterator);
        }
    
        private class MyEnumeration<T> implements Enumeration<T> {
            Iterator<T> iterator;
    
            public MyEnumeration(Iterator<T> iterator) {
                super();
                this.iterator = iterator;
            }
    
            @Override
            public boolean hasMoreElements() {
                return iterator.hasNext();
            }
    
            @Override
            public T nextElement() {
                return iterator.next();
            }
    
        }
    
        @Override
        public void invalidate() {
            this.invalidated = true;
        }
    
        @Override
        public void removeAttribute(String name) {
            changed = true;
            allAttribute.remove(name);
        }
    
        @Override
        public long getCreationTime() {
            return orgiSession.getCreationTime();
        }
    
        @Override
        public long getLastAccessedTime() {
            return orgiSession.getLastAccessedTime();
        }
    
        @Override
        public int getMaxInactiveInterval() {
            return orgiSession.getMaxInactiveInterval();
        }
    
        @Override
        public ServletContext getServletContext() {
            return orgiSession.getServletContext();
        }
    
        @Override
        public Object getValue(String arg0) {
            return orgiSession.getValue(arg0);
        }
    
        @Override
        public String[] getValueNames() {
            return orgiSession.getValueNames();
        }
    
        @Override
        public boolean isNew() {
            return orgiSession.isNew();
        }
    
        @Override
        public void putValue(String arg0, Object arg1) {
            orgiSession.putValue(arg0, arg1);
        }
    
        @Override
        public void removeValue(String arg0) {
            orgiSession.removeValue(arg0);
        }
    
        @Override
        public void setMaxInactiveInterval(int arg0) {
            orgiSession.setMaxInactiveInterval(arg0);
        }
    
        @Override
        public HttpSessionContext getSessionContext() {
            return orgiSession.getSessionContext();
        }
    

    4、DistributedHttpServletRequestWrapper 实现了 HttpServletRequestWrapper,包装处理过的session和原始request,核心代码:

    
    public class DistributedHttpServletRequestWrapper extends javax.servlet.http.HttpServletRequestWrapper {
        private HttpServletRequest orgiRequest;
        private DistributedHttpSessionWrapper session;
    
        public DistributedHttpServletRequestWrapper(HttpServletRequest request, DistributedHttpSessionWrapper session) {
            super(request);
            if (session == null){
                //异常处理。。
            }
            if (request == null){
                //异常处理。。
            }
            this.orgiRequest = request;
            this.session = session;
        }
    
        public DistributedHttpSessionWrapper getSession(boolean create) {
            orgiRequest.getSession(create);
            return session;
        }
    
        public DistributedHttpSessionWrapper getSession() {
            return session;
        }
    
    }
    

    5、另外,定义DistributedBaseInterFace接口,用来处理session入redis进行持久化操作:

    public interface DistributedBaseInterFace {
    
        /**
         * 根据key获取缓存数据
         * @param key   
         * @param seconds   
         */
        public String get(String key,int seconds);
    
        /**
         * 更新缓存数据
         * @param key    
         * @param json
         * @param seconds
         */
        public void set(String key, String json,int  seconds);
    
        /**
         * 删除缓存
         * @param key
         */
        public void del(String key);
    
        /**
         * 设置过期数据
         * @param key
         * @param seconds
         */
        public void expire(String key,int  seconds);
    

    注:本文只是在Spring中采用redis的方式对session进行管理,还有其他诸多的实现方式,比如在容器里面配置等,设计路由算法让session依赖于集群中的各个节点服务器,,,,,,但redis这种方式在实际应用中还是比较广泛的,LZ公司主要就是采用此方式。

    展开全文
  • SqlServer2005数据库分布式管理  2010-08-06 13:49:49| 分类: 学习 | 标签:sql2005 发布 订阅 数据同步  |举报 |字号大中小 订阅 什么叫分布式我也不懂,我只是使用SQL的发布和订阅功能...
  • 蜜蜂之道:分布式管理 第一自然段:蜜蜂将雄果树花朵今年最后的花蜜零星采集回家,他们在黑暗的家中,继续辛勤劳作 第二自然段:凯利禽兽把蜂群从建筑物和树林中搬出来,在家中建起新的蜂箱,最后被凯利的手术...
  • 集中式:版本库是集中存放在中央...另外,集中式版本管理,不代表服务器只有一台。就像淘宝就一个网站,但服务器有上千台一样。 3. 分布式:每个人的电脑上都是一个完整的版本库,找一台电脑充当服务器的角色,...
  • 三分虚拟化技术、七分分布式管理、十二分大数据  谷歌(Google)利用大数据技术在短短十多年内将寂寂无名的草根企业迅速打造成为全球著名的IT企业,这段商业传奇将全球的目光都聚焦到了大数据上,人们一致认为...
  • 以云计算和大数据为背景的...如何对众多的通用计算机进行有效的管理与利用成为分布式系统需要解决的核心问题。 资源管理  通用计算机系统由CPU和若干设备控制器通过共同的总线相连而成,而做为一台服务器最重要的
  • Git被开发出来的初衷是为了更好地管理Linux内核,现在却是被广泛应用于全球各种大小型公司的项目中。 在学习Git之前,建议您先熟悉一下Linux的常用命令,我前面有篇相关的文章: http://blog.csdn
  • hg分布式管理工具操作方法

    万次阅读 2014-01-07 22:55:48
    Mercurial是一个跨平台的分布式版本控制工具。主要由Python语言实现,也包含一个用C语言实现的二进制比较工具。对Mercurial的所有操作都由不同的关键字作为hg的参数来实现的。它采用SHA-1散列算法来识别修订版本,...
  • Git是一款免费、开源的分布式版本控制系统,用于敏捷高效地处理任何或小或大的项目。不管开发还是测试,我们都会用到它,因为用它管理我们的代码比较方便,在团队合作中我们通过git就能获得最新的代码,而不需要分别...
  • 项目使用的是SpringMVC+hibernate,听从老大的意见使用Spring-Session进行处理session,用redis托管Session。下面正式记录下处理方法。  1.如果项目之前没有整合过spring-data-redis的话,这一步需要先做,在maven...
  • http://www.adventnet.com.cn/index.html
  • centos搭建Git分布式管理控制系统

    千次阅读 2011-10-09 13:12:24
    Git是一个开源的分布式版本控制系统,用以有效、高速的处理从很小到非常大的项目版本管理。 安装步骤: 操作系统:centos 5.5 安装GIT依赖的包 yum install zlib-devel  yum insta
  • java - disconf分布式管理-配置文件篇

    千次阅读 2016-09-21 11:43:35
    #忽略哪些分布式配置,用逗号分隔 disconf.ignore= #获取远程配置 重试次数,默认是3次 disconf.conf_server_url_retry_times=1 #获取远程配置 重试时休眠时间,默认是5秒 disconf.conf_server_url_retry_sleep_...
  • 集中式管理的优劣 分布管理的优劣 高内聚和低耦合 高内聚 低耦合 总结 现如今,在整个项目开发的过程中模块化以他独特的优势引领了一股项目架构潮流。灵活,可复用,后期易维护,代码逻辑清晰,所有的这些都成为了...
  • 服务端的接口设计和调用代码设计,客户端的界面和调用设计,都不是一个新手能随便搞定的,不过iModel平台的出现将打破只要高手才能开发的分布式应用管理软件,几分钟的开发平台搭建,完全可视化填表开发,让
  • 浅谈MongoDB数据库分布式存储管理

    千次阅读 2017-07-24 11:18:37
    分布式管理
  • 分布式内存管理

    千次阅读 2013-05-29 18:54:15
    分布式内存管理之结构图解 ...在分布式内存管理模块里,如何体现出内存的分布式管理呢?在我的理解里,分布式就是说每个线程对应着管理其局部的内存。好了,这个我们就很容易想到一个技术:线程本 地存储或者
  • 分布式数据库管理系统实现技术分布式数据库管理系统实现技术分布式数据库管理系统实现技术分布式数据库管理系统实现技术
  • git分布式系统管理

    2016-08-12 11:07:19
    git分布式系统管理git分布式系统管理

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 58,997
精华内容 23,598
关键字:

分布式管理