Jackwang@1992
Jackwang@1992

fhs-framework springboot mybatis 解决表关联查询问题的关键方案-翻译服务

简介

    开发中会经常遇到这样的场景：比如在成绩表有一个student_id，如果我要查看成绩列表需要学生的名称，一般写法就是使用join，现在大部分ORM框架对于表关联支持并不是很友好，所以很多时候我们都要自己写SQL去实现。

   翻译服务即:通过id,将对应的title/name 字段翻译出,装载到VO中用于前端展示的技术.

1 FHS 提供的翻译服务如何使用?

     a  定义翻译数据源.

        

@Service
@DataSource("base_business")
@AutoTrans(namespace = BaseTransConstant.ORG, fields = "name", useRedis = true, defaultAlias = "org")
public class UcenterMsOrganizationServiceImpl extends BaseServiceImpl implements UcenterMsOrganizationService {

      通过以上定义,我们就能知道,组织机构的表,对外开放组织机构名称这个字段给其他的业务使用.

      b  标记业务pojo orgid字段使用此翻译数据源.

          

/**
     * 所属机构
     */
    @NotNull(message = "所属机构字段不可为null", groups = {Update.class, Delete.class})
    @Length(message = "所属机构字段的长度最大为32", groups = {Add.class, Update.class}, max = 32)
    @Column(name = "organization_id")
    @Trans(type = TransType.AUTO_TRANS,key = BaseTransConstant.ORG )
    private String organizationId;

    c   调用transService的trans相关方法即可.

         

 public V d2v(D d) {
        try {
            if (d == null) {
                return null;
            }
            V vo = voClass.newInstance();
            BeanUtils.copyProperties(d, vo);
            transService.transOne(vo);
            return vo;
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }

 public List dos2vos(List dos) {
        List vos = ListUtils.copyListToList(dos, this.getVOClass());
        transService.transMore(vos);
        return vos;
    }

     c VO中需要有getTransMap 方法返回一个map,翻译服务会吧翻译的结果放到此map中.

     d 翻译后的结果示例:

    

 {
            "between": {},
            "createTime": "2019-03-25 00:00:00",
            "createUser": "1",
            "dataPermissin": {},
            "dataPermissions": "{\"parkIds\":\"0d601eb23f0e11e99571d02788407b5e\"}",
            "groupCode": null,
            "inFilter": {},
            "isDelete": null,
            "isEnable": 1,
            "methods": null,
            "organizationId": "001",
            "pkey": 1,
            "remark": "12123",
            "roleId": 1,
            "roleName": "1231",
            "state": null,
            "transMap": {
                "orgName": "机构",
                "isEnableName": "启用",
                "createUserUserName": "admin22"
            },
            "updateTime": "2019-03-29 00:00:00",
            "updateUser": "62b5870c510c4e9da3f72460001c42fa"
        },

      2  翻译服务实现

                 A 定义注解

                              自动翻译注解,把一个service当做数据源的注解,用于service实现类之上,比如上面的ORGservice

@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.TYPE})
public @interface AutoTrans
{
    /**
     *  命名空间
     * @return
     */
    String namespace();

    /**
     * 字段集合
     * @return
     */
    String[] fields();

    /**
     * 是否使用缓存翻译
     * @return  默认为true 如果是false的话
     */
    boolean useCache() default true;

    /**
     * 是否使用redis存放缓存
     * @return 默认false
     */
    boolean useRedis() default false;

    /**
     * 默认的别名
     * @return
     */
    String defaultAlias() default "";
}

          字段翻译注解,定义这个字段使用哪个翻译,比如fhs提供了auto(自动翻译),和wordbook(字典)

@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.FIELD })
public @interface Trans {

    /**
     * 获取翻译类型，比如 wordbook 是字典
     * @return 类型
     */
    String type();

    /**
     * 字段 比如  要翻译男女 上面的type写wordbook 此key写sex即可
     * @return
     */
    String key() default "";
}

         翻译类型集合,用于标记到 pojo上,代表我使用了哪些类型的翻译.

