冯子玉
冯子玉

除了Mybatis,我们还能用什么访问数据库

目录

  • 为什么我很讨厌Mybatis？
  • 除了Mybatis，我们还能用什么
  • Spring-JDBC
  • 基于Spring-JDBC的实践
      • SQL组装工具
      • 分页插件
      • 基础查询层
      • 实例

为什么我很讨厌Mybatis？

  • 我很讨厌在XML里写SQL，每次接手一个用Mybatis开发的项目，需要调试或者修改SQL的时候都要多走一步，从dao层找对应的mapper文件，我觉得挺傻的，虽然现在mybtais可以基于全注解来开发，但是灵活性和SQL编写的舒适性都有很大程度下降
  • 很难调试，本地启动的情况下没法断点调试，需要开启打印SQL通过控制台来调试SQL
  • SQL真的很难写，这条是我个人的主观感受，虽然Mybatis提供了动态SQL的功能，但还是很难写，在XML里面要用到各种标签，加一个条件不光要在xml里面加，还需要跳到java代码

除了Mybatis，我们还能用什么

公司的项目没办法，统一和标准压过一切，现在阿里基本上用的都是mybatis或者更老的ibatis，个人只能服从组织安排。但在开发私人项目时其实可以有更多的选择，比如我个人做一些小demo或者小系统时都会用Spring-JDBC。

Spring-JDBC

Spring-JDBC是一个非常轻量级的数据库访问框架，基本上只有管理数据库连接（连接池配置），SQL执行等功能，但是它本身又非常灵活，提供了可以实现类似于JPA的数据映射扩展接口RowMapper，至少就我感觉，在 经过一定的封装之后，Spring-JDBC的使用体验比mybatis好很多，而且用Spring开发的web项目使用Spring-JDBC，听起来就很爽对吧

基于Spring-JDBC的实践

我个人是基于Spring-JDBC封装了一个二方包，集成了自动分页，分库分表，SQL组装等功能，接下来给大家做一个基本的介绍

SQL组装工具

其实很多人认为Mybatis的一个大优势就是可以写比较灵活的SQL，但这个优点其实只能在和SpringDataJPA或者hibernate这种JPA框架对比时才能成立，无论你在XML里面无论有多灵活，也不如直接在代码里写SQL来的灵活。但是写SQL，但是灵活只是一方面，更重要的是如何保证可读性，mybatis其实是兼顾了两者的，毕竟你在代码里哗哗写一大堆字符串拼接，碳基生物基本上都不太能看懂，我是开发了一个工具类SqlBuilder用于在代码中书写SQL

public final class SqlBuilder {
    private StringBuilder sqlBuilder;

    private LinkedList params;

    private SqlBuilder(String initSql) {
        this.sqlBuilder = new StringBuilder(initSql);
        this.params = new LinkedList<>();
    }

    public static SqlBuilder init(String str){
        return new SqlBuilder(str);
    }

    public String getSql(){
        return sqlBuilder.toString();
    }

    public Object[] getParamArray(){
        return params.toArray();
    }

    public SqlBuilder joinDirect(String sql, Object param){
        sqlBuilder.append(" ").append(sql);
        params.add(param);
        return this;
    }

    public SqlBuilder joinDirect(String sql){
        sqlBuilder.append(" ").append(sql);
        return this;
    }

    public SqlBuilder join(String sql, Object param){
        if(param != null){
            sqlBuilder.append(" ").append(sql);
            params.add(param);
        }
        return this;
    }

    public SqlBuilder joinLikeBefore(String sql, Object param){
        if(param != null){
            sqlBuilder.append(" ").append(sql).append(" like? ");
            params.add("%" + param);
        }
        return this;
    }

    public SqlBuilder joinLikeAfter(String sql, Object param){
        if(param != null){
            sqlBuilder.append(" ").append(sql).append(" like? ");
            params.add(param + "%");
        }
        return this;
    }
    public SqlBuilder joinLikeAround(String sql, Object param){
        if(param != null){
            sqlBuilder.append(" ").append(sql).append(" like? ");
            params.add("%" + param + "%");
        }
        return this;
    }

    public SqlBuilder joinIn(String sql, Object[] paramArray){
        if(paramArray.length > 0){
            sqlBuilder.append(" ").append(sql).append(" in(").append(StringUtil.getEmptyParams(paramArray.length)).append(")");
            params.addAll(Arrays.stream(paramArray).collect(Collectors.toList()));
        }
        return this;
    }

    public SqlBuilder joinIn(String sql, Collection paramArray){
        if(paramArray.size() > 0){
            sqlBuilder.append(" ").append(sql).append(" in(").append(StringUtil.getEmptyParams(paramArray.size())).append(")");
            params.addAll(paramArray);
        }
        return this;
    }
}
 
  
其实代码非常简单，两个成员变量，sqlBuilder用于保存用户的SQL，params用于保存用户的参数,同时提供了常用的SQL拼接工具方法，比如join方法会在传入参数不为空时拼接一个查询条件到SQL中，joinIn会拼接一个in查询条件，下面是一个使用例子
 
  
SqlBuilder sqlBuilder = SqlBuilder.init("select * from tb_book_flow");
sqlBuilder.joinDirect("where 1=1")
             .join("and id=?", condition.getId())
             .join("and book_name=?", condition.getBookName())
             .join("and status", condition.getStatus());

 
  
