分布式配置管理平台Disconf

Disconf 可以为各种业务平台提供统一的配置管理服务。

• 支持配置（配置项+配置文件）的分布式化管理

• 配置发布统一化

• 极简的使用方式（注解式编程 或 XML代码无代码侵入模式）

• 低侵入性或无侵入性、强兼容性

• 需要Spring编程环境

重要功能特点

• 支持配置（配置项+配置文件）的分布式化管理

• 配置发布统一化

• 配置发布、更新统一化（云端存储、发布）:配置存储在云端系统，用户统一在平台上进行发布、更新配置。

• 配置更新自动化：用户在平台更新配置，使用该配置的系统会自动发现该情况，并应用新配置。特殊地，如果用户为此配置定义了回调函数类，则此函数类会被自动调用。

• 配置异构系统管理

• 异构包部署统一化：这里的异构系统是指一个系统部署多个实例时，由于配置不同，从而需要多个部署包（jar或war）的情况（下同）。使用 Disconf后，异构系统的部署只需要一个部署包，不同实例的配置会自动分配。特别地，在业界大量使用部署虚拟化（如JPAAS系统，SAE，BAE） 的情况下，同一个系统使用同一个部署包的情景会越来越多，Disconf可以很自然地与他天然契合。

• 异构主备自动切换：如果一个异构系统存在主备机，主机发生挂机时，备机可以自动获取主机配置从而变成主机。

• 异构主备机Context共享工具：异构系统下，主备机切换时可能需要共享Context。可以使用Context共享工具来共享主备的Context。

• 极简的使用方式（注解式编程 或 XML代码无代码侵入模式）：我们追求的是极简的、用户编程体验良好的编程方式。目前支持两种开发模式：基于XML配置或才基于注解，即可完成复杂的配置分布式化。

• 需要Spring编程环境

注：配置项是指某个类里的某个Field字段。

Disconf的功能特点描述图：

查看大图

其它功能特点

• 低侵入性或无侵入性、强兼容性：

• 低侵入性：通过极少的注解式代码撰写，即可实现分布式配置。

• 无侵入性：通过XML简单配置，即可实现分布式配置。

• 强兼容性：为程序添加了分布式配置注解后，开启Disconf则使用分布式配置；若关闭Disconf则使用本地配置；若开启Disconf后disconf-web不能正常Work，则Disconf使用本地配置。

• 支持配置项多个项目共享，支持批量处理项目配置。

• 配置监控：平台提供自校验功能（进一步提高稳定性），可以定时校验应用系统的配置是否正确。

模块架构图

posted @ 2015-04-13 16:12 paulwong 阅读(857) | 评论 (0) | 编辑 收藏

消息传递平台 JBoss A-MQ

JBoss A-MQ 是高性能，灵活的信息平台，可以安全的传递消息，非常可靠，而且支持 Internet of Things (IoT)。JBoss A-MQ 在任意的配置中都可以很容易部署和管理，可以在保证基础设施的基础上部署，也可以在云端部署，或者是混合配置下部署。

JBoss A-MQ 支持多种语言：C，C++ 和 Java；同时还支持多种协议：JMS 1.1, TCP, SSL, STOMP, NMS, MQTT, AMQP 1.0。

JBoss A-MQ 扩展了 xPaaS 消息功能，提供 OpenShift Platform-as-a-Service (PaaS) 解决方案。

posted @ 2015-04-07 21:44 paulwong 阅读(664) | 评论 (0) | 编辑 收藏

JBoss 集成管理平台 Embedded Jopr

Embedded Jopr 是基于 Web 的应用，可以管理和监控 JBoss Application Server 的实例。 

Embedded Jopr 是 Jopr 的分支，复用了大量 Jopr 的组件。Embedded Jopr 的最终目标是替代 jmx 和 web 工作台。可以作为配置和监控 JBoss AS 实例的工具。

示例视频： demo video

posted @ 2015-04-07 21:42 paulwong 阅读(463) | 评论 (0) | 编辑 收藏

LINUX时间同步NTP

[root@clientlinux ~]# ntpdate time.windows.com
28 Jul 17:19:33 ntpdate[3432]: step time server time.windows.com offset -2428.396146 sec
# 最後面會顯示微調的時間有多少 (offset)，因為鳥哥這部主機時間差很多，所以秒數

[root@clientlinux ~]# date; hwclock -r
四  7月 28 17:20:27 CST 2011
西元2011年07月28日 (週四) 18時19分26秒  -0.752303 seconds
# 知道鳥哥想要表達什麼嗎？對啊！還得 hwclock -w 寫入 BIOS 時間才行啊！