@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.TYPE})
public @interface TransTypes 
{
    /**
     * 获取需要翻译的类型
     * @return
     */
    String[] types();
}

           B 定义翻译服务类

                    主要负责根据翻译的类型决定调用哪个ITransTypeService的实现类去翻译某些字段.


@Service("transService")
public class TransService {
    /**
     * key type  val是对应type的service
     */
    private static Map transTypeServiceMap = new HashMap();

    /**
     * 注册一个trans服务
     *
     * @param type             类型
     * @param transTypeService 对应的trans接口实现
     */
    public static void registerTransType(String type, ITransTypeService transTypeService) {
        transTypeServiceMap.put(type, transTypeService);
    }

    /**
     * 翻译一个字段
     *
     * @param obj 需要翻译的对象
     */
    public void transOne(VO obj) {
        if (obj == null) {
            return;
        }
        ClassInfo info = ClassManager.getClassInfoByName(obj.getClass());
        String[] transTypes = info.getTransTypes();
        if (transTypes == null) {
            return;
        }
        List transFieldList = null;
        for (String type : transTypes) {
            transFieldList = info.getTransField(type);
            if (transFieldList == null || transFieldList.size() == 0) {
                continue;
            }
            transTypeServiceMap.get(type).transOne(obj, transFieldList);
        }
    }

    /**
     * 翻译多个 字段
     *
     * @param objList 需要翻译的对象集合
     * @param objList 需要翻译的字段集合
     */
    public void transMore(List objList) {
        if (objList == null || objList.size() == 0) {
            return;
        }
        Object object = objList.get(0);
        ClassInfo info = ClassManager.getClassInfoByName(object.getClass());
        String[] transTypes = info.getTransTypes();
        if (transTypes == null) {
            return;
        }
        List transFieldList = null;
        for (String type : transTypes) {
            transFieldList = info.getTransField(type);
            if (transFieldList == null || transFieldList.size() == 0) {
                continue;
            }
            transTypeServiceMap.get(type).transMore(objList, transFieldList);
        }
    }

}

            D 自动翻译实现

                springboot启动成功后,扫描service包,被autotrans注解标记的service,解析autotrans的内容,然后把数据库中数据缓存到内存和redis中,当业务需要翻译的时候,根据id把缓存的数据拿出来,放到transmap中.

 

    


/**
 * 本接类使用需要配合Autotrans 注解和autoTransAble的实现类
 *
 * @Description: 自动翻译服务
 * @Author: Wanglei
 * @Date: Created in 10:14 2019/10/15
 */
@Data
@Service
public class AutoTransService implements ITransTypeService, InitializingBean, ApplicationListener {

    public static final Logger LOGGER = LoggerFactory.getLogger(AutoTransService.class);


    /**
     * service的包路径
     */
    @Value("${fhs.autotrans.package:com.*.*.service.impl}")
    private String[] packageNames;

    /**
     * 翻译数据缓存map
     */
    private Map> cacheMap = new HashMap<>();


    /**
     * 缓存 默认时间：半个小时
     */
    @CreateCache(expire = 1800, name = "trans:cache:", cacheType = CacheType.REMOTE)
    private Cache> transCache;

    /**
     * 基础服务
     */
    private Map baseServiceMap = new HashMap<>();

    /**
     * 配置
     */
    private Map transSettMap = new HashMap<>();

    /**
     * 如果直接去表里查询，放到这个cache中
     */
    private ThreadLocal>> threadLocalCache = new ThreadLocal<>();

    /**
     * 翻译字段配置map
     */
    private Map transFieldSettMap = new HashMap<>();