分页插件
 
  
实现分页插件一个核心的点是需要可扩展，即针对不同的的数据库类型要能做到适配（至少oracle和mysql的分页语句是不同的），我这里主要是基于接口和工厂模式来实现的，接口如下
 
  
/**
 * 分页插件
 */
public interface PaginationSupport {
    /**
     * 用于将指定SQL加工为带分页的SQL
     * @param sql
     * @param page
     * @param 
     * @return
     */
    public  String getPaginationSql(String sql, Page page);

    /**
     * 获取计数SQL
     * @param sql
     * @return
     */
    public String getCountSql(String sql);

    /**
     * 当前SQL插件是否支持指定数据库类型
     * @param dbType
     * @return
     */
    public boolean support(String dbType);
}

 
  
工厂类如下
 
  
public class PaginationSupportFactory {
    private static final Set paginationSupports = new HashSet<>();

    static {
        addPaginationSupport(new MysqlPaginationSupport());
    }

    public static void addPaginationSupport(PaginationSupport paginationSupport){
        paginationSupports.add(paginationSupport);
    }

    public static PaginationSupport getSuitableSupport(String dbType){
        return paginationSupports.stream()
                .filter(paginationSupport -> paginationSupport.support(dbType))
                .findAny()
                .orElseThrow(() -> new IllegalArgumentException("不支持的数据库类型:" + dbType));
    }
}

 
  
最后我们提供一个默认实现，Mysql的分页插件（代码是19年写的，当时我还没进入阿里，所以代码中其实存在一些违反阿里代码规约的地方，有人能找出来吗？
 
  
public class MysqlPaginationSupport implements PaginationSupport {
    @Override
    public  String getPaginationSql(String sql, Page page) {
        long startIndex = (page.getPageNo() - 1) * page.getPageSize();
        long endIndex = startIndex + page.getPageSize();
        StringBuilder sqlBuilder = new StringBuilder(sql);
        if(!StringUtil.isEmpty(page.getSortBy())){
            sqlBuilder.append(" ORDER BY ").append(page.getSortBy()).append(page.getRank());
        }
        sqlBuilder.append(" limit ").append(startIndex).append(",").append(endIndex);
        return sqlBuilder.toString().toLowerCase();
    }

    @Override
    public String getCountSql(String sql) {
        return ("SELECT COUNT(*) FROM (" + sql + ") A").toLowerCase();
    }

    @Override
    public boolean support(String dbType) {
        return dbType.equalsIgnoreCase("MYSQL");
    }
}

 
  
基础查询层
 
  
前面说过，Spring-JDBC是一个非常轻量级的框架，本身提供的功能很少，为了能更舒服的做数据库开发，我做了一个基础的查询类，提供了一些类似JPA的数据映射能力
 
  
@Validated
public abstract class BaseDao{

    @Autowired
    protected JdbcTemplate jdbcTemplate;

    private String dbType;

    /**
     * 分页查询
     * @param page
     * @param modelClass
     * @param sql
     * @param args
     * @param 
     * @return
     */
    public  Page queryForPaginationBean(@NotNull Page page, @NotNull Class modelClass, @NotBlank String sql, @NotNull Object[] args){
        PaginationSupport paginationSupport = null;
        try {
            paginationSupport = getSuitablePaginationSupport();
        } catch (SQLException e) {
            throw new UnsupportedOperationException(e);
        }
        int total = this.count(paginationSupport.getCountSql(sql), args);
        page.setTotal(total);
        List data = this.jdbcTemplate.query(paginationSupport.getPaginationSql(sql, page), new BeanPropertyRowMapper<>(modelClass), args);
        page.setData(data);
        return page;
    }

    /**
     * 分页查询
     * @param page
     * @param modelClass
     * @param sqlBuilder
     * @param 
     * @return
     */
    public  Page queryForPaginationBean(@NotNull Page page, @NotNull Class modelClass, @NotNull SqlBuilder sqlBuilder){
        return queryForPaginationBean(page, modelClass, sqlBuilder.getSql(), sqlBuilder.getParamArray());
    }

