ink_墨
ink_墨

ES封装工具类简单增删改查

1.使用时调用该类中的方法:

package cn.com.cewell.search.esBase;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.apache.http.HttpHost;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
import org.elasticsearch.action.admin.indices.create.CreateIndexRequest;
import org.elasticsearch.action.admin.indices.create.CreateIndexResponse;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.admin.indices.get.GetIndexRequest;
import org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequest;
import org.elasticsearch.action.bulk.BulkItemResponse;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.search.SearchType;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.client.*;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentFactory;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.aggregations.Aggregation;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.avg.InternalAvg;
import org.elasticsearch.search.aggregations.metrics.cardinality.InternalCardinality;
import org.elasticsearch.search.aggregations.metrics.max.InternalMax;
import org.elasticsearch.search.aggregations.metrics.min.InternalMin;
import org.elasticsearch.search.aggregations.metrics.sum.Sum;
import org.elasticsearch.search.aggregations.metrics.valuecount.InternalValueCount;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.sort.FieldSortBuilder;

import java.lang.reflect.Field;
import java.util.*;

public class EsBaseUtils {
    private static int TIME_OUT = 5 * 60 * 1000;
    private static RestHighLevelClient restHighLevelClient = null;

    private static String host = "127.0.0.1";
    private static int port = 9200;

    //获取客户端
    private static RestHighLevelClient getClient() {
        if (restHighLevelClient == null) {
            buildClient();
        }
        return restHighLevelClient;
    }