    @Override
    public void transOne(VO obj, List toTransList) {
        Trans tempTrans = null;
        for (Field tempField : toTransList) {
            TransFieldSett transFieldSett = transFieldSettMap.containsKey(tempField) ? transFieldSettMap.get(tempField) : new TransFieldSett(tempField);
            tempTrans = transFieldSett.getTrans();
            String namespace = transFieldSett.getNamespace();
            String alias = transFieldSett.getAlias();
            if (transSettMap.containsKey(namespace) && CheckUtils.isNullOrEmpty(alias)) {
                alias = transSettMap.get(namespace).defaultAlias();
            }
            String pkey = ConverterUtils.toString(ReflectUtils.getValue(obj, tempField.getName()));
            if (StringUtils.isEmpty(pkey)) {
                continue;
            }
            Map transCache = null;
            // 主键可能是数组
            pkey = pkey.replace("[", "").replace("]", "");
            if (pkey.contains(",")) {
                String[] pkeys = pkey.split(",");
                transCache = new HashMap<>();
                Map tempTransCache = null;
                for (String tempPkey : pkeys) {
                    tempTransCache = getTempTransCacheMap(namespace, ConverterUtils.toInteger(tempPkey));
                    if (tempTransCache == null) {
                        LOGGER.error("auto trans缓存未命中:" + namespace + "_" + tempPkey);
                        continue;
                    }
                    // 比如学生表  可能有name和age 2个字段
                    for (String key : tempTransCache.keySet()) {
                        transCache.put(key, transCache.containsKey(key) ? transCache.get(key) + "," + tempTransCache.get(key) : tempTransCache.get(key));
                    }
                }
            } else {
                transCache = getTempTransCacheMap(namespace, pkey);
                if (transCache == null) {
                    LOGGER.error("auto trans缓存未命中:" + namespace + "_" + pkey);
                    continue;
                }
            }
            if (!CheckUtils.isNullOrEmpty(alias)) {
                Map tempMap = new HashMap<>();
                Set keys = transCache.keySet();
                for (String key : keys) {
                    tempMap.put(alias + key.substring(0, 1).toUpperCase() + key.substring(1), transCache.get(key));
                }
                transCache = tempMap;
            }
            Map transMap = obj.getTransMap();
            Set keys = transCache.keySet();
            for (String key : keys) {
                if (CheckUtils.isNullOrEmpty(transMap.get(key))) {
                    transMap.put(key, transCache.get(key));
                }
            }
        }
    }

    @Override
    public void transMore(List objList, List toTransList) {
        threadLocalCache.set(new HashMap<>());
        // 由于一些表数据比较多，所以部分数据不是从缓存取的，是从db先放入缓存的，翻译完了释放掉本次缓存的数据
        for (Field tempField : toTransList) {
            tempField.setAccessible(true);
            Trans tempTrans = tempField.getAnnotation(Trans.class);
            String namespace = tempTrans.key();
            // 如果是 good#student  翻译出来应该是 goodStuName goodStuAge  customer#customer  customerName
            if (namespace.contains("#")) {
                namespace = namespace.substring(0, namespace.indexOf("#"));
            }
            if (!this.baseServiceMap.containsKey(namespace)) {
                LOGGER.warn("namesapce对应的service没有标记autotrans:" + namespace);
                continue;
            }
            AutoTrans autoTransSett = this.transSettMap.get(namespace);
            if (autoTransSett.useCache()) {
                continue;
            }
            Set ids = new HashSet<>();
            objList.forEach(obj -> {
                try {
                    ids.add(tempField.get(obj));
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            });
            List dbDatas = baseServiceMap.get(namespace).findByIds(new ArrayList<>(ids));
            for (VO vo : dbDatas) {
                threadLocalCache.get().put(namespace + "_" + vo.getPkey(), createTempTransCacheMap(vo, autoTransSett));
            }
        }
        objList.forEach(obj -> {
            this.transOne(obj, toTransList);
        });
        threadLocalCache.set(null);
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        TransService.registerTransType("auto", this);
        TransMessageListener.regTransRefresher("auto", this::refreshCache);
    }


    public void init(ApplicationReadyEvent applicationReadyEvent) {
        //spring容器初始化完成之后，就会自行此方法。
        Set> entitySet = scan(AutoTrans.class, packageNames);
        // 遍历所有class，获取所有用@autowareYLM注释的字段
        if (entitySet != null) {
            for (Class entity : entitySet) {
                // 获取该类
                Object baseService = SpringContextUtil.getBeanByClass(entity);
                if (!(baseService instanceof AutoTransAble)) {
                    LOGGER.warn("AutoTrans 只能用到实现AutoTransAble的类上,不能用到:" + baseService.getClass());
                    continue;
                }
                AutoTrans autoTransSett = entity.getAnnotation(AutoTrans.class);
                this.baseServiceMap.put(autoTransSett.namespace(), (AutoTransAble) baseService);
                this.transSettMap.put(autoTransSett.namespace(), autoTransSett);
            }
        }
        refreshCache(new HashMap<>());
    }

    /**
     * 刷新缓存
     *
     * @param messageMap 消息
     */
    public void refreshCache(Map messageMap) {
        //这里必须能拿到namespace 拿不到,就当作全部刷新
        String namespace = messageMap.get("namespace") != null ?
                messageMap.get("namespace").toString() : null;
        if (namespace == null) {
            Set namespaceSet = this.transSettMap.keySet();
            namespaceSet.forEach(temp -> {
                refreshOneNamespace(temp);
            });
        } else {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                LOGGER.error("刷新缓存错误:", e);
            }
            refreshOneNamespace(namespace);
        }
    }