    /**
     * 快速查询全部
     * @param modelClass
     * @param sql
     * @param args
     * @param 
     * @return
     */
    public  List queryForAllBean(@NotNull Class modelClass, @NotBlank String sql, @NotNull Object[] args){
        return this.jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(modelClass), args);
    }

    /**
     * 快速查询全部
     * @param modelClass
     * @param sqlBuilder
     * @param 
     * @return
     */
    public  List queryForAllBean(@NotNull Class modelClass, @NotNull SqlBuilder sqlBuilder){
        return this.queryForAllBean(modelClass, sqlBuilder.getSql(), sqlBuilder.getParamArray());
    }

    /**
     * 快速查询首个Bean
     * @param modelClass
     * @param sql
     * @param args
     * @param 
     * @return
     */
    public  Optional findFirstBean(@NotNull Class modelClass, @NotBlank String sql, @NotNull Object[] args){
        T t;
        try {
            t = this.jdbcTemplate.queryForObject(sql, BeanPropertyRowMapper.newInstance(modelClass), args);
        }catch (EmptyResultDataAccessException e){
            t = null;
        }
        return Optional.ofNullable(t);
    }
    public  Optional findFirstBean(Class modelClass, SqlBuilder sqlBuilder){
        return findFirstBean(modelClass, sqlBuilder.getSql(), sqlBuilder.getParamArray());
    }

    /**
     * 快速分页查询Map
     * @param page
     * @param sql
     * @param args
     * @return
     */
    public Page> queryForPaginationMap(@NotNull Page> page, @NotBlank String sql, @NotNull Object[] args) {
        PaginationSupport paginationSupport = null;
        try {
            paginationSupport = getSuitablePaginationSupport();
        } catch (SQLException e) {
            throw new UnsupportedOperationException(e);
        }
        int total = this.count(paginationSupport.getCountSql(sql), args);
        page.setTotal(total);
        List> data = this.jdbcTemplate.queryForList(paginationSupport.getPaginationSql(sql, page), args);
        page.setData(data);
        return page;
    }

    /**
     * 根据SqlBuilder快速分页查询接口
     * @param page
     * @param sqlBuilder
     * @return
     */
    public Page> queryForPaginationMap(@NotNull Page> page, @NotNull SqlBuilder sqlBuilder){
        return queryForPaginationMap(page, sqlBuilder.getSql(), sqlBuilder.getParamArray());
    }

    /**
     * 根据SqlBuilder快速更新
     * @param sqlBuilder
     * @return
     */
    public int update(@NotNull SqlBuilder sqlBuilder){
        return this.update(sqlBuilder.getSql(), sqlBuilder.getParamArray());
    }

    /**
     * 根据SQL进行更新
     * @param sql
     * @param args
     * @return
     */
    public int update(@NotBlank String sql, @NotNull Object[] args){
        return jdbcTemplate.update(sql, args);
    }

    /**
     * 快速更新javabean对象
     * @param column 数据库字段名称
     * @param bean
     * @param table
     * @param 
     * @return
     */
    public  int updateBean(@NotBlank String column, @NotNull T bean, @NotBlank String table){
        Map parameterMap = BeanUtils.transBeanToMapWithUnderScore(bean);
        Object selectValue = parameterMap.remove(column);

        List params = new ArrayList<>(parameterMap.values());
        params.add(selectValue);
        String sql = getUpdateSql(parameterMap, table, column);
        return this.jdbcTemplate.update(sql, params.toArray());
    }

    /**
     * 快速根据ID进行修改
     * @param bean
     * @param table
     * @param 
     * @return
     */
    public  int updateById(@NotNull T bean, String table){
        return updateBean("id", bean, table);
    }

    /**
     * 快速根据字段删除
     * @param column
     * @param value
     * @param table
     * @return
     */
    public int remove(@NotBlank String column, @NotNull Object value, @NotBlank String table){
        String sql = "delete from " + table + " where " + column + " =?";
        return this.jdbcTemplate.update(sql, value);
    }

    /**
     * 快速根据字段批量删除
     * @param column
     * @param valueArray
     * @param table
     * @return
     */
    public int remove(@NotBlank String column, @NotEmpty Object[] valueArray, @NotBlank String table){
        String sql = "delete from " + table + " where " + column + " in(" + StringUtil.getEmptyParams(valueArray.length) + ")";
        return this.jdbcTemplate.update(sql, valueArray);
    }

    /**
     * 快速根据ID删除
     * @param id
     * @param table
     * @return
     */
    public int removeById(@NotNull Object id, @NotBlank String table){
        return remove("id", id, table);
    }

    /**
     * 快速根据ID批量删除
     * @param array
     * @param table
     * @return
     */
    public int removeByIdArray(@NotEmpty Object[] array, @NotBlank String table){
        return remove("id", array, table);
    }
    /**
     * 保存单个对象
     * @param bean
     * @param table
     * @param 
     */
    public  void saveBean(T bean, String table){
        Map parameterMap = BeanUtils.transBeanToMapWithUnderScore(bean);
        String sql = this.getSaveSql(parameterMap, table);
        this.jdbcTemplate.update(sql, parameterMap.values().toArray());
    }

    /**
     * 批量保存javaBean对象,使用NoConvertField标注的字段不会保存
     * @param beans
     * @param table
     * @param 
     */
    public  void saveBeanList(List beans, String table){
        if(beans.size() <= 0){
            return;
        }
        String sql = null;
        List batchArgs = new LinkedList<>();
        for(T bean : beans) {
            Map beanPropertyMap = BeanUtils.transBeanToMapWithUnderScore(bean);
            if (sql == null) {
                sql = getSaveSql(beanPropertyMap, table);
            }
            batchArgs.add(beanPropertyMap.values().toArray());
        }
        this.jdbcTemplate.batchUpdate(sql, batchArgs);
    }

    /**
     * 快速根据主健ID(id)进行单条记录查询
     * @param id
     * @param modelClass
     * @param table
     * @param 
     * @return
     */
    public  Optional findById(Integer id, Class modelClass, String table){
        return findBy("id", modelClass, table, id);
    }

    /**
     * 根据数据库表指定的一个字段进行单条记录查询
     * @param key
     * @param modelClass
     * @param table
     * @param value
     * @param 
     * @return
     */
    public  Optional findBy(String key, Class modelClass, String table, Object value){
        T t;
        try {
            t = this.jdbcTemplate.queryForObject("select * from " + table + " where " + key + "=?", BeanPropertyRowMapper.newInstance(modelClass), value);
        }catch (EmptyResultDataAccessException e){
            t = null;
        }
        return Optional.ofNullable(t);
    }

    /**
     * 根据占位符sql和入参进行计数
     * @param sql
     * @param args
     * @return
     */
    public Integer count(String sql, Object[] args){
        return this.jdbcTemplate.queryForObject(sql, Integer.class, args);
    }

    /**
     * 根据SQLBuilder进行计数
     * @param sqlBuilder
     * @return
     */
    public Integer count(SqlBuilder sqlBuilder){
        AssertUtil.assertNotNull(sqlBuilder, "count sqlBuilder cannot be null");
        return this.jdbcTemplate.queryForObject(sqlBuilder.getSql(), Integer.class, sqlBuilder.getParamArray());
    }

    /**
     * 简单执行SQL并计数
     * @param sql
     * @return
     */
    public Integer count(String sql){
        return this.jdbcTemplate.queryForObject(sql, Integer.class);
    }

    /**
     * 获取当前适用的分页插件
     * @return
     * @throws SQLException
     */
    private PaginationSupport getSuitablePaginationSupport() throws SQLException {
        try {
            return PaginationSupportFactory.getSuitableSupport(this.getCurrentDbType());
        } catch (SQLException e) {
            throw new SQLException("数据库分页查询失败,无法获取当前数据库类型:" + jdbcTemplate.getDataSource(), e);
        }
    }

    /**
     * 获取当前数据库类型
     * @return
     * @throws SQLException
     */
    private String getCurrentDbType() throws SQLException {
        if(StringUtil.isNotEmpty(dbType)){
            return dbType;
        }
        synchronized (this){
            dbType = this.jdbcTemplate.execute((ConnectionCallback) connection ->
                    connection.getMetaData().getDatabaseProductName());
        }
        return dbType;
    }

    /**
     * 获取更新bean的SQL
     * @param beanPropertyMap
     * @param table
     * @param column
     * @return
     */
    private String getUpdateSql(Map beanPropertyMap, String table, String column){
        AssertUtil.assertTrue(beanPropertyMap.containsKey(column), String.format("column:%s not exist in bean", column));
        StringBuilder updateSqlBuilder = new StringBuilder("UPDATE ").append(table);
        boolean isFirstParam = true;
        for(String key : beanPropertyMap.keySet()){
            if(key.equals(column)){
                continue;
            }
            if (isFirstParam) {
                updateSqlBuilder.append(" SET ");
                isFirstParam = false;
            } else {
                updateSqlBuilder.append(",");
            }
            updateSqlBuilder.append(key).append("=").append("?");
        }
        updateSqlBuilder.append(" WHERE ").append(column).append("=?");
        return updateSqlBuilder.toString();
    }

    /**
     * 生成保存bean的SQL
     * @param beanPropertyMap
     * @param table
     * @return
     */
    private String getSaveSql(Map beanPropertyMap, String table){
        return "INSERT INTO " +
                table +
                "(" +
                StringUtil.join(new ArrayList<>(beanPropertyMap.keySet()), ",") +
                ")" +
                "VALUES" +
                "(" +
                StringUtil.getEmptyParams(beanPropertyMap.size()) +
                ")";
    }
}
 
  
有一个非常重要的点是在做分页查询时我们需要获取当前连接的数据库类型（不同的数据库类型分页语句是不同的），我一开始是直接调的DataSource的getConnection方法，结果发现每次做一次分页查询都会建立一个连接，查询几次之后数据库连接都超时了，我仔细看了看文档才发现这个方法不是获取已有的数据库连接而是开启一个新连接，修改之后问题才解决
 
  
其实到这一步为止，从易用性上讲我认为已经超过Mybatis了，基于这套封装的框架，我们既可以实现类似于JPA框架一样的快速基于JavaBean开发，也可以基于灵活的SQL进行开发，但有个点其实不够优雅，就是在实现类似JPA的操作时候我们需要传表名，所以我加了一个注解和一个扩展查询类，用于实现表的内聚
 
  
@Retention(RetentionPolicy.RUNTIME)
public @interface DaoMapping {
    //逻辑表
    String logicTable();
    //是否开启分库分表
    boolean sharding() default false;
    //用户分库分表的字段
    String shardingColumn() default "id";
    //可映射的表,若为default,映射到逻辑表
    String actualTable() default "default";
    //可映射的数据源,若为default,映射到主数据源
    String actualDataSource() default "default";
    //分表算法
    Class tablePreciseShardingAlgorithm() default ModShardingAlgorithm.class;
    //分表算法
    Class tableRangeShardingAlgorithm() default ModShardingAlgorithm.class;
    //分库算法
    Class dbPreciseShardingAlgorithm() default DefaultShardingAlgorithm.class;
    //分库算法
    Class dbRangeShardingAlgorithm() default DefaultShardingAlgorithm.class;
}

 
  