[root@clientlinux ~]# vim /etc/crontab
# 加入這一行去！
10 5 * * * root (/usr/sbin/ntpdate time.windows.com && /sbin/hwclock -w) &> /dev/null

posted @ 2015-03-20 11:21 paulwong 阅读(454) | 评论 (0) | 编辑 收藏

commonrpc 0.1 发布，高性能分布式 RPC 框架

posted @ 2015-03-12 19:02 paulwong 阅读(716) | 评论 (0) | 编辑 收藏

NETTY资源

nginx+tomcat与netty优缺点

posted @ 2015-02-26 09:49 paulwong 阅读(488) | 评论 (0) | 编辑 收藏

SPRING CACHE之ConcurrentMapCacheManager改造

1. pom.xml中加入依赖包
   
           <dependency>
               <groupId>com.google.guava</groupId>
               <artifactId>guava</artifactId>
               <version>18.0</version>
           </dependency>
   
   
2. 改造CacheManager，MyConcurrentMapCacheManager
   
   package com.paul.common.cache;
   /*
    * Copyright 2002-2014 the original author or authors.
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *      http://www.apache.org/licenses/LICENSE-2.0
    *
    * Unless required by applicable law or agreed to in writing, software
    * distributed under the License is distributed on an "AS IS" BASIS,
    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    * See the License for the specific language governing permissions and
    * limitations under the License.
    */
   
   import java.util.Collection;
   import java.util.Collections;
   import java.util.Map;
   import java.util.concurrent.ConcurrentHashMap;
   import java.util.concurrent.ConcurrentMap;
   import java.util.concurrent.TimeUnit;
   
   import org.springframework.cache.Cache;
   import org.springframework.cache.CacheManager;
   import org.springframework.cache.concurrent.ConcurrentMapCache;
   
   import com.google.common.cache.CacheBuilder;
   
   /**
    * {@link CacheManager} implementation that lazily builds {@link ConcurrentMapCache}
    * instances for each {@link #getCache} request. Also supports a 'static' mode where
    * the set of cache names is pre-defined through {@link #setCacheNames}, with no
    * dynamic creation of further cache regions at runtime.
    *
    * <p>Note: This is by no means a sophisticated CacheManager; it comes with no
    * cache configuration options. However, it may be useful for testing or simple
    * caching scenarios. For advanced local caching needs, consider
    * {@link org.springframework.cache.guava.GuavaCacheManager} or
    * {@link org.springframework.cache.ehcache.EhCacheCacheManager}.
    *
    * @author Juergen Hoeller
    * @since 3.1
    * @see ConcurrentMapCache
    */
   public class MyConcurrentMapCacheManager implements CacheManager {
   
       private final ConcurrentMap<String, Cache> cacheMap = new ConcurrentHashMap<String, Cache>(16);
   
       private boolean dynamic = true;
   
       private boolean allowNullValues = true;
       
       private long expireTime = 30;
       
       private long maximumSize = 100;
   
   
       /**
        * Construct a dynamic ConcurrentMapCacheManager,
        * lazily creating cache instances as they are being requested.
        */
       public MyConcurrentMapCacheManager() {
       }
   
       /**
        * Construct a static ConcurrentMapCacheManager,
        * managing caches for the specified cache names only.
        */
       public MyConcurrentMapCacheManager(long expireTime, long maximumSize) {
           if(expireTime > 0)
               this.expireTime = expireTime;
           if(maximumSize > 0)
               this.maximumSize = maximumSize;
       }
   
   
       /**
        * Specify the set of cache names for this CacheManager's 'static' mode.
        * <p>The number of caches and their names will be fixed after a call to this method,
        * with no creation of further cache regions at runtime.
        * <p>Calling this with a {@code null} collection argument resets the
        * mode to 'dynamic', allowing for further creation of caches again.
        */
       public void setCacheNames(Collection<String> cacheNames) {
           if (cacheNames != null) {
               for (String name : cacheNames) {
                   this.cacheMap.put(name, createConcurrentMapCache(name));
               }
               this.dynamic = false;
           }
           else {
               this.dynamic = true;
           }
       }
   
       /**
        * Specify whether to accept and convert {@code null} values for all caches
        * in this cache manager.
        * <p>Default is "true", despite ConcurrentHashMap itself not supporting {@code null}
        * values. An internal holder object will be used to store user-level {@code null}s.
        * <p>Note: A change of the null-value setting will reset all existing caches,
        * if any, to reconfigure them with the new null-value requirement.
        */
       public void setAllowNullValues(boolean allowNullValues) {
           if (allowNullValues != this.allowNullValues) {
               this.allowNullValues = allowNullValues;
               // Need to recreate all Cache instances with the new null-value configuration
               for (Map.Entry<String, Cache> entry : this.cacheMap.entrySet()) {
                   entry.setValue(createConcurrentMapCache(entry.getKey()));
               }
           }
       }
   
       /**
        * Return whether this cache manager accepts and converts {@code null} values
        * for all of its caches.
        */
       public boolean isAllowNullValues() {
           return this.allowNullValues;
       }
   
   
       @Override
       public Collection<String> getCacheNames() {
           return Collections.unmodifiableSet(this.cacheMap.keySet());
       }
   
       @Override
       public Cache getCache(String name) {
           Cache cache = this.cacheMap.get(name);
           if (cache == null && this.dynamic) {
               synchronized (this.cacheMap) {
                   cache = this.cacheMap.get(name);
                   if (cache == null) {
                       cache = createConcurrentMapCache(name);
                       this.cacheMap.put(name, cache);
                   }
               }
           }
           return cache;
       }
   
       /**
        * Create a new ConcurrentMapCache instance for the specified cache name.
        * @param name the name of the cache
        * @return the ConcurrentMapCache (or a decorator thereof)
        */
       protected Cache createConcurrentMapCache(String name) {
           //return new ConcurrentMapCache(name, isAllowNullValues());
           //此处改用GOOGLE GUAVA的构造MANAGER方式
           return new ConcurrentMapCache(name,
                                           CacheBuilder.newBuilder()
                                                       .expireAfterWrite(this.expireTime, TimeUnit.MINUTES)
                                                       .maximumSize(this.maximumSize)
                                                       .build()
                                                       .asMap(), 
                                           isAllowNullValues());
       }
   
   }
   
   
   