    /**
     * 刷新一个namespace下的所有的缓存
     *
     * @param namespace namespace
     */
    public void refreshOneNamespace(String namespace) {
        LOGGER.info("开始刷新auto-trans缓存:" + namespace);
        if (!this.transSettMap.containsKey(namespace)) {
            LOGGER.info("本系统无需刷新此缓存namespace:" + namespace);
            return;
        }

        List vos = this.baseServiceMap.get(namespace).select();
        if (vos == null || vos.isEmpty()) {
            return;
        }
        Object pkeyVal = null;
        String fielVal = null;
        Map tempCacheTransMap = null;
        VO po = null;
        AutoTrans autoTrans = this.transSettMap.get(namespace);
        //不适用缓存的不做缓存
        if (!autoTrans.useCache()) {
            return;
        }
        for (int i = 0; i < vos.size(); i++) {
            po = vos.get(i);
            pkeyVal = po.getPkey();
            cacheMap.put(namespace + "_" + pkeyVal, createTempTransCacheMap(po, autoTrans));
            if(autoTrans.useCache()){
                this.transCache.put(namespace + "_" + pkeyVal, createTempTransCacheMap(po, autoTrans));
            }
        }
        LOGGER.info("刷新auto-trans缓存完成:" + namespace);
    }

    /**
     * 创建一个临时缓存map
     *
     * @param po        po
     * @param autoTrans 配置
     * @return
     */
    private Map createTempTransCacheMap(Object po, AutoTrans autoTrans) {
        String fielVal = null;
        Map tempCacheTransMap = new LinkedHashMap<>();
        for (String field : autoTrans.fields()) {
            fielVal = ConverterUtils.toString(ReflectUtils.getValue(po, field));
            tempCacheTransMap.put(field, fielVal);
        }
        return tempCacheTransMap;
    }

    /**
     * 获取用于翻译的缓存
     *
     * @param namespace namespace
     * @param pkey      主键
     * @return 缓存
     */
    private Map getTempTransCacheMap(String namespace, Object pkey) {
        AutoTrans autoTrans = this.transSettMap.get(namespace);
        //如果内存缓存中有,则优先用内存缓存
        if (cacheMap.containsKey(namespace + "_" + pkey)) {
            return cacheMap.get(namespace + "_" + pkey);
        }
        //如果注解为空,代表可能是其他的服务提供的翻译,尝试去redis获取缓存
        else if (autoTrans == null) {
            Map redisCacheResult = this.transCache.get(namespace + "_" + pkey);
            //如果获取到了返回
            if (redisCacheResult != null) {
                return redisCacheResult;
            }
            //redis获取不到返回空map
            return new HashMap<>();
        } else {
            if (autoTrans == null) {
                LOGGER.warn("namespace对应的service没有使用autotrans注解标记:" + namespace);
                return  new HashMap<>();
            }
            //如果强调使用缓存,则可能是还没刷新进来,直接返回空map,前端在刷新一下就好了
            if (autoTrans.useCache()) {
                return new HashMap<>();
            }
            if (this.threadLocalCache.get() == null) {
                VO vo = this.baseServiceMap.get(namespace).selectById(pkey);
                return createTempTransCacheMap(vo, autoTrans);
            }
            return this.threadLocalCache.get().get(namespace + "_" + pkey);
        }
    }