如图，DaoMapping是一个用于标识数据库表映射的注解，它有几个功能，标识当前Dao要操作的数据表，实现分库分表（这个功能下期有时间再说），在扩展查询类中，我们会获取当前类上的注解并注入表名，实现更方便的查询
 
  
@Validated
public abstract class BaseMappingDao extends BaseDao{

    /**
     * 快速根据ID查询
     * @param id
     * @param modelClass 返回值类型
     * @param 
     * @return
     */
    public  Optional findById(@NotNull Integer id, @NotNull Class modelClass){
        return this.findById(id, modelClass, this.getTable());
    }

    /**
     * 快速根据单个字段查询
     * @param key 字段名称
     * @param value 字段值
     * @param modelClass 返回值类型
     * @param 
     * @return
     */
    public  Optional findBy(@NotBlank String key, @NotNull Object value, @NotNull Class modelClass){
        return this.findBy(key, modelClass, this.getTable(), value);
    }

    /**
     * 快速根据单个字段更新bean
     * @param column
     * @param bean
     * @param 
     * @return
     */
    public  int updateBean(@NotBlank String column, @ NotNull T bean){
        return this.updateBean(column, bean, this.getTable());
    }

    /**
     * 快速根据ID更新数据库
     * @param bean 必须包含id字段
     * @param 
     * @return
     */
    public  int updateById(@NotNull T bean){
        return this.updateById(bean, this.getTable());
    }