3. 配置想着bean, cache-concurrentmap-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"
       xmlns:cache="http://www.springframework.org/schema/cache"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xmlns:jee="http://www.springframework.org/schema/jee"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/context
             http://www.springframework.org/schema/context/spring-context-3.0.xsd
             http://www.springframework.org/schema/beans
             http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
             http://www.springframework.org/schema/cache
             http://www.springframework.org/schema/cache/spring-cache.xsd
             http://www.springframework.org/schema/jee 
             http://www.springframework.org/schema/jee/spring-jee.xsd
             http://www.springframework.org/schema/util
             http://www.springframework.org/schema/util/spring-util.xsd">
   
       <cache:annotation-driven />
   
       <!-- <bean id="cacheManager"
           class="org.springframework.cache.concurrent.ConcurrentMapCacheManager" >
           <property name="cacheNames">
               <list>
                   <value>my-local-cache</value>
               </list>
           </property>
       </bean> -->
       
       <bean id="cacheManager"
           class="com.paul.common.cache.MyConcurrentMapCacheManager">
           <constructor-arg index="0" value="1" />
           <constructor-arg index="1" value="5000" />
       </bean>    
       
   </beans>
   
   
   
4. 通过注释进行使用
   
   /*
    * JBoss, Home of Professional Open Source
    * Copyright 2014, Red Hat, Inc. and/or its affiliates, and individual
    * contributors by the @authors tag. See the copyright.txt in the
    * distribution for a full listing of individual contributors.
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    * http://www.apache.org/licenses/LICENSE-2.0
    * Unless required by applicable law or agreed to in writing, software
    * distributed under the License is distributed on an "AS IS" BASIS,
    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    * See the License for the specific language governing permissions and
    * limitations under the License.
    */
   package com.paul.springmvc.data;
   
   import java.util.List;
   
   import javax.persistence.EntityManager;
   import javax.persistence.criteria.CriteriaBuilder;
   import javax.persistence.criteria.CriteriaQuery;
   import javax.persistence.criteria.Root;
   
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.cache.annotation.CacheEvict;
   import org.springframework.cache.annotation.Cacheable;
   import org.springframework.stereotype.Repository;
   import org.springframework.transaction.annotation.Transactional;
   
   import com.paul.springmvc.model.Member;
   
   @Repository
   @Transactional
   public class MemberDaoImpl implements MemberDao {
       @Autowired
       private EntityManager em;
   
       @Cacheable(value = "my-local-cache", key = "#id")
       public Member findById(Long id) {
           System.out.println("MemberDaoImpl NO CACHE");
           return em.find(Member.class, id);
       }
   
       public Member findByEmail(String email) {
           CriteriaBuilder cb = em.getCriteriaBuilder();
           CriteriaQuery<Member> criteria = cb.createQuery(Member.class);
           Root<Member> member = criteria.from(Member.class);
   
           /*
            * Swap criteria statements if you would like to try out type-safe criteria queries, a new
            * feature in JPA 2.0 criteria.select(member).orderBy(cb.asc(member.get(Member_.name)));
            */
   
           criteria.select(member).where(cb.equal(member.get("email"), email));
           return em.createQuery(criteria).getSingleResult();
       }
   
       public List<Member> findAllOrderedByName() {
           CriteriaBuilder cb = em.getCriteriaBuilder();
           CriteriaQuery<Member> criteria = cb.createQuery(Member.class);
           Root<Member> member = criteria.from(Member.class);
   
           /*
            * Swap criteria statements if you would like to try out type-safe criteria queries, a new
            * feature in JPA 2.0 criteria.select(member).orderBy(cb.asc(member.get(Member_.name)));
            */
   
           criteria.select(member).orderBy(cb.asc(member.get("name")));
           return em.createQuery(criteria).getResultList();
       }
   
       @CacheEvict(value="my-local-cache",allEntries=true,beforeInvocation=true)//清空所有缓存
       public void register(Member member) {
           em.persist(member);
           return;
       }
   }