    /**
     * 翻译单个的key
     *
     * @param namespace namespace
     * @param pkeyVal   主键
     * @return
     */
    public String transKey(String namespace, String pkeyVal) {
        Map tempCacheTransMap = cacheMap.get(namespace + "_" + pkeyVal);
        if (tempCacheTransMap == null) {
            LOGGER.error("auto trans缓存未命中:" + namespace + "_" + pkeyVal);
        } else {
            for (String key : tempCacheTransMap.keySet()) {
                return tempCacheTransMap.get(key);
            }
        }
        return null;
    }

    /**
     * 类扫描器
     *
     * @param annotationClass 注解
     * @param packageNames    包
     * @return 符合条件的类
     */
    public static Set> scan(Class annotationClass, String[] packageNames) {
        TypeFilter entityFilter = AnnotationTypeFilterBuilder.build(annotationClass);
        SpringClassScanner entityScanner = new SpringClassScanner.Builder().typeFilter(entityFilter).build();
        for (String packageName : packageNames) {
            entityScanner.getScanPackages().add(packageName);
        }
        Set> entitySet = null;
        try {
            entitySet = entityScanner.scan();
        } catch (ClassNotFoundException | IOException e) {
            LOGGER.error("包扫描错误", e);
            // log or throw runTimeExp
            throw new RuntimeException(e);
        }
        return entitySet;
    }

    @Override
    public void onApplicationEvent(ApplicationReadyEvent applicationReadyEvent) {
        init(applicationReadyEvent);
    }

}

/**
 * 被翻译的字段的实体
 */
@Data
class TransFieldSett {
    /**
     * trans注解
     */
    private Trans trans;
    /**
     * 命名空间
     */
    private String namespace;
    /**
     * 别名
     */
    String alias;

    public TransFieldSett(Field transField) {
        transField.setAccessible(true);
        trans = transField.getAnnotation(Trans.class);
        namespace = trans.key();
        // 如果是 good#student  翻译出来应该是 goodStuName goodStuAge  customer#customer  customerName
        if (namespace.contains("#")) {
            alias = namespace.substring(namespace.indexOf("#") + 1);
            namespace = namespace.substring(0, namespace.indexOf("#"));
        }
    }
}

全部源码地址 https://gitee.com/fhs-opensource/fhs-framework/tree/v2.x/fhs_extends/fhs_trans


开源项目地址:https://gitee.com/fhs-opensource/fhs-framework


fhs framework qq群:976278956

























你可能感兴趣的:(fhs_framework)






    

  • fhs_framework springcloud使用统一的控制器来接收rpc调用请求教程,无需每个rpc接口都写控制器