    public  void saveBean(@NotNull T bean){
        this.saveBean(bean, getTable());
    }

    public  void saveBeanList(@NotEmpty List beanList){
        this.saveBeanList(beanList, getTable());
    }

    public void removeBy(@NotBlank String column, @NotNull Object value){
        this.remove(column, value, this.getTable());
    }

    public void removeById(@NotNull Object value){
        this.removeBy("id", value);
    }

    public Optional getThisDaoMapping(){
        return Optional.ofNullable(this.getClass().getAnnotation(DaoMapping.class));
    }

    public String getTable(){
        return getThisDaoMapping().map(DaoMapping::logicTable).orElseThrow(() -> new UnsupportedOperationException("缺少DaoMapping注解的类不支持该类查询"));
    }
}

 
  
实例
 
  
用参加百技时我们项目实战的代码举个例子
 
  
@Component
@DaoMapping(logicTable = "tb_book_flow")
public class BookDao extends BaseMappingDao {

    public List findAllBook(){
        SqlBuilder sqlBuilder = SqlBuilder.init("select * from tb_book_flow");
        return queryForAllBean(Book.class, sqlBuilder);
    }

    public Page queryForPage(BookQueryCondition condition, Page page){
        SqlBuilder sqlBuilder = SqlBuilder.init("select * from tb_book_flow");
        sqlBuilder.joinDirect("where 1=1")
                .join("and id=?", condition.getId())
                .join("and book_name=?", condition.getBookName())
                .join("and status=?", condition.getStatus());

        return queryForPaginationBean(page, Book.class, sqlBuilder);
    }

    public void insertBook(Book book){
        saveBean(book);
    }

    public void updateBook(Book book) {
        updateBook(book);
    }
}

 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(数据库,spring,java)

        

            

                
    
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • Google earth studio 简介
                        陟彼高冈yu
旅游
                        
    GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
    
                    
    • 
                    
  • 关于提高复杂业务逻辑代码可读性的思考
                        编程经验分享
开发经验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
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具
                        nseejrukjhad
数据库python
                        
    深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • MongoDB Oplog 窗口
                        喝醉酒的小白
MongoDB运维
                        
    在MongoDB中，oplog（操作日志）是一个特殊的日志系统，用于记录对数据库的所有写操作。oplog允许副本集成员（通常是从节点）应用主节点上已经执行的操作，从而保持数据的一致性。它是MongoDB副本集实现数据复制的基础。MongoDBOplog窗口oplog窗口是指在MongoDB副本集中，从节点可以用来同步数据的时间范围。这个窗口通常由以下因素决定：Oplog大小：oplog的大小是有限
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • python os 环境变量
                        CV矿工
python开发语言numpy
                        
    环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
    
                    
    • 
                    
  • 【PG】常见数据库、表属性设置
                        江无羡