posted @ 2015-02-25 16:34 paulwong 阅读(2731) | 评论 (0) | 编辑 收藏

SPRING CACHE资源

Spring Cache抽象详解

posted @ 2015-02-25 16:04 paulwong 阅读(525) | 评论 (0) | 编辑 收藏

Spring Boot使用redis做数据缓存

1 添加redis支持

在pom.xml中添加

Xml代码  

1. <dependency>  
2.           <groupId>org.springframework.boot</groupId>  
3.           <artifactId>spring-boot-starter-redis</artifactId>  
4.       </dependency>  

 

2 redis配置

Java代码  

1. @Configuration  
2. @EnableCaching  
3. public class RedisCacheConfig {  
4.     @Bean  
5.     public CacheManager cacheManager(  
6.             @SuppressWarnings("rawtypes") RedisTemplate redisTemplate) {  
7.         return new RedisCacheManager(redisTemplate);  
8.     }  
9.   
10.     @Bean  
11.     public RedisTemplate<String, String> redisTemplate(  
12.             RedisConnectionFactory factory) {  
13.         final StringRedisTemplate template = new StringRedisTemplate(factory);  
14.         template.setValueSerializer(new Jackson2JsonRedisSerializer<SysUser>(  
15.                 SysUser.class)); //请注意这里  
16.   
17.         return template;  
18.     }  
19. }  

 

3 redis服务器配置

Properties代码  

1. # REDIS (RedisProperties)  
2. spring.redis.database= # database name  
3. spring.redis.host=localhost # server host  
4. spring.redis.password= # server password  
5. spring.redis.port=6379 # connection port  
6. spring.redis.pool.max-idle=8 # pool settings ...  
7. spring.redis.pool.min-idle=0  
8. spring.redis.pool.max-active=8  
9. spring.redis.pool.max-wait=-1  
10. spring.redis.sentinel.master= # name of Redis server  
11. spring.redis.sentinel.nodes= # comma-separated list of host:port pairs  

 

4 应用

Java代码  

1. /** 
2. *此处的dao操作使用的是spring data jpa,使用@Cacheable可以在任意方法上，*比如@Service或者@Controller的方法上 
3. */  
4. public interface SysUserRepo1 extends CustomRepository<SysUser, Long> {  
5.     @Cacheable(value = "usercache")  
6.     public SysUser findByUsername(String username);  
7. }  

 

5 检验

Java代码  

1. @Controller  
2. public class TestController {  
3.       
4.       
5.     @Autowired   
6.     SysUserRepo1 sysUserRepo1;  
7.     @RequestMapping("/test")  
8.     public @ResponseBody String test(){  
9.   
10.         final SysUser loaded = sysUserRepo1.findByUsername("wyf");  
11.         final SysUser cached = sysUserRepo1.findByUsername("wyf");  
12.           
13.         return "ok";  
14.     }   
15. }  

 

效果如图：

 

posted @ 2015-02-25 10:02 paulwong 阅读(5302) | 评论 (3) | 编辑 收藏

2015年2月份最佳的免费 UI 工具包

posted @ 2015-02-24 18:25 paulwong 阅读(498) | 评论 (0) | 编辑 收藏