    //构建客户端
    private static void buildClient() {
        final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        RestClientBuilder builder = RestClient.builder(new HttpHost(host, port))
                .setMaxRetryTimeoutMillis(TIME_OUT)
                .setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
                    @Override
                    public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
                        return httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
                    }
                });
        restHighLevelClient = new RestHighLevelClient(builder);
        System.out.println(">>>>>>buildClient>>>host:" + host + " port:" + port);
    }

    //判断索引是否存在
    public static boolean indexExists(String index) {
        GetIndexRequest request = new GetIndexRequest();
        request.indices(index);
        try {
            return getClient().indices().exists(request, RequestOptions.DEFAULT);
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println(">>>>>>indexExists>>>index isExists fail!  index=" + index);
            return false;
        }
    }

    //删除索引
    public static void deleteIndex(String index) {
        DeleteIndexRequest request = new DeleteIndexRequest(index);
        request.indices(index);
        try {
            getClient().indices().delete(request, RequestOptions.DEFAULT);
            System.out.println(">>>>>>deleteIndex>>>delete index success!  index=" + index);
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println(">>>>>>deleteIndex>>>delete index fail!  index=" + index);
        }
    }

    //创建索引
    public static boolean createIndexAndMapping(String index, String type, Class clazz) {
        if (indexExists(index)) {
            // 存在就删除重新创建
            deleteIndex(index);
        }
        try {
            CreateIndexRequest createIndexRequest = new CreateIndexRequest(index);
            CreateIndexResponse createIndexResponse = getClient().indices().create(createIndexRequest, RequestOptions.DEFAULT);
            if (!createIndexResponse.isAcknowledged()) {
                System.out.println(">>>>>>createIndexAndMapping>>>create index error!  index=" + index);
                return false;
            }
            PutMappingRequest putMapping = Requests.putMappingRequest(index).type(type).source(createMapping(clazz));
            AcknowledgedResponse response = getClient().indices().putMapping(putMapping, RequestOptions.DEFAULT);
            if (!response.isAcknowledged()) {
                System.out.println(">>>>>>createIndexAndMapping>>>create mapping error! index=" + index+" type="+type);
                return false;
            }
            System.out.println(">>>>>>createIndexAndMapping>>>create mapping success! index=" + index+" type="+type);
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println(">>>>>>createIndexAndMapping>>>create error! index=" + index+" type="+type);
            return false;
        }
        return true;
    }

    //查询数据-返回数据
    public static JSONArray queryList(String index, String type, QueryRule rule) {
        JSONArray jsonArray = new JSONArray();
        try {
            //拼接查询条件
            SearchSourceBuilder sourceBuilder = search(rule);
            if (null == sourceBuilder) {
                return jsonArray;
            }
            SearchRequest searchRequest = new SearchRequest(index).types(type)
                    .searchType(SearchType.QUERY_THEN_FETCH)
                    .source(sourceBuilder);
            SearchResponse response = getClient().search(searchRequest, RequestOptions.DEFAULT);
            SearchHit[] hits = response.getHits().getHits();
            for (SearchHit hit : hits) {
                jsonArray.add(hit.getSourceAsMap());
            }
            System.out.println(">>>>>>queryList>>>size:" + jsonArray.size() + " jsonArray:" + jsonArray);
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println(">>>>>>queryList>>>size:" + jsonArray.size() + " 失败:" + e.getMessage());
        }
        return jsonArray;
    }

    //查询数据-聚合
    public static JSONArray queryListAgg(String index, String type, QueryRule rule,List groupFields){
        JSONArray jsonArray = new JSONArray();
        try {
            //拼接普通查询条件
            SearchSourceBuilder sourceBuilder = search(rule);
            if (null == sourceBuilder) {
                return jsonArray;
            }
            //拼接聚合条件
            TermsAggregationBuilder termsBuilder = AggregationBuilders.terms(groupFields.get(0)).field(groupFields.get(0)).size(10000);
            searchAgg(termsBuilder,groupFields,0);
            sourceBuilder.aggregation(termsBuilder);
            //查询
            SearchRequest searchRequest = new SearchRequest(index).types(type)
                    .searchType(SearchType.QUERY_THEN_FETCH)
                    .source(sourceBuilder);
            SearchResponse response = getClient().search(searchRequest, RequestOptions.DEFAULT);
            //解析聚合结果
            ArrayList results = results(response);
            System.out.println(results);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return jsonArray;
    }
    private static ArrayList results(SearchResponse agg){
        Map aggregations = agg.getAggregations().asMap();
        ArrayList objects = new ArrayList<>();
        for (Map.Entry entry:aggregations.entrySet()) {
            String key = entry.getKey();
            Aggregation value = entry.getValue();
            HashMap group = new HashMap<>();
            parseAggs(value,group,key,objects);
        }
        return objects;
    }

    //解析聚合结果(解析结果逻辑有问题,导致返回的集合中没有数据,暂时没有解决)
    private static ArrayList parseAggs(Aggregation agg, HashMap group,String field,ArrayList objects){
        if (agg instanceof Terms){
            for (Terms.Bucket bucket:((Terms) agg).getBuckets() ){
                String keyAsString = bucket.getKeyAsString();
                group.put(field,keyAsString);
                for (Map.Entry entry :bucket.getAggregations().asMap().entrySet()) {
                    String key = entry.getKey();
                    Aggregation value = entry.getValue();
                    if (value instanceof Terms){
                        parseAggs(value,group,key,objects);
                    }else {
                        LinkedHashMap map = package2map(bucket);
                        map.putAll(group);
                        objects.add(map);
                        break;
                    }
                }
            }
        }
        return objects;
    }
    private static LinkedHashMap package2map(Terms.Bucket bucket){
        LinkedHashMap map = new LinkedHashMap<>();
        for (Map.Entry entry :bucket.getAggregations().asMap().entrySet()) {
            String key = entry.getKey();
            Aggregation value = entry.getValue();
            map.put(key,getValue(value));
        }
        return map;
    }

    //取值
    public static String getValue(Aggregation agg) {
        String type = agg.getType();
        String result = "";
        switch (type) {
            case "avg":
                result = String.valueOf(((InternalAvg) agg).getValue());
                break;
            case "sum":
                result = String.valueOf(((Sum) agg).getValue());
                break;
            case "value_count":
                result = String.valueOf(((InternalValueCount) agg).getValue());
                break;
            case "min":
                result = String.valueOf(((InternalMin) agg).getValue());
                break;
            case "max":
                result = String.valueOf(((InternalMax) agg).getValue());
                break;
            case "cardinality":
                result = String.valueOf(((InternalCardinality) agg).getValue());
                break;
            default:
                result = String.valueOf(agg);
                break;
        }
        return result;
    }

    //插入数据
    public static int save(String index, String type, List> result) {
        BulkRequest bulkRequest = new BulkRequest();
        for (Map map : result) {
            bulkRequest.add(new IndexRequest(index, type).source(map));
        }
        //插入
        try {
            BulkResponse bulkResponse = getClient().bulk(bulkRequest, RequestOptions.DEFAULT);
            if (bulkResponse.hasFailures()) {
                for (BulkItemResponse item : bulkResponse.getItems()) {
                    System.out.println(">>>>>>save>>>error1... msg=" + item.getFailureMessage());
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println(">>>>>>save>>>error2... msg=" + e.getMessage());
        }
        int count = bulkRequest.numberOfActions();
        System.out.println(">>>>>>save>>>save success, count=" + count);
        return count;
    }

    //修改数据-根据查询条件
    public static void update(String index, String type, QueryRule rule, Map result) {
        List esId = getESId(index, type, rule);
        if (esId.size() == 1) {
            upsertEs(index, type, esId.get(0), result);
        } else {
            System.out.println(">>>>>>update>>>getESId number is not one!");
        }
    }

    //删除数据-根据查询条件
    public static void delete(String index, String type, QueryRule rule) {
        List esId = getESId(index, type, rule);
        try {
            for (String id : esId) {
                DeleteRequest deleteRequest = new DeleteRequest(index, index, id);
                getClient().delete(deleteRequest, RequestOptions.DEFAULT);
            }
            System.out.println(">>>>>>delete>>>delete success ids=" + esId);
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println(">>>>>>delete>>>delete fail id=" + esId);
        }
    }

    //查询数据-返回响应
    private static SearchSourceBuilder search(QueryRule rule) {
        try {
            //获取所有查询条件
            List criterions = rule.getCriterions();
            SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
            BoolQueryBuilder builder = QueryBuilders.boolQuery();
            //拼装查询条件
            for (QueryCriterion criterion : criterions) {
                builder.filter(criterion.getBuilder());
            }
            sourceBuilder.query(builder).explain(true);
            //拼开始和数量
            if (rule.getFirstResult() > -1 && rule.getMaxResults() > 0) {
                sourceBuilder.from(rule.getFirstResult()).size(rule.getMaxResults());
            }
            //拼排序条件
            List sorts = rule.getOrderPropertyNames();
            if (null != sorts && !sorts.isEmpty()) {
                for (String s : sorts) {
                    sourceBuilder.sort(new FieldSortBuilder(s).order(rule.getSortMode()));
                }
            }
            return sourceBuilder;
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println(">>>>>>queryList>>>search fail:" + e.getMessage());
        }
        return null;
    }

    //根据查询条件返回主键id
    private static List getESId(String index, String type, QueryRule rule) {
        SearchSourceBuilder sourceBuilder = search(rule);
        List ids = new ArrayList<>();
        if (null == sourceBuilder) {
            return ids;
        }
        try {
            SearchRequest searchRequest = new SearchRequest(index).types(type)
                    .searchType(SearchType.QUERY_THEN_FETCH)
                    .source(sourceBuilder);
            SearchResponse response = getClient().search(searchRequest, RequestOptions.DEFAULT);
            SearchHit[] hits = response.getHits().getHits();
            for (SearchHit hit : hits) {
                ids.add(hit.getId());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return ids;
    }

    //批量更新ES
    public static Integer upsertEs(String index, String type, String id, Map params) {
        BulkRequest bulkRequest = new BulkRequest();
        bulkRequest.add(getRequest(index, type, id, JSONObject.fromObject(params).toString()));
        //插入
        try {
            BulkResponse bulkResponse = getClient().bulk(bulkRequest, RequestOptions.DEFAULT);
            if (bulkResponse.hasFailures()) {
                for (BulkItemResponse item : bulkResponse.getItems()) {
                    System.out.println(">>>>>>upsertEs>>>error... msg=" + item.getFailureMessage());
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        int count = bulkRequest.numberOfActions();
        System.out.println(">>>>>>upsertEs>>>update success, count=" + count);
        return count;
    }
    //批量更新设置参数
    public static UpdateRequest getRequest(String index, String type, String id, String json) {
        UpdateRequest updateRequest = new UpdateRequest(index, type, id);
        //冲突重试设置
        updateRequest.retryOnConflict(3);
        //如果尚未存在，则表明必须将部分文档用作upsert文档
        updateRequest.docAsUpsert(true);
        //禁用noop检测
        updateRequest.detectNoop(false);
        //更新后是否获取_source
        updateRequest.fetchSource(true);
        //upsert
        updateRequest.upsert(json, XContentType.JSON);
        //指定doc
        updateRequest.doc(json, XContentType.JSON);
        return updateRequest;
    }
    //反射构建mapping
    private static XContentBuilder createMapping(Class clazz) {
        XContentBuilder mapping = null;
        try {
            mapping = XContentFactory.jsonBuilder().startObject()
                    .startObject("properties");
            Field[] fields = clazz.getDeclaredFields();
            for (Field field : fields) {
                if (field.getType().getTypeName().equals("java.lang.Long")) {
                    mapping.startObject(field.getName()).field("type", "long").endObject();
                } else if (field.getType().getTypeName().equals("java.lang.Integer") || field.getType().getTypeName().equals("int")) {
                    mapping.startObject(field.getName()).field("type", "integer").endObject();
                } else if (field.getType().getTypeName().equals("java.lang.Double")) {
                    mapping.startObject(field.getName()).field("type", "double").endObject();
                } else {
                    mapping.startObject(field.getName()).field("type", "keyword").endObject();
                }
            }
            mapping.endObject().endObject();
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println(">>>>>>createMapping>>>create mapping error:" + e.getMessage());
        }
        return mapping;
    }
    //拼装聚合条件
    private static void searchAgg(TermsAggregationBuilder termsBuilder, List groupFields,int count) {
        if (count < groupFields.size() - 1) {
            count ++;
            TermsAggregationBuilder termsBuilder1 = AggregationBuilders.terms(groupFields.get(count)).field(groupFields.get(count)).size(10000);
            termsBuilder.subAggregation(termsBuilder1);
            searchAgg(termsBuilder1, groupFields, count);
        }
    }
}



2.使用方法


@RequestMapping("/testQuery")
    public void list(HttpServletRequest request, HttpServletResponse response){
        System.out.println("测试查询ES数据");
        QueryRule rule = new QueryRule();
        rule.add(Restrictions.like("file_id", "123"))
                .add(Restrictions.ge("start_time","2021-04-01 00:00:24"))
                .add(Restrictions.le("start_time","2021-04-01 23:00:24"))
                .addOrder("start_time").orderDesc();
        EsBaseUtils.queryList("test", "type", rule);
    }



3.查询前置条件拼装


package cn.com.cewell.search.esBase;

import org.elasticsearch.search.sort.SortOrder;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class QueryRule {
    private int firstResult;
    private int maxResults;
    List criterions = new ArrayList<>();
    private List orderPropertyNames = new ArrayList<>();
    private SortOrder sortMode = SortOrder.ASC;

    public QueryRule add(QueryCriterion criterion) {
        criterions.add(criterion);
        return this;
    }

    public QueryRule clear(QueryCriterion criterion) {
        criterions.clear();
        firstResult = -1;
        maxResults = 0;
        return this;
    }

    public QueryRule addOrder(String ...name) {
        orderPropertyNames.addAll(Arrays.asList(name));
        return this;
    }

    public QueryRule orderDesc() {
        this.sortMode = SortOrder.DESC;
        return this;
    }

    public int getFirstResult() {
        return firstResult;
    }
    public QueryRule setFirstResult(int firstResult) {
        this.firstResult = firstResult;
        return this;
    }
    public int getMaxResults() {
        return maxResults;
    }
    public QueryRule setMaxResults(int maxResults) {
        this.maxResults = maxResults;
        return this;
    }
    public List getCriterions() {
        return criterions;
    }

    public List getOrderPropertyNames() {
        return orderPropertyNames;
    }

    public SortOrder getSortMode() {
        return sortMode;
    }
}




4.封装不同查询条件


package cn.com.cewell.search.esBase;

import java.util.Collection;

public class Restrictions {

    public static QueryCriterion eq(String propertyName, Object value) {
        return new SimpleExpression(propertyName, value, QueryCriterion.eq);
    }

    public static QueryCriterion eq(String propertyName, Object ...value) {
        return new ValuesExpression(propertyName, value);
    }

    public static QueryCriterion like(String propertyName, Object value) {
        return new SimpleExpression(propertyName, value, QueryCriterion.like);
    }

    public static QueryCriterion ne(String propertyName, Object value) {
        return new SimpleExpression(propertyName, value, QueryCriterion.ne);
    }

    public static QueryCriterion gt(String propertyName, Object value) {
        return new SimpleExpression(propertyName, value, QueryCriterion.gt);
    }

    public static QueryCriterion lt(String propertyName, Object value) {
        return new SimpleExpression(propertyName, value, QueryCriterion.lt);
    }

    public static QueryCriterion ge(String propertyName, Object value) {
        return new SimpleExpression(propertyName, value, QueryCriterion.ge);
    }

    public static QueryCriterion le(String propertyName, Object value) {
        return new SimpleExpression(propertyName, value, QueryCriterion.le);
    }

    public static QueryCriterion matchQuery(String propertyName, Object value) {
        return new SimpleExpression(propertyName, value, QueryCriterion.matchQuery);
    }

    public static QueryCriterion in(String propertyName, Collection values) {
        return new InExpression(propertyName, values);
    }

    public static QueryCriterion multipleFileds(String value, String ...propertyNames) {
        return new MultipleFieldExpression(value, propertyNames);
    }
}




5.常量


package cn.com.cewell.search.esBase;

import org.elasticsearch.index.query.QueryBuilder;

public abstract class QueryCriterion {

    public abstract QueryBuilder getBuilder();

    public static final String eq = "=";
    public static final String like = "like";
    public static final String ne = "<>";
    public static final String gt = ">";
    public static final String lt = "<";
    public static final String ge = ">=";
    public static final String le = "<=";
    public static final String matchQuery = "matchQuery";
}




6.查询条件拼接


package cn.com.cewell.search.esBase;

import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;

public class SimpleExpression extends QueryCriterion {

    private String propertyName;
    private Object value;
    private String op;

    public SimpleExpression(String propertyName, Object value, String op) {
        this.propertyName = propertyName;
        this.value = value;
        this.op = op;
    }

    public String getPropertyName() {
        return propertyName;
    }

    public Object getValue() {
        return value;
    }

    public String getOp() {
        return op;
    }

    @Override
    public QueryBuilder getBuilder() {
        QueryBuilder qb = null;
        switch (op) {
           case eq:
//                qb = QueryBuilders.termQuery(propertyName, value);
                //可能有多个值,此处的替换要根据实际数据格式调整
                qb = QueryBuilders.regexpQuery(propertyName, value.toString().replaceAll(",", "|"));
                break;
            case like:
//                qb = QueryBuilders.wildcardQuery(propertyName, "*"+value.toString()+"*");
                //可能会有多个值
                String[] split = value.toString().split(",");
                String fileVal = "";
                for (String s : split) {
                    fileVal+=".*"+s+".*|";
                }
                fileVal = fileVal.length() > 0 ? fileVal.substring(0, fileVal.length() - 1) : "";
                if (!"".equals(fileVal)){
                    qb = QueryBuilders.regexpQuery(propertyName,fileVal);
                }
                break;
            case ne:

                break;
            case gt:
                qb = QueryBuilders.rangeQuery(propertyName).gt(value);
                break;
            case lt:
                qb = QueryBuilders.rangeQuery(propertyName).lt(value);
                break;
            case ge:
                qb = QueryBuilders.rangeQuery(propertyName).gte(value);
                break;
            case le:
                qb = QueryBuilders.rangeQuery(propertyName).lte(value);
                break;
            case matchQuery:
                qb = QueryBuilders.matchQuery(propertyName, value);
                break;
        }
        return qb;
    }
}




7.不同查询条件拼接---一次匹配多个值


package cn.com.cewell.search.esBase;

import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;

public class ValuesExpression extends QueryCriterion {

    private String propertyName;
    private Object []values;

    public ValuesExpression(String propertyName, Object ...values) {
        this.propertyName = propertyName;
        this.values = values;
    }

    public void setPropertyName(String propertyName) {
        this.propertyName = propertyName;
    }

    public void setValues(Object[] values) {
        this.values = values;
    }

    @Override
    public QueryBuilder getBuilder() {
        return QueryBuilders.termsQuery(propertyName, values);
    }
}




8.不同查询条件拼接---一次匹配多个值


package cn.com.cewell.search.esBase;

import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;

import java.util.Collection;

public class InExpression extends QueryCriterion {

    private String propertyName;
    private Collection values;

    public InExpression(String propertyName, Collection values) {
        this.propertyName = propertyName;
        this.values = values;
    }

    public String getPropertyName() {
        return propertyName;
    }

    public Collection getValues() {
        return values;
    }

    @Override
    public QueryBuilder getBuilder() {
        return QueryBuilders.termsQuery(propertyName, values);
    }
}




9.不同查询条件拼接---多字段匹配


package cn.com.cewell.search.esBase;

import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;

public class MultipleFieldExpression extends QueryCriterion {

    private String []propertyName;
    private String value;

    public MultipleFieldExpression(String value, String ...propertyName) {
        this.propertyName = propertyName;
        this.value = value;
    }

    public String[] getPropertyName() {
        return propertyName;
    }

    public String getValue() {
        return value;
    }

    @Override
    public QueryBuilder getBuilder() {
        return QueryBuilders.multiMatchQuery(value, propertyName);
    }
}

























你可能感兴趣的:(ES封装工具类简单增删改查)






    

  • OC语言多界面传值五大方式
Magnetic_h
iosui学习objective-c开发语言

    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
    

    • 

  • C语言如何定义宏函数？
小九格物
c语言

    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
    

    • 

  • Long类型前后端数据不一致
igotyback
前端

    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    

    • 

  • mysql禁用远程登录
igotyback
mysql

    去mysql库中的user表里，将host都改成localhost之后刷新权限FLUSHPRIVILEGES;
    

    • 

  • 2021-08-26
影幽

    在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
    

    • 

  • 消息中间件有哪些常见类型
xmh-sxh-1314
java

    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
    

    • 

  • 每日一题——第八十四题
互联网打工人no1
C语言程序设计每日一练c语言

    题目：编写函数1、输入10个职工的姓名和职工号2、按照职工由大到小顺序排列，姓名顺序也随之调整3、要求输入一个职工号，用折半查找法找出该职工的姓名#define_CRT_SECURE_NO_WARNINGS#include#include#defineMAX_EMPLOYEES10typedefstruct{intid;charname[50];}Empolyee;voidinputEmploye
    

    • 

  • C#中使用split分割字符串
互联网打工人no1
c#

    1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
    

    • 

  • Python中os.environ基本介绍及使用方法
鹤冲天Pro
#Pythonpython服务器开发语言

    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
    

    • 

  • linux sdl windows.h,Windows下的SDL安装
奔跑吧linux内核
linuxsdlwindows.h

    首先你要下载并安装SDL开发包。如果装在C盘下，路径为C:\SDL1.2.5如果在WINDOWS下。你可以按以下步骤：1.打开VC++，点击"Tools",Options2,点击directories选项3.选择"Includefiles"增加一个新的路径。"C:\SDL1.2.5\include"4，现在选择"Libaryfiles“增加"C:\SDL1.2.5\lib"现在你可以开始编写你的第
    

    • 

  • Python教程：一文了解使用Python处理XPath
旦莫
Python进阶python开发语言

    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
    

    • 

  • python os.environ_python os.environ 读取和设置环境变量
weixin_39605414
pythonos.environ

    >>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
    

    • 

  • linux中sdl的使用教程,sdl使用入门
Melissa Corvinus
linux中sdl的使用教程

    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
    

    • 

  • 今天我破防了
sin信仰

    今天本来是大年初一，新年的第一天，应该是高高兴兴的一天，但是我怎么也高兴不起来。具体原因很简单，原本计划年后去县城找了一份会计的工作，被公公婆婆否定了，我心里立马就不舒服了，但是当时刚好肚子疼，我去了厕所，等我上完厕所，公公由于喝了酒还在那里和婆婆唠叨个没完。然后我就在心情极度压抑的情况下把午饭吃完的碗筷和锅给刷了。边刷碗筷和锅，边在那里难受，感觉自己在这个家里真的是过的憋屈死了，公婆不让我去上班
    

    • 

  • 关于提高复杂业务逻辑代码可读性的思考
编程经验分享
开发经验java数据库开发语言

    目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
    

    • 

  • SQL Server_查询某一数据库中的所有表的内容
qq_42772833
SQLServer数据库sqlserver

    1.查看所有表的表名要列出CrabFarmDB数据库中的所有表（名），可以使用以下SQL语句：USECrabFarmDB;--切换到目标数据库GOSELECTTABLE_NAMEFROMINFORMATION_SCHEMA.TABLESWHERETABLE_TYPE='BASETABLE';对这段SQL脚本的解释：SELECTTABLE_NAME：这个语句的作用是从查询结果中选择TABLE_NAM
    

    • 

  • 四章-32-点要素的聚合
彩云飘过

    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
    

    • 

  • Git常用命令－修改远程仓库地址
猿大师
LinuxJavagitjava

    查看远程仓库地址gitremote-v返回结果originhttps://git.coding.net/＊＊＊＊＊.git(fetch)originhttps://git.coding.net/＊＊＊＊＊.git(push)修改远程仓库地址gitremoteset-urloriginhttps://git.coding.net/＊＊＊＊＊.git先删除后增加远程仓库地址gitremotermori
    

    • 

  • 使用Faiss进行高效相似度搜索
llzwxh888
faisspython

    在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
    

    • 

  • 利用Requests Toolkit轻松完成HTTP请求
nseejrukjhad
http网络协议网络python

    RequestsToolkit的力量：轻松构建HTTP请求Agent在现代软件开发中，API请求是与外部服务交互的核心。RequestsToolkit提供了一种便捷的方式，帮助开发者构建自动化的HTTP请求Agent。本文旨在详细介绍RequestsToolkit的设置、使用和潜在挑战。引言RequestsToolkit是一个强大的工具包，可用于构建执行HTTP请求的智能代理。这对于想要自动化与外
    

    • 

  • GitHub上克隆项目
bigbig猩猩
github

    从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
    

    • 

  • Kafka 消息丢失如何处理？
架构文摘JGWZ
学习

    今天给大家分享一个在面试中经常遇到的问题：Kafka消息丢失该如何处理？这个问题啊，看似简单，其实里面藏着很多“套路”。来，咱们先讲一个面试的“真实”案例。面试官问：“Kafka消息丢失如何处理？”小明一听，反问：“你是怎么发现消息丢失了？”面试官顿时一愣，沉默了片刻后，可能有点不耐烦，说道：“这个你不用管，反正现在发现消息丢失了，你就说如何处理。”小明一头雾水：“问题是都不知道怎么丢的，处理起来
    

    • 

  • webpack图片等资源的处理
dmengmeng

    需要的loaderfile-loader（让我们可以引入这些资源文件）url-loader（其实是file-loader的二次封装）img-loader（处理图片所需要的）在没有使用任何处理图片的loader之前，比如说css中用到了背景图片，那么最后打包会报错的，因为他没办法处理图片。其实你只想能够使用图片的话。只加一个file-loader就可以，打开网页能准确看到图片。{test:/\.(p
    

    • 

  • Faiss Tips：高效向量搜索与聚类的利器
焦习娜Samantha

    FaissTips：高效向量搜索与聚类的利器faiss_tipsSomeusefultipsforfaiss项目地址:https://gitcode.com/gh_mirrors/fa/faiss_tips项目介绍Faiss是由FacebookAIResearch开发的一个用于高效相似性搜索和密集向量聚类的库。它支持多种硬件平台，包括CPU和GPU，能够在海量数据集上实现快速的近似最近邻搜索（AN
    

    • 

  • CX8903：Ebike自行车仪表电源方案开发,Ebike智能仪表电源芯片
诚芯微科技
社交电子

    CX8903：电动Ebike自行车仪表电源方案开发,Ebike智能仪表电源芯片推荐。电动助力自行车EBIKE凭借其环保、健康、低噪、和便捷等特点，成为了越来越受欢迎的骑行便利交通工具。提供电动Ebike自行车仪表电源方案开发、E-BIKE电动助力自行车仪表供电电源解决方案。CX8903采用100V高压制造工艺（芯片最高耐压可到100V以上），SOP-8L贴片封装，CX8903内置100V/90mΩ
    

    • 

  • 回溯算法-重新安排行程
chirou_
算法数据结构图论c++图搜索

    leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
    

    • 

  • 数据仓库——维度表一致性
墨染丶eye
背诵数据仓库

    数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
    

    • 

  • ARM驱动学习之基础小知识
JT灬新一
ARM嵌入式arm开发学习

    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
    

    • 

  • ARM驱动学习之5 LEDS驱动
JT灬新一
嵌入式C底层arm开发学习单片机

    ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
    

    • 

  • 基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作
GPJnCrbBdl
python开发语言

    基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
    

    • 

  • java封装继承多态等
麦田的设计者
javaeclipsejvmcencapsulatopn

           最近一段时间看了很多的视频却忘记总结了，现在只能想到什么写什么了，希望能起到一个回忆巩固的作用。
    1、final关键字
      译为：最终的
       &
    

    • 

  • F5与集群的区别
bijian1013
weblogic集群F5

            http请求配置不是通过集群，而是F5；集群是weblogic容器的，如果是ejb接口是通过集群。
        F5同集群的差别，主要还是会话复制的问题，F5一把是分发http请求用的，因为http都是无状态的服务，无需关注会话问题，类似
    

    • 

  • LeetCode[Math] - #7 Reverse Integer
Cwind
java题解MathLeetCodeAlgorithm

    原题链接：#7 Reverse Integer
 
要求：
按位反转输入的数字
例1： 输入 x = 123, 返回 321
例2： 输入 x = -123, 返回 -321
 
难度：简单
 
分析：
对于一般情况，首先保存输入数字的符号，然后每次取输入的末位（x%10）作为输出的高位（result = result*10 + x%10）即可。但
    

    • 

  • BufferedOutputStream
周凡杨

         首先说一下这个大批量，是指有上千万的数据量。
     例子：
     有一张短信历史表，其数据有上千万条数据，要进行数据备份到文本文件，就是执行如下SQL然后将结果集写入到文件中！
     select t.msisd
    

    • 

  • linux下模拟按键输入和鼠标
被触发
linux

    查看/dev/input/eventX是什么类型的事件， cat /proc/bus/input/devices
设备有着自己特殊的按键键码，我需要将一些标准的按键，比如0－9，X－Z等模拟成标准按键，比如KEY_0,KEY-Z等，所以需要用到按键 模拟，具体方法就是操作/dev/input/event1文件，向它写入个input_event结构体就可以模拟按键的输入了。
linux/in
    

    • 

  • ContentProvider初体验
肆无忌惮_
ContentProvider

    ContentProvider在安卓开发中非常重要。与Activity，Service，BroadcastReceiver并称安卓组件四大天王。
在android中的作用是用来对外共享数据。因为安卓程序的数据库文件存放在data/data/packagename里面，这里面的文件默认都是私有的，别的程序无法访问。
如果QQ游戏想访问手机QQ的帐号信息一键登录，那么就需要使用内容提供者COnte
    

    • 

  • 关于Spring MVC项目（maven）中通过fileupload上传文件
843977358
mybatisspring mvc修改头像上传文件upload

    Spring MVC 中通过fileupload上传文件，其中项目使用maven管理。
 
1.上传文件首先需要的是导入相关支持jar包：commons-fileupload.jar,commons-io.jar
因为我是用的maven管理项目，所以要在pom文件中配置（每个人的jar包位置根据实际情况定）
<!-- 文件上传 start by zhangyd-c --&g
    

    • 

  • 使用svnkit api，纯java操作svn，实现svn提交，更新等操作
aigo
svnkit

     原文：http://blog.csdn.net/hardwin/article/details/7963318
 
import java.io.File;
import org.apache.log4j.Logger;
import org.tmatesoft.svn.core.SVNCommitInfo;
import org.tmateso
    

    • 

  • 对比浏览器，casperjs，httpclient的Header信息
alleni123
爬虫crawlerheader

     @Override
protected void doGet(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException
{
String type=req.getParameter("type");
Enumeration es=re
    

    • 

  • java.io操作 DataInputStream和DataOutputStream基本数据流
百合不是茶
java流

    1，java中如果不保存整个对象，只保存类中的属性，那么我们可以使用本篇文章中的方法，如果要保存整个对象  先将类实例化  后面的文章将详细写到
 
 
2，DataInputStream 是java.io包中一个数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。
    

    • 

  • 车辆保险理赔案例
bijian1013
车险

    理赔案例：
一货运车，运输公司为车辆购买了机动车商业险和交强险，也买了安全生产责任险，运输一车烟花爆竹，在行驶途中发生爆炸，出现车毁、货损、司机亡、炸死一路人、炸毁一间民宅等惨剧，针对这几种情况，该如何赔付。
赔付建议和方案：
客户所买交强险在这里不起作用，因为交强险的赔付前提是：“机动车发生道路交通意外事故”；
如果是交通意外事故引发的爆炸，则优先适用交强险条款进行赔付，不足的部分由商业
    

    • 

  • 学习Spring必学的Java基础知识(5)—注解
bijian1013
javaspring

            文章来源：http://www.iteye.com/topic/1123823，整理在我的博客有两个目的：一个是原文确实很不错，通俗易懂，督促自已将博主的这一系列关于Spring文章都学完；另一个原因是为免原文被博主删除，在此记录，方便以后查找阅读。
 
        有必要对
    

    • 

  • 【Struts2一】Struts2 Hello World
bit1129
Hello world

    Struts2 Hello World应用的基本步骤
创建Struts2的Hello World应用，包括如下几步：
1.配置web.xml
2.创建Action
3.创建struts.xml，配置Action
4.启动web server，通过浏览器访问
  配置web.xml
<?xml version="1.0" encoding="
    

    • 

  • 【Avro二】Avro RPC框架
bit1129
rpc

    1. Avro RPC简介 1.1. RPC
RPC逻辑上分为二层，一是传输层，负责网络通信；二是协议层，将数据按照一定协议格式打包和解包
从序列化方式来看，Apache Thrift 和Google的Protocol Buffers和Avro应该是属于同一个级别的框架，都能跨语言，性能优秀，数据精简，但是Avro的动态模式（不用生成代码，而且性能很好）这个特点让人非常喜欢，比较适合R
    

    • 

  • lua　set get cookie
ronin47
lua cookie

    lua:
local access_token = ngx.var.cookie_SGAccessToken
if access_token then
ngx.header["Set-Cookie"] = "SGAccessToken="..access_token.."; path=/;Max-Age=3000"
end
    

    • 

  • java-打印不大于N的质数
bylijinnan
java

    
public class PrimeNumber {
/**
* 寻找不大于N的质数
*/
public static void main(String[] args) {
int n=100;
PrimeNumber pn=new PrimeNumber();
pn.printPrimeNumber(n);
System.out.print
    

    • 

  • Spring源码学习-PropertyPlaceholderHelper
bylijinnan
javaspring

    今天在看Spring 3.0.0.RELEASE的源码，发现PropertyPlaceholderHelper的一个bug
当时觉得奇怪，上网一搜，果然是个bug，不过早就有人发现了，且已经修复：
详见：
http://forum.spring.io/forum/spring-projects/container/88107-propertyplaceholderhelper-bug

    

    • 

  • [逻辑与拓扑]布尔逻辑与拓扑结构的结合会产生什么?
comsci
拓扑

    
   如果我们已经在一个工作流的节点中嵌入了可以进行逻辑推理的代码,那么成百上千个这样的节点如果组成一个拓扑网络,而这个网络是可以自动遍历的,非线性的拓扑计算模型和节点内部的布尔逻辑处理的结合,会产生什么样的结果呢?
   是否可以形成一种新的模糊语言识别和处理模型呢?  大家有兴趣可以试试,用软件搞这些有个好处,就是花钱比较少,就算不成
    

    • 

  • ITEYE 都换百度推广了
cuisuqiang
GoogleAdSense百度推广广告外快

    以前ITEYE的广告都是谷歌的Google AdSense，现在都换成百度推广了。
 
为什么个人博客设置里面还是Google AdSense呢？
 
都知道Google AdSense不好申请，这在ITEYE上也不是讨论了一两天了，强烈建议ITEYE换掉Google AdSense。至少，用一个好申请的吧。
 
什么时候能从ITEYE上来点外快，哪怕少点
    

    • 

  • 新浪微博技术架构分析
dalan_123
新浪微博架构

    新浪微博在短短一年时间内从零发展到五千万用户，我们的基层架构也发展了几个版本。第一版就是是非常快的，我们可以非常快的实现我们的模块。我们看一下技术特点，微博这个产品从架构上来分析，它需要解决的是发表和订阅的问题。我们第一版采用的是推的消息模式，假如说我们一个明星用户他有10万个粉丝，那就是说用户发表一条微博的时候，我们把这个微博消息攒成10万份，这样就是很简单了，第一版的架构实际上就是这两行字。第
    

    • 

  • 玩转ARP攻击
dcj3sjt126com
r

    我写这片文章只是想让你明白深刻理解某一协议的好处。高手免看。如果有人利用这片文章所做的一切事情，盖不负责。 网上关于ARP的资料已经很多了，就不用我都说了。 用某一位高手的话来说，“我们能做的事情很多，唯一受限制的是我们的创造力和想象力”。 ARP也是如此。 以下讨论的机子有 一个要攻击的机子：10.5.4.178 硬件地址：52:54:4C:98
    

    • 

  • PHP编码规范
dcj3sjt126com
编码规范

    一、文件格式
1. 对于只含有 php 代码的文件，我们将在文件结尾处忽略掉 "?>" 。这是为了防止多余的空格或者其它字符影响到代码。例如：<?php$foo = 'foo';2. 缩进应该能够反映出代码的逻辑结果，尽量使用四个空格，禁止使用制表符TAB，因为这样能够保证有跨客户端编程器软件的灵活性。例
    

    • 

  • linux 脱机管理（nohup）
eksliang
linux nohupnohup

    脱机管理 nohup
转载请出自出处：http://eksliang.iteye.com/blog/2166699
nohup可以让你在脱机或者注销系统后，还能够让工作继续进行。他的语法如下
nohup [命令与参数] --在终端机前台工作
nohup [命令与参数] & --在终端机后台工作
 
但是这个命令需要注意的是，nohup并不支持bash的内置命令，所
    

    • 

  • BusinessObjects Enterprise Java SDK
greemranqq
javaBOSAPCrystal Reports

    最近项目用到oracle_ADF  从SAP/BO 上调用 水晶报表，资料比较少，我做一个简单的分享，给和我一样的新手 提供更多的便利。
 
首先，我是尝试用JAVA JSP 去访问的。
 
官方API：http://devlibrary.businessobjects.com/BusinessObjectsxi/en/en/BOE_SDK/boesdk_ja
    

    • 

  • 系统负载剧变下的管控策略
iamzhongyong
高并发

    假如目前的系统有100台机器，能够支撑每天1亿的点击量（这个就简单比喻一下），然后系统流量剧变了要，我如何应对，系统有那些策略可以处理，这里总结了一下之前的一些做法。
1、水平扩展
这个最容易理解，加机器，这样的话对于系统刚刚开始的伸缩性设计要求比较高，能够非常灵活的添加机器，来应对流量的变化。
2、系统分组
假如系统服务的业务不同，有优先级高的，有优先级低的，那就让不同的业务调用提前分组
    

    • 

  • BitTorrent DHT 协议中文翻译
justjavac
bit

    前言
做了一个磁力链接和BT种子的搜索引擎 {Magnet & Torrent}，因此把 DHT 协议重新看了一遍。
BEP: 5Title: DHT ProtocolVersion: 3dec52cb3ae103ce22358e3894b31cad47a6f22bLast-Modified: Tue Apr 2 16:51:45 2013 -070
    

    • 

  • Ubuntu下Java环境的搭建
macroli
java工作ubuntu

    配置命令：
　　$sudo apt-get install ubuntu-restricted-extras
　　再运行如下命令：
　　$sudo apt-get install sun-java6-jdk
　　待安装完毕后选择默认Java.
　　$sudo update- alternatives --config java
　　安装过程提示选择，输入“2”即可，然后按回车键确定。 
    

    • 

  • js字符串转日期（兼容IE所有版本）
qiaolevip
TODateStringIE

     /**
* 字符串转时间（yyyy-MM-dd HH:mm:ss）
* result （分钟）
*/
stringToDate : function(fDate){
var fullDate = fDate.split(" ")[0].split("-");
var fullTime = fDate.split("
    

    • 

  • 【数据挖掘学习】关联规则算法Apriori的学习与SQL简单实现购物篮分析
superlxw1234
sql数据挖掘关联规则

    关联规则挖掘用于寻找给定数据集中项之间的有趣的关联或相关关系。
关联规则揭示了数据项间的未知的依赖关系，根据所挖掘的关联关系，可以从一个数据对象的信息来推断另一个数据对象的信息。
例如购物篮分析。牛奶 ⇒ 面包 [支持度：3%，置信度：40%] 支持度3%：意味3%顾客同时购买牛奶和面包。 置信度40%：意味购买牛奶的顾客40%也购买面包。 规则的支持度和置信度是两个规则兴
    

    • 

  • Spring 5.0 的系统需求，期待你的反馈
wiselyman
spring

           
       Spring 5.0将在2016年发布。Spring5.0将支持JDK 9。
 
       Spring 5.0的特性计划还在工作中，请保持关注，所以作者希望从使用者得到关于Spring 5.0系统需求方面的反馈。
 
    

    •