数据库
                        
    PG的常见属性配置方法数据库复制、备份相关表的复制标识单表操作批量表操作链接数据库复制、备份相关表的复制标识单表操作通过ALTER语句单独更改一张表的复制标识。ALTERTABLE[tablename]REPLICAIDENTITYFULL;批量表操作通过代码块的方式，对某个schema中的所有表一起更新其复制标识。SELECTtablename,CASErelreplidentWHEN'd'TH
    
                    
    • 
                    
  • nosql数据库技术与应用知识点
                        皆过客，揽星河
NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
                        
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
    
                    
    • 
                    
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
                        文章永久免费只为良心
oracle数据库
                        
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    
                    
    • 
                    
  • insert into select 主键自增_mybatis拦截器实现主键自动生成
                        weixin_39521651
insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
                        
    前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 关于Mysql 中 Row size too large (＞ 8126) 错误的解决和理解
                        秋刀prince
mysqlmysql数据库
                        
    提示：啰嗦一嘴，数据库的任何操作和验证前，一定要记得先备份！！！不会有错；文章目录问题发现一、问题导致的可能原因1、页大小2、行格式2.1compact格式2.2Redundant格式2.3Dynamic格式2.4Compressed格式3、BLOB和TEXT列二、解决办法1、修改页大小（不推荐）2、修改行格式3、修改数据类型为BLOB和TEXT列4、其他优化方式（可以参考使用）4.1合理设置数据
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • spring如何整合druid连接池？
                        惜.己
springspringjunit数据库javaidea后端xml
                        
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                                
  • LeetCode[位运算] - #137 Single Number II
                                    Cwind
javaAlgorithmLeetCode题解位运算
                                    
    原题链接：#137 Single Number II  
要求： 
给定一个整型数组，其中除了一个元素之外，每个元素都出现三次。找出这个元素 
注意：算法的时间复杂度应为O(n)，最好不使用额外的内存空间 
  
难度：中等 
  
分析： 
与#136类似，都是考察位运算。不过出现两次的可以使用异或运算的特性 n XOR n = 0, n XOR 0 = n，即某一
    
                                
    • 
                                
  • 《JavaScript语言精粹》笔记
                                    aijuans
JavaScript
                                    
    0、JavaScript的简单数据类型包括数字、字符创、布尔值（true/false）、null和undefined值，其它值都是对象。 
1、JavaScript只有一个数字类型，它在内部被表示为64位的浮点数。没有分离出整数，所以1和1.0的值相同。 
2、NaN是一个数值，表示一个不能产生正常结果的运算结果。NaN不等于任何值，包括它本身。可以用函数isNaN(number)检测NaN,但是
    
                                
    • 
                                
  • 你应该更新的Java知识之常用程序库
                                    Kai_Ge
java
                                    
    在很多人眼中，Java 已经是一门垂垂老矣的语言，但并不妨碍 Java 世界依然在前进。如果你曾离开 Java，云游于其它世界，或是每日只在遗留代码中挣扎，或许是时候抬起头，看看老 Java 中的新东西。 
Guava 
Guava[gwɑ:və]，一句话，只要你做Java项目，就应该用Guava（Github）。 
guava 是 Google 出品的一套 Java 核心库，在我看来，它甚至应该
    
                                
    • 
                                
  • HttpClient
                                    120153216
httpclient
                                    
    /**
 * 可以传对象的请求转发，对象已流形式放入HTTP中
 */