Jackwang@1992
fhs_framework

    从dubbo转到springcloud,觉得springcloud家族组件很全,但是用起来稍微麻烦,每个api都要写一个控制器来处理http请求.于是对相关代码进行抽象,使用统一控制器方法来处理请求,返回结果.1RPC接口定义在定义接口的时候,url使用统一的开头/api/*,将需要调用的类和方法标记到url中.比如@RequestLine("GET/api/com.fhs.basics.api.
    

    • 

  • sql统计相同项个数并按名次显示
朱辉辉33
javaoracle

    现在有如下这样一个表：
A表
ID Name time
------------------------------
0001 aaa 2006-11-18
0002 ccc 2006-11-18
0003 eee 2006-11-18
0004 aaa 2006-11-18
0005 eee 2006-11-18
0004 aaa 2006-11-18
0002 ccc 20
    

    • 

  • Android+Jquery Mobile学习系列-目录
白糖_
JQuery Mobile

    最近在研究学习基于Android的移动应用开发，准备给家里人做一个应用程序用用。向公司手机移动团队咨询了下，觉得使用Android的WebView上手最快，因为WebView等于是一个内置浏览器，可以基于html页面开发，不用去学习Android自带的七七八八的控件。然后加上Jquery mobile的样式渲染和事件等，就能非常方便的做动态应用了。
 
从现在起，往后一段时间，我打算
    

    • 

  • 如何给线程池命名
daysinsun
线程池

            在系统运行后，在线程快照里总是看到线程池的名字为pool-xx，这样导致很不好定位，怎么给线程池一个有意义的名字呢。参照ThreadPoolExecutor类的ThreadFactory，自己实现ThreadFactory接口，重写newThread方法即可。参考代码如下：
   
public class Named
    

    • 

  • IE 中"HTML Parsing Error:Unable to modify the parent container element before the
周凡杨
html解析errorreadyState

     
错误： IE 中"HTML Parsing Error:Unable to modify the parent container element before the child element is closed"
 
 
现象： 同事之间几个IE 测试情况下，有的报这个错，有的不报。经查询资料后，可归纳以下原因。
    

    • 

  • java上传
g21121
java

    我们在做web项目中通常会遇到上传文件的情况，用struts等框架的会直接用的自带的标签和组件，今天说的是利用servlet来完成上传。
我们这里利用到commons-fileupload组件，相关jar包可以取apache官网下载：http://commons.apache.org/
下面是servlet的代码：
//定义一个磁盘文件工厂
DiskFileItemFactory fact
    

    • 

  • SpringMVC配置学习
510888780
springmvc

    spring MVC配置详解
现在主流的Web MVC框架除了Struts这个主力 外，其次就是Spring MVC了，因此这也是作为一名程序员需要掌握的主流框架，框架选择多了，应对多变的需求和业务时，可实行的方案自然就多了。不过要想灵活运用Spring MVC来应对大多数的Web开发，就必须要掌握它的配置及原理。
　　一、Spring MVC环境搭建：（Spring 2.5.6 + Hi
    

    • 

  • spring mvc-jfreeChart 柱图(1)
布衣凌宇
jfreechart

    第一步：下载jfreeChart包，注意是jfreeChart文件lib目录下的，jcommon-1.0.23.jar和jfreechart-1.0.19.jar两个包即可；
第二步：配置web.xml;
web.xml代码如下
<servlet>
    <servlet-name>jfreechart</servlet-nam
    

    • 

  • 我的spring学习笔记13-容器扩展点之PropertyPlaceholderConfigurer
aijuans
Spring3

    PropertyPlaceholderConfigurer是个bean工厂后置处理器的实现，也就是BeanFactoryPostProcessor接口的一个实现。关于BeanFactoryPostProcessor和BeanPostProcessor类似。我会在其他地方介绍。PropertyPlaceholderConfigurer可以将上下文（配置文件）中的属性值放在另一个单独的标准java P
    

    • 

  • java 线程池使用 Runnable&Callable&Future
antlove
javathreadRunnablecallablefuture

    1. 创建线程池
ExecutorService executorService = Executors.newCachedThreadPool();
 
2. 执行一次线程，调用Runnable接口实现
Future<?> future = executorService.submit(new DefaultRunnable());
System.out.prin
    

    • 

  • XML语法元素结构的总结
百合不是茶
xml树结构

    1.XML介绍1969年   gml (主要目的是要在不同的机器进行通信的数据规范)1985年   sgml  standard generralized markup language1993年   html(www网)1998年  xml   extensible markup language
    

    • 

  • 改变eclipse编码格式
bijian1013
eclipse编码格式

    1.改变整个工作空间的编码格式
        改变整个工作空间的编码格式，这样以后新建的文件也是新设置的编码格式。
        Eclipse->window->preferences->General->workspace-
    

    • 

  • javascript中return的设计缺陷
bijian1013
JavaScriptAngularJS

    代码1：
<script>
var gisService = (function(window)
{
return
{
name:function ()
{
alert(1);
}
};
})(this);
gisService.name();
&l
    

    • 

  • 【持久化框架MyBatis3八】Spring集成MyBatis3
bit1129
Mybatis3

    pom.xml配置
Maven的pom中主要包括：
MyBatis
MyBatis-Spring
Spring
MySQL-Connector-Java
Druid
applicationContext.xml配置  
<?xml version="1.0" encoding="UTF-8"?>
&
    

    • 

  • java web项目启动时自动加载自定义properties文件
bitray
javaWeb监听器相对路径

    创建一个类
public class ContextInitListener implements ServletContextListener
使得该类成为一个监听器。用于监听整个容器生命周期的，主要是初始化和销毁的。
类创建后要在web.xml配置文件中增加一个简单的监听器配置，即刚才我们定义的类。
<listener>
<des
    

    • 

  • 用nginx区分文件大小做出不同响应
ronin47

    昨晚和前21v的同事聊天，说到我离职后一些技术上的更新。其中有个给某大客户(游戏下载类)的特殊需求设计，因为文件大小差距很大——估计是大版本和补丁的区别——又走的是同一个域名，而squid在响应比较大的文件时，尤其是初次下载的时候，性能比较差，所以拆成两组服务器，squid服务于较小的文件，通过pull方式从peer层获取，nginx服务于较大的文件，通过push方式由peer层分发同步。外部发布
    

    • 

  • java-67-扑克牌的顺子.从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的.2-10为数字本身，A为1，J为11，Q为12，K为13，而大
bylijinnan
java

    package com.ljn.base;
import java.util.Arrays;
import java.util.Random;
public class ContinuousPoker {
/**
* Q67 扑克牌的顺子 从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的。
* 2-10为数字本身，A为1，J为1
    

    • 

  • 翟鸿燊老师语录
ccii
翟鸿燊

    一、国学应用智慧TAT之亮剑精神A
1. 角色就是人格
    就像你一回家的时候，你一进屋里面，你已经是儿子，是姑娘啦，给老爸老妈倒怀水吧，你还觉得你是老总呢？还拿派呢？就像今天一样，你们往这儿一坐，你们之间是什么，同学，是朋友。
    还有下属最忌讳的就是领导向他询问情况的时候，什么我不知道，我不清楚，该你知道的你凭什么不知道
    

    • 

  • [光速与宇宙]进行光速飞行的一些问题
comsci
问题

    
     在人类整体进入宇宙时代，即将开展深空宇宙探索之前，我有几个猜想想告诉大家
    仅仅是猜想。。。未经官方证实
     1：要在宇宙中进行光速飞行，必须首先获得宇宙中的航行通行证，而这个航行通行证并不是我们平常认为的那种带钢印的证书，是什么呢？ 下面我来告诉
    

    • 

  • oracle undo解析
cwqcwqmax9
oracle

    oracle undo解析2012-09-24 09:02:01     我来说两句       作者：虫师收藏    我要投稿
Undo是干嘛用的？         &nb
    

    • 

  • java中各种集合的详细介绍
dashuaifu
java集合

    一，java中各种集合的关系图 Collection       接口的接口     对象的集合  ├ List           子接口   &n
    

    • 

  • 卸载windows服务的方法
dcj3sjt126com
windowsservice

    卸载Windows服务的方法
在Windows中，有一类程序称为服务，在操作系统内核加载完成后就开始加载。这里程序往往运行在操作系统的底层，因此资源占用比较大、执行效率比较高，比较有代表性的就是杀毒软件。但是一旦因为特殊原因不能正确卸载这些程序了，其加载在Windows内的服务就不容易删除了。即便是删除注册表中的相 应项目，虽然不启动了，但是系统中仍然存在此项服务，只是没有加载而已。如果安装其他
    

    • 

  • Warning: The Copy Bundle Resources build phase contains this target's Info.plist
dcj3sjt126com
iosxcode

     
 
http://developer.apple.com/iphone/library/qa/qa2009/qa1649.html
Excerpt:
You are getting this warning because you probably added your Info.plist file to your Copy Bundle 
    

    • 

  • 2014之C++学习笔记（一）
Etwo
C++EtwoEtwoiterator迭代器

            已经有很长一段时间没有写博客了，可能大家已经淡忘了Etwo这个人的存在，这一年多以来，本人从事了AS的相关开发工作，但最近一段时间，AS在天朝的没落，相信有很多码农也都清楚，现在的页游基本上达到饱和，手机上的游戏基本被unity3D与cocos占据，AS基本没有容身之处。so。。。最近我并不打算直接转型
    

    • 

  • js跨越获取数据问题记录
haifengwuch
jsonpjsonAjax

    js的跨越问题，普通的ajax无法获取服务器返回的值。
  第一种解决方案，通过getson，后台配合方式，实现。
Java后台代码：
protected void doPost(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
String ca
    

    • 

  • 蓝色jQuery导航条
ini
JavaScripthtmljqueryWebhtml5

    效果体验：http://keleyi.com/keleyi/phtml/jqtexiao/39.htmHTML文件代码：
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>jQuery鼠标悬停上下滑动导航条 - 柯乐义<
    

    • 

  • linux部署jdk,tomcat,mysql
kerryg
jdktomcatlinuxmysql

    1、安装java环境jdk:
    一般系统都会默认自带的JDK,但是不太好用，都会卸载了，然后重新安装。
   1.1）、卸载：
     （rpm -qa :查询已经安装哪些软件包；
       rmp -q 软件包：查询指定包是否已
    

    • 

  • DOMContentLoaded VS onload VS onreadystatechange
mutongwu
jqueryjs

    1. DOMContentLoaded 在页面html、script、style加载完毕即可触发，无需等待所有资源（image/iframe）加载完毕。（IE9+）
2. onload是最早支持的事件，要求所有资源加载完毕触发。
3. onreadystatechange 开始在IE引入，后来其它浏览器也有一定的实现。涉及以下 document , applet, embed, fra
    

    • 

  • sql批量插入数据
qifeifei
批量插入

    hi，
  自己在做工程的时候，遇到批量插入数据的数据修复场景。我的思路是在插入前准备一个临时表，临时表的整理就看当时的选择条件了，临时表就是要插入的数据集，最后再批量插入到数据库中。
  
WITH tempT AS (
SELECT
item_id AS combo_id,
item_id,
now() AS create_date
FROM
a
    

    • 

  • log4j打印日志文件 如何实现相对路径到 项目工程下
thinkfreer
Weblog4j应用服务器日志

    最近为了实现统计一个网站的访问量，记录用户的登录信息，以方便站长实时了解自己网站的访问情况，选择了Apache 的log4j,但是在选择相对路径那块 卡主了，X度了好多方法(其实大多都是一样的内用，还一个字都不差的)，都没有能解决问题，无奈搞了2天终于解决了，与大家分享一下
需求：
用户登录该网站时，把用户的登录名,ip,时间。统计到一个txt文档里，以方便其他系统调用此txt。项目名
    

    • 

  • linux下mysql-5.6.23.tar.gz安装与配置
笑我痴狂
mysqllinuxunix

    1.卸载系统默认的mysql
[root@localhost ~]# rpm -qa | grep mysql
mysql-libs-5.1.66-2.el6_3.x86_64
mysql-devel-5.1.66-2.el6_3.x86_64
mysql-5.1.66-2.el6_3.x86_64
[root@localhost ~]# rpm -e mysql-libs-5.1
    

    •