public static Object doPost(Map<String,Object> parmMap,String url)
	{
		Object object = null;
		HttpClient hc = new HttpClient();
		
		String fullURL 
    
                                
    • 
                                
  • Django model字段类型清单
                                    2002wmj
django
                                    
    Django 通过 models 实现数据库的创建、修改、删除等操作，本文为模型中一般常用的类型的清单，便于查询和使用： AutoField：一个自动递增的整型字段，添加记录时它会自动增长。你通常不需要直接使用这个字段；如果你不指定主键的话，系统会自动添加一个主键字段到你的model。(参阅自动主键字段)  BooleanField：布尔字段,管理工具里会自动将其描述为checkbox。  Cha
    
                                
    • 
                                
  • 在SQLSERVER中查找消耗CPU最多的SQL
                                    357029540
SQL Server
                                    
    返回消耗CPU数目最多的10条语句 
 
SELECT TOP 10 
   total_worker_time/execution_count AS avg_cpu_cost, plan_handle, 
   execution_count, 
   (SELECT SUBSTRING(text, statement_start_of
    
                                
    • 
                                
  • Myeclipse项目无法部署，Undefined exploded archive location
                                    7454103
eclipseMyEclipse
                                    
    做个备忘！ 
 
错误信息为： 
      Undefined exploded archive location 
 
 
原因： 
          在工程转移过程中，导致工程的配置文件出错； 
 
 
解决方法： 
   
    
                                
    • 
                                
  • GMT时间格式转换
                                    adminjun
GMT时间转换
                                    
    普通的时间转换问题我这里就不再罗嗦了，我想大家应该都会那种低级的转换问题吧，现在我向大家总结一下如何转换GMT时间格式，这种格式的转换方法网上还不是很多，所以有必要总结一下，也算给有需要的朋友一个小小的帮助啦。 
1、可以使用 
SimpleDateFormat SimpleDateFormat    
EEE-三位星期 
d-天 
MMM-月 
yyyy-四位年 

    
                                
    • 
                                
  • Oracle数据库新装连接串问题
                                    aijuans
oracle数据库
                                    
    割接新装了数据库，客户端登陆无问题，apache/cgi-bin程序有问题，sqlnet.log日志如下： 
Fatal NI connect error 12170. 
  VERSION INFORMATION:         TNS for Linux: Version 10.2.0.4.0 - Product
    
                                
    • 
                                
  • 回顾java数组复制
                                    ayaoxinchao
java数组
                                    
    在写这篇文章之前，也看了一些别人写的，基本上都是大同小异。文章是对java数组复制基础知识的回顾，算是作为学习笔记，供以后自己翻阅。首先，简单想一下这个问题：为什么要复制数组？我的个人理解：在我们在利用一个数组时，在每一次使用，我们都希望它的值是初始值。这时我们就要对数组进行复制，以达到原始数组值的安全性。java数组复制大致分为3种方式：①for循环方式 ②clone方式 ③arrayCopy方
    
                                
    • 
                                
  • java web会话监听并使用spring注入
                                    bewithme
Java Web
                                    
      
      在java web应用中，当你想在建立会话或移除会话时，让系统做某些事情，比如说，统计在线用户，每当有用户登录时，或退出时，那么可以用下面这个监听器来监听。 
       
import java.util.ArrayList;
import java.ut
    
                                
    • 
                                
  • NoSQL数据库之Redis数据库管理(Redis的常用命令及高级应用)
                                    bijian1013
redis数据库NoSQL
                                    
    一 .Redis常用命令 
        Redis提供了丰富的命令对数据库和各种数据库类型进行操作，这些命令可以在Linux终端使用。 
        a.键值相关命令 
        b.服务器相关命令 
1.键值相关命令 
      &
    
                                
    • 
                                
  • java枚举序列化问题
                                    bingyingao
java枚举序列化
                                    
    对象在网络中传输离不开序列化和反序列化。而如果序列化的对象中有枚举值就要特别注意一些发布兼容问题: 
 
 
1.加一个枚举值 
新机器代码读分布式缓存中老对象，没有问题，不会抛异常。 
 
老机器代码读分布式缓存中新对像，反序列化会中断，所以在所有机器发布完成之前要避免出现新对象，或者提前让老机器拥有新增枚举的jar。 
 
 
 
  2.删一个枚举值 
新机器代码读分布式缓存中老对象，反序列
    
                                
    • 
                                
  • 【Spark七十八】Spark Kyro序列化
                                    bit1129
spark
                                    
    当使用SparkContext的saveAsObjectFile方法将对象序列化到文件，以及通过objectFile方法将对象从文件反序列出来的时候，Spark默认使用Java的序列化以及反序列化机制，通常情况下，这种序列化机制是很低效的，Spark支持使用Kyro作为对象的序列化和反序列化机制，序列化的速度比java更快，但是使用Kyro时要注意，Kyro目前还是有些bug。 
 
 Spark
    
                                
    • 
                                
  • Hybridizing OO and Functional Design
                                    bookjovi
erlanghaskell
                                    
      推荐博文：
Tell Above, and Ask Below - Hybridizing OO and Functional Design  
文章中把OO和FP讲的深入透彻，里面把smalltalk和haskell作为典型的两种编程范式代表语言，此点本人极为同意，smalltalk可以说是最能体现OO设计的面向对象语言，smalltalk的作者Alan kay也是OO的最早先驱，
    
                                
    • 
                                
  • Java-Collections Framework学习与总结-HashMap
                                    BrokenDreams
Collections
                                    
            开发中常常会用到这样一种数据结构，根据一个关键字，找到所需的信息。这个过程有点像查字典，拿到一个key，去字典表中查找对应的value。Java1.0版本提供了这样的类java.util.Dictionary(抽象类)，基本上支持字典表的操作。后来引入了Map接口，更好的描述的这种数据结构。 
 &nb
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-职责链模式-Chain Of Responsibility
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 
 
 




/**
 * 业务逻辑：项目经理只能处理500以下的费用申请，部门经理是1000，总经理不设限。简单起见，只同意“Tom”的申请
 * bylijinnan
 */
abstract class Handler {
	/* 
    
                                
    • 
                                
  • Android中启动外部程序
                                    cherishLC
android
                                    
    1、启动外部程序 
引用自： 
http://blog.csdn.net/linxcool/article/details/7692374 
 
//方法一
Intent intent=new Intent();
//包名 包名+类名（全路径）
intent.setClassName("com.linxcool", "com.linxcool.PlaneActi
    
                                
    • 
                                
  • summary_keep_rate
                                    coollyj
SUM
                                    
    
BEGIN  
      /*DECLARE  minDate varchar(20) ;
      DECLARE  maxDate varchar(20) ;*/
      DECLARE  stkDate varchar(20) ;

      DECLARE done int default -1; 
			/* 游标中 注册服务器地址 */  
      DE
    
                                
    • 
                                
  • hadoop hdfs 添加数据目录出错
                                    daizj
hadoophdfs扩容
                                    
    由于原来配置的hadoop data目录快要用满了，故准备修改配置文件增加数据目录，以便扩容，但由于疏忽，把core-site.xml, hdfs-site.xml配置文件dfs.datanode.data.dir 配置项增加了配置目录，但未创建实际目录，重启datanode服务时，报如下错误： 
 
2014-11-18 08:51:39,128 WARN org.apache.hadoop.h
    
                                
    • 
                                
  • grep 目录级联查找
                                    dongwei_6688
grep
                                    
           在Mac或者Linux下使用grep进行文件内容查找时，如果给定的目标搜索路径是当前目录，那么它默认只搜索当前目录下的文件，而不会搜索其下面子目录中的文件内容，如果想级联搜索下级目录，需要使用一个“-r”参数： 
grep -n -r "GET" . 
  
上面的命令将会找出当前目录“.”及当前目录中所有下级目录
    
                                
    • 
                                
  • yii 修改模块使用的布局文件
                                    dcj3sjt126com
yiilayouts
                                    
    方法一：yii模块默认使用系统当前的主题布局文件，如果在主配置文件中配置了主题比如:  'theme'=>'mythm',   那么yii的模块就使用 protected/themes/mythm/views/layouts 下的布局文件；   如果未配置主题，那么 yii的模块就使用  protected/views/layouts 下的布局文件， 总之默认不是使用自身目录 pr
    
                                
    • 
                                
  • 设计模式之单例模式
                                    come_for_dream
设计模式单例模式懒汉式饿汉式双重检验锁失败无序写入
                                    
                    今天该来的面试还没来，这个店估计不会来电话了，安静下来写写博客也不错，没事翻了翻小易哥的博客甚至与大牛们之间的差距，基础知识不扎实建起来的楼再高也只能是危楼罢了，陈下心回归基础把以前学过的东西总结一下。 
  
*********************************
    
                                
    • 
                                
  • 8、数组
                                    豆豆咖啡
二维数组数组一维数组
                                    
      
一、概念 
  
    数组是同一种类型数据的集合。其实数组就是一个容器。 
  
二、好处 
  
    可以自动给数组中的元素从0开始编号，方便操作这些元素 
  
三、格式 
  
//一维数组
1,元素类型[] 变量名 = new 元素类型[元素的个数]
int[] arr =
    
                                
    • 
                                
  • Decode Ways
                                    hcx2013
decode
                                    
    A message containing letters from A-Z is being encoded to numbers using the following mapping: 
'A' -> 1
'B' -> 2
...
'Z' -> 26
 
Given an encoded message containing digits, det
    
                                
    • 
                                
  • Spring4.1新特性——异步调度和事件机制的异常处理
                                    jinnianshilongnian
spring 4.1
                                    
    目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
    
                                
    • 
                                
  • squid3(高命中率)缓存服务器配置
                                    liyonghui160com

                                    
      
  
系统:centos 5.x 
  需要的软件:squid-3.0.STABLE25.tar.gz 
1.下载squid 
wget http://www.squid-cache.org/Versions/v3/3.0/squid-3.0.STABLE25.tar.gz 
tar zxf squid-3.0.STABLE25.tar.gz &&
    
                                
    • 
                                
  • 避免Java应用中NullPointerException的技巧和最佳实践
                                    pda158
java
                                    
    1) 从已知的String对象中调用equals()和equalsIgnoreCase()方法，而非未知对象。   　　总是从已知的非空String对象中调用equals()方法。因为equals()方法是对称的，调用a.equals(b)和调用b.equals(a)是完全相同的，这也是为什么程序员对于对象a和b这么不上心。如果调用者是空指针，这种调用可能导致一个空指针异常 
Object unk
    
                                
    • 
                                
  • 如何在Swift语言中创建http请求
                                    shoothao
httpswift
                                    
      
 概述：本文通过实例从同步和异步两种方式上回答了”如何在Swift语言中创建http请求“的问题。  
   
如果你对Objective-C比较了解的话，对于如何创建http请求你一定驾轻就熟了，而新语言Swift与其相比只有语法上的区别。但是，对才接触到这个崭新平台的初学者来说，他们仍然想知道“如何在Swift语言中创建http请求？”。 
在这里,我将作出一些建议来回答上述问题。常见的
    
                                
    • 
                                
  • Spring事务的传播方式
                                    uule
spring事务
                                    
    传播方式：  
      新建事务 
      required 
      required_new   - 挂起当前 
  
      非事务方式运行 
      supports 
  &nbs
    
                                
    •