MyBatis-plus+注解形式实现项目与数据库绑定动态更新

前言：在自己电脑上使用mybatis-plus生成映射数据库表的实体类，将项目上传到服务器启动时根据实体类自动创建、更新相应的数据库表，这样做的目的是使得在自己电脑上创建数据库表后不用再到服务器去创建

 实现思路：

1. 使用mybatis-plus生成实体类
2. 在生成实体类的时候获取类字段信息并通过注解的形式写入到实体类里面去
3. 在服务器启动项目的时候获取项目的所有实体类与数据库所有表进行对比，解析实体类上注解信息，写入特定的类用于将数据库没有对应的表进行创建

详细步骤

1.配置mybatis-plus自动生成代码

   依赖mybatis-plus   

    com.baomidou
    mybatis-plus
    2.3


    com.baomidou
    mybatisplus-spring-boot-starter
    1.0.5



    org.freemarker
    freemarker



    org.apache.velocity
    velocity-engine-core
    2.0

 配置

mybatis-plus:
  mapper-locations: classpath*:/mapper/*/*Mapper.xml
  global-config:
    id-type: 3
    field-strategy: 2
    db-column-underline: true
    refresh-mapper: true
  configuration:
    map-underscore-to-camel-case: true
    cache-enabled: true
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

 代码生成器

MpGenerator.java

import com.baomidou.mybatisplus.enums.FieldFill;
import com.baomidou.mybatisplus.enums.IdType;
import com.baomidou.mybatisplus.exceptions.MybatisPlusException;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.InjectionConfig;
import com.baomidou.mybatisplus.generator.config.*;
import com.baomidou.mybatisplus.generator.config.converts.MySqlTypeConvert;
import com.baomidou.mybatisplus.generator.config.po.TableField;
import com.baomidou.mybatisplus.generator.config.po.TableFill;
import com.baomidou.mybatisplus.generator.config.po.TableInfo;
import com.baomidou.mybatisplus.generator.config.rules.DbColumnType;
import com.baomidou.mybatisplus.generator.config.rules.DbType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import com.baomidou.mybatisplus.toolkit.StringUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.*;

public class MpGenerator {

    /**
     * 

     * 读取控制台内容
     * 
     */
    public String scanner(String tip) {
        Scanner scanner = new Scanner(System.in);
        StringBuilder help = new StringBuilder();
        help.append("请输入" + tip + "：");
        System.out.println(help.toString());
        if (scanner.hasNext()) {
            String ipt = scanner.next();
            if (StringUtils.isNotEmpty(ipt)) {
                return ipt;
            }
        }
        throw new MybatisPlusException("请输入正确的" + tip + "！");
    }

    private int type;



    public PackageConfig getPackageConfig() {
        PackageConfig pc = new PackageConfig();
        if (type == 3) {
            pc.setParent("com.wdz.tofs");
        } else {
            pc.setParent("com.wdz");
        }
        pc.setModuleName(scanner("模块名"));
        pc.setEntity("entity");
        pc.setController(null);
        return pc;
    }
    /**
     * 获取表字段信息
     */
    public ResultSetMetaData getMetaData(DataSourceConfig dsc,String tableName){
        Connection connection = dsc.getConn();
        try {
            try (PreparedStatement preparedStatement = connection.prepareStatement("select * from " + tableName)) {
                return preparedStatement.executeQuery().getMetaData();
            }
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        }
    }
    /**
     * 

     * MySQL 生成演示
     * 
     */
    public static void main(String[] args) {
        AutoGenerator mpg = new AutoGenerator();
        MpGenerator mpGenerator = new MpGenerator();
        // 选择 freemarker 引擎，默认 Veloctiy
        //mpg.setTemplateEngine(new FreemarkerTemplateEngine());
        // 全局配置
        GlobalConfig gc = new GlobalConfig();
        gc.setOpen(false);//完成后不打开文件夹
        gc.setAuthor("autor");
        String oPath = System.getProperty("user.dir");//得到当前项目的路径
        gc.setOutputDir(oPath + "/core_database/src/main/java/");   //生成文件输出根目录
        gc.setFileOverride(false);// 是否覆盖同名文件，默认是false
        gc.setActiveRecord(true);// 不需要ActiveRecord特性的请改为false
        gc.setEnableCache(false);// XML 二级缓存
        gc.setBaseResultMap(true);// XML ResultMap
        gc.setBaseColumnList(false);// XML columList
        gc.setIdType(IdType.UUID);
        mpg.setGlobalConfig(gc);

        // 数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setDbType(DbType.MYSQL);
        dsc.setTypeConvert(new MySqlTypeConvert() {
            // 自定义数据库表字段类型转换【可选】
            @Override
            public DbColumnType processTypeConvert(String fieldType) {
                // 注意！！processTypeConvert 存在默认类型转换，如果不是你要的效果请自定义返回、非如下直接返回。
                if (fieldType.equals("datetime")) {
                    fieldType = "String";
                }
                System.out.println("转换类型：" + fieldType);
                return super.processTypeConvert(fieldType);
            }
        });
        dsc.setDriverName("com.mysql.jdbc.Driver");

        dsc.setUsername("root");
        dsc.setPassword("00000");
        dsc.setUrl("jdbc:mysql://190.289.20.1:3306/***?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=GMT&allowPublicKeyRetrieval=true");
        mpg.setDataSource(dsc);
        // 包配置
        PackageConfig pc = mpGenerator.getPackageConfig();
        mpg.setPackageInfo(pc);
        // 策略配置
        StrategyConfig strategy = new StrategyConfig();

        // strategy.setCapitalMode(true);// 全局大写命名 ORACLE 注意
        strategy.setTablePrefix(new String[]{""});// 此处可以修改为您的表前缀
        //下划线转驼峰命名法
        strategy.setNaming(NamingStrategy.underline_to_camel);// 表名生成策略
        //自动填充设置
        List tableFillList = new ArrayList();
        tableFillList.add(new TableFill("create_date", FieldFill.INSERT));//设置为插入时自动填充
        tableFillList.add(new TableFill("update_date", FieldFill.INSERT_UPDATE));//设置为更新时自动填充
        strategy.setTableFillList(tableFillList);
        strategy.setRestControllerStyle(true);
        String tables = mpGenerator.scanner("表名,以逗号隔开需要生成的表");
        if (tables.length() != 0) {
            if ((tables.charAt(tables.length() - 1)) == ',') {
                tables = tables.substring(0, tables.length() - 1);
            }
            String[] tabless = tables.split(",");

            strategy.setInclude(tabless); // 需要生成的表
        }
        strategy.setControllerMappingHyphenStyle(true);
        mpg.setStrategy(strategy);

        // 自定义配置
        InjectionConfig cfg = new InjectionConfig() {
            @Override
            public void initMap() {
                // to do nothing
                Map map = new HashMap<>();
                this.setMap(map);
            }
        };

        // 如果模板引擎是 freemarker
        // String templatePath = "/templates/mapper.xml.ftl";
        // 如果模板引擎是 velocity
        String templatePath = "/templates/mapper.xml.vm";
        String entityPath = "/template/entity.java.vm";
        // 自定义输出配置
        List focList = new ArrayList<>();
        // 自定义配置会被优先输出
        focList.add(new FileOutConfig(templatePath) {
            @Override
            public String outputFile(TableInfo tableInfo) {
                // 自定义输出文件名 ， 如果你 Entity 设置了前后缀、此处注意 xml 的名称会跟着发生变化！！
                List list = tableInfo.getFields();
                Iterator iterator = list.iterator();
                ResultSetMetaData resultSetMetaData = mpGenerator.getMetaData(dsc,tableInfo.getName());
                int i = 1;
                while (iterator.hasNext()){
                    Map map = new HashMap();
                    try {
                        //在数据库中字符最大长度
                        map.put("length",resultSetMetaData.getColumnDisplaySize(i));
                        //类型
                        map.put("type",resultSetMetaData.getColumnTypeName(i));
                        //是否为null
                        map.put("nullable",resultSetMetaData.isNullable(i));
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                    i++;
                    iterator.next().setCustomMap(map);
                }
                return oPath + "/core_database/src/main/resources/mapper/" + mpGenerator.change(tableInfo.getEntityName())+ "/"+tableInfo.getEntityName() + "Mapper.xml";
            }
        });

        cfg.setFileOutConfigList(focList);
        mpg.setCfg(cfg);
        TemplateConfig tc = new TemplateConfig();
        //不生成controller
        tc.setController(null);
        //不生成xml(xml已经放到resource下面了,这里是不再Java文件夹下面存放了)
        tc.setXml(null);
        mpg.setTemplate(tc);
        // 执行生成
        mpg.execute();
    }
    /**
     * 全部转换为小写
     *
     * @param str 需要转换的参数
     * @return 返回替换后字符串
     */
    private String change(String str) {
        char[] cs = str.toCharArray();
        StringBuilder rstr = new StringBuilder();
        for (char c : cs) {
            //如果输入的是大写，+32即可得到小写
            if (c >= 'A' && c <= 'Z') {
                c += 32;
            }
            rstr.append(c);
        }
        return rstr.toString();
    }
}

 自定义表信息以及表字段信息注解

TableInfo（表信息）

import java.lang.annotation.*;

/**
 * 表详细信息
 * @author wuchuancheng
 * @since 2022-07-28
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface TableInfo {
    /**
     * 表名
     * @return
     */
    String name() default "";

    /**
     * 是否需要自动创建
     * @return
     */
    boolean isCreate() default true;

    /**
     * 注释
     * @return
     */
    String comment() default "";
}

ColumnInfo（表字段信息）

import java.lang.annotation.*;

/**
 * 表字段详细信息
 * @author wuchuancheng
 * @since 2022-07-28
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface ColumnInfo {

    /**
     * 字段名
     */
    String name() default "";

    /**
     * 字段注释
     */
    String comment() default "";

    /**
     * 最大长度
     */
    int length() default 0;

    /**
     * 字段类型
     */
    String type() default "";

    /**
     * 是否是主键
     */
    boolean key() default false;

    /**
     * 是否为空
     */
    int nullable() default 0;
}

自定义模板

entity.java.vm（放在resource/template下面）

package ${package.Entity};

//这两个改写成你自己的目录
import com.wdz.annotations.ColumnInfo;
import com.wdz.annotations.TableInfo;

#foreach($pkg in ${table.importPackages})
import ${pkg};
#end
#if(${entityLombokModel})

import com.baomidou.mybatisplus.annotations.Version;

import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
#end

/**
 * 

 * $!{table.comment}
 * 
 *
 * @author ${author}
 * @since ${date}
 */
@TableInfo(name="${table.name}",comment = "${table.comment}")
#if(${entityLombokModel})
@Data
#if(${superEntityClass})
@EqualsAndHashCode(callSuper = true)
#else
@EqualsAndHashCode(callSuper = false)
#end
@Accessors(chain = true)
#end
#if(${table.convert})
@TableName("${table.name}")
#end
#if(${superEntityClass})
public class ${entity} extends ${superEntityClass}#if(${activeRecord})<${entity}>#end {
#elseif(${activeRecord})
public class ${entity} extends Model<${entity}> {
#else
public class ${entity} implements Serializable {
#end

    private static final long serialVersionUID = 1L;

## ----------  BEGIN 字段循环遍历  ----------
#foreach($field in ${table.fields})
    #if(${field.keyFlag})
#set($keyPropertyName=${field.propertyName})
#end
#if("$!field.comment" != "")
    /**
     * ${field.comment}
     */
#end
@ColumnInfo(name="${field.name}",comment = "${field.comment}",length = ${field.customMap.length},type = "${field.customMap.type}",key = ${field.keyFlag},nullable = ${field.customMap.nullable})
#if(${field.keyFlag})
## 主键
#if(${field.keyIdentityFlag})
    @TableId(value = "${field.name}", type = IdType.AUTO)
#elseif(!$null.isNull(${idType}) && "$!idType" != "")
    @TableId(value = "${field.name}", type = IdType.${idType})
#elseif(${field.convert})
    @TableId("${field.name}")
#end
## 普通字段
#elseif(${field.fill})
## -----   存在字段填充设置   -----
#if(${field.convert})
    @TableField(value = "${field.name}", fill = FieldFill.${field.fill})
#else
    @TableField(fill = FieldFill.${field.fill})
#end
#elseif(${field.convert})
    @TableField("${field.name}")
#end
## 乐观锁注解
#if(${versionFieldName}==${field.name})
    @Version
#end
## 逻辑删除注解
#if(${logicDeleteFieldName}==${field.name})
    @TableLogic
#end
    private ${field.propertyType} ${field.propertyName};
#end
## ----------  END 字段循环遍历  ----------

#if(!${entityLombokModel})
#foreach($field in ${table.fields})
#if(${field.propertyType.equals("boolean")})
#set($getprefix="is")
#else
#set($getprefix="get")
#end

    public ${field.propertyType} ${getprefix}${field.capitalName}() {
        return ${field.propertyName};
    }

#if(${entityBuilderModel})
    public ${entity} set${field.capitalName}(${field.propertyType} ${field.propertyName}) {
#else
    public void set${field.capitalName}(${field.propertyType} ${field.propertyName}) {
#end
        this.${field.propertyName} = ${field.propertyName};
#if(${entityBuilderModel})
        return this;
#end
    }
#end
#end

#if(${entityColumnConstant})
#foreach($field in ${table.fields})
    public static final String ${field.name.toUpperCase()} = "${field.name}";

#end
#end
#if(${activeRecord})
    @Override
    protected Serializable pkVal() {
#if(${keyPropertyName})
        return this.${keyPropertyName};
#else
        return null;
#end
    }

#end
#if(!${entityLombokModel})
    @Override
    public String toString() {
        return "${entity}{" +
#foreach($field in ${table.fields})
#if($!{velocityCount}==1)
        "${field.propertyName}=" + ${field.propertyName} +
#else
        ", ${field.propertyName}=" + ${field.propertyName} +
#end
#end
        "}";
    }
#end
}

第一阶段代码生成器的改造基本完成，这一阶段的作用是根据数据库表生成相对应的实体类，实体类里面还有描述实体类的表信息注解以及字段信息注解，如以下代码类似

import com.wdz.annotations.ColumnInfo;

import com.baomidou.mybatisplus.annotations.TableField;
import com.baomidou.mybatisplus.enums.FieldFill;
import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.enums.IdType;
import com.baomidou.mybatisplus.activerecord.Model;
import com.baomidou.mybatisplus.annotations.TableName;
import com.wdz.annotations.TableInfo;

import java.io.Serializable;

/**
 * 

 * 测试
 * 
 *
 * @author wuchuancheng
 * @since 2022-07-28
 */
@TableInfo(name="test",comment = "测试")
@TableName("test")
public class Test extends Model {

    private static final long serialVersionUID = 1L;

    /**
     * 主键
     */
@ColumnInfo(name="id",comment = "主键",length = 32,type = "VARCHAR",key = true,nullable = 0)
    @TableId(value = "id", type = IdType.UUID)
    private String id;
    /**
     * 测试
     */
@ColumnInfo(name="test",comment = "测试",length = 255,type = "VARCHAR",key = false,nullable = 1)
    private String test;

    public String getWay() {
        return way;
    }

    public void setWay(String way) {
        this.way = way;
    }

    /**
     * 测试way
     */
    @ColumnInfo(name="way",comment = "测试way",length = 255,type = "VARCHAR",key = false,nullable = 1)
    private String way;
    /**
     * 数字
     */
@ColumnInfo(name="ino",comment = "数字",length = 10,type = "INT",key = false,nullable = 1)
    private Integer int1;
    /**
     * 时间
     */
@ColumnInfo(name="create_date",comment = "时间",length = 0,type = "DATETIME",key = false,nullable = 1)
    @TableField(value = "create_date", fill = FieldFill.INSERT)
    private String createDate;


    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getTest() {
        return test;
    }

    public void setTest(String test) {
        this.test = test;
    }

    public Integer getInt1() {
        return int1;
    }

    public void setInt1(Integer int1) {
        this.int1 = int1;
    }

    public String getCreateDate() {
        return createDate;
    }

    public void setCreateDate(String createDate) {
        this.createDate = createDate;
    }

    @Override
    protected Serializable pkVal() {
        return this.id;
    }

    @Override
    public String toString() {
        return "Test{" +
        ", id=" + id +
        ", test=" + test +
        ", int1=" + int1 +
        ", createDate=" + createDate +
        "}";
    }
}

另外，mapper.xml会在resource下生成，不会生成controller。

关键代码解释：

这一部分的精髓在这里

// 如果模板引擎是 freemarker
        // String templatePath = "/templates/mapper.xml.ftl";
        // 如果模板引擎是 velocity
        String templatePath = "/templates/mapper.xml.vm";
        String entityPath = "/template/entity.java.vm";
        // 自定义输出配置
        List focList = new ArrayList<>();
        // 自定义配置会被优先输出
        focList.add(new FileOutConfig(templatePath) {
            @Override
            public String outputFile(TableInfo tableInfo) {
                // 自定义输出文件名 ， 如果你 Entity 设置了前后缀、此处注意 xml 的名称会跟着发生变化！！
                List list = tableInfo.getFields();
                Iterator iterator = list.iterator();
                ResultSetMetaData resultSetMetaData = mpGenerator.getMetaData(dsc,tableInfo.getName());
                int i = 1;
                while (iterator.hasNext()){
                    Map map = new HashMap();
                    try {
                        //在数据库中字符最大长度
                        map.put("length",resultSetMetaData.getColumnDisplaySize(i));
                        //类型
                        map.put("type",resultSetMetaData.getColumnTypeName(i));
                        //是否为null
                        map.put("nullable",resultSetMetaData.isNullable(i));
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                    i++;
                    iterator.next().setCustomMap(map);
                }
                return oPath + "/core_database/src/main/resources/mapper/" + mpGenerator.change(tableInfo.getEntityName())+ "/"+tableInfo.getEntityName() + "Mapper.xml";
            }
        });

/templates/mapper.xml.vm模板是在依赖包mybatis-plus-generate下面

/template/entity.java.vm模板是在自己项目resource下面

 resultSetMetaData对象是表字段信息集合

/**
     * 获取表字段信息
     */
    public ResultSetMetaData getMetaData(DataSourceConfig dsc,String tableName){
        Connection connection = dsc.getConn();
        try {
            try (PreparedStatement preparedStatement = connection.prepareStatement("select * from " + tableName)) {
                return preparedStatement.executeQuery().getMetaData();
            }
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        }
    }

而这一段

while (iterator.hasNext()){
                    Map map = new HashMap();
                    try {
                        //在数据库中字符最大长度
                        map.put("length",resultSetMetaData.getColumnDisplaySize(i));
                        //类型
                        map.put("type",resultSetMetaData.getColumnTypeName(i));
                        //是否为null
                        map.put("nullable",resultSetMetaData.isNullable(i));
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                    i++;
                    iterator.next().setCustomMap(map);
                }

是将表字段信息写入到实体类里面去，重点在于.setCustomMap();这个方法

源码

将几个数据写入 customMap里面去就可以在entity.java.vm里面使用它

 然后就可以生成带有表信息以及表字段信息注解的实体类了

2.项目启动时创建表

这一步的关键是要去数据库读取所有表名和项目的实体类名然后进行判断，判断出若项目有某个实体类而数据库没有这张表，就自动创建这张表，所以我自建了Table，FieldInfo和与之对应的TableMapper，FieldInfoMapper类来查询数据库表以及表字段、创建或更新表。创建或更新表也可以直接在mapper.xml里面写sql语句

 封装表信息实体类

Table.java

import com.baomidou.mybatisplus.activerecord.Model;

import java.io.Serializable;
import java.util.List;

/**
 * 数据库表名集合
 * @author wuchuancheng
 */
public class Table extends Model {
    private static final long serialVersionUID = 1L;

    private String tableName;

    private String comment;

    private List fieldInfos;

    public List getFieldInfos() {
        return fieldInfos;
    }

    public void setFieldInfos(List fieldInfos) {
        this.fieldInfos = fieldInfos;
    }

    public String getTableName() {
        return tableName;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String comment) {
        this.comment = comment;
    }

    public void setTableName(String tableName) {
        this.tableName = tableName;
    }

    @Override
    protected Serializable pkVal() {
        return serialVersionUID;
    }
}
 
  
Mapper
 
  
TableMapper.java
 
  
import com.baomidou.mybatisplus.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

import java.util.List;

/**
 * @author wuchuancheng
 */
@Mapper
public interface TableMapper extends BaseMapper {
    
    /**
     * 查询所以表名
     * @return 表集合
     */
    @Select("select table_name from information_schema.tables where table_schema='bd_dongzhebk' and table_type='base table';")
    List tableList();

    /**
     * 创建表
     * @param tableInfo 表信息
     */
    void createTable(Table tableInfo);

    /**
     * 更新表
     * @param tableInfo 表信息
     */
    void alterField(Table tableInfo);

}
 TableMapper.xml




    
    
        
    
    
    
        SET NAMES utf8mb4;
        SET FOREIGN_KEY_CHECKS = 0;
        DROP TABLE IF EXISTS ${tableName};
        CREATE TABLE ${tableName}
        
            ${item.name} ${item.type}(${item.length})
            
                CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci
            
            NOT NULL
            NULL DEFAULT
                
                    0
                
                
                    NULL
                
            
            COMMENT '${item.comment}',
            
                
                    
                        PRIMARY KEY (${item2.name}) USING BTREE
                    
                
            
        

        ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '${comment}' ROW_FORMAT
        = Compact;
    
    
    
        
            alter table ${tableName} add ${item.name} ${item.type}(${item.length})
            
                CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci
            
            NOT NULL
            NULL DEFAULT
                
                    0
                
                
                    NULL
                
            
            comment '${item.comment}';
        
    

封装字段信息实体类
 FieldInfo.java
import com.baomidou.mybatisplus.activerecord.Model;

import java.io.Serializable;

/**
 * 字段信息
 * @author wuchuancheng
 */
public class FieldInfo extends Model {

    private static final long serialVersionUID = 1L;

    private String name;

    private String type;

    private Integer length;

    private Integer decimal;

    private String defaulc;

    public String getDefaulc() {
        return defaulc;
    }

    public void setDefaulc(String defaulc) {
        this.defaulc = defaulc;
    }

    public String getCollation() {
        return collation;
    }

    public void setCollation(String collation) {
        this.collation = collation;
    }

    private Integer isNull;

    private String nullable;

    private String collation;

    private String keyValue;

    public String getKeyValue() {
        return keyValue;
    }

    public void setKeyValue(String keyValue) {
        this.keyValue = keyValue;
    }

    public String getNullable() {
        return nullable;
    }

    public void setNullable(String nullable) {
        this.nullable = nullable;
    }

    private boolean isKey;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public Integer getLength() {
        return length;
    }

    public void setLength(Integer length) {
        this.length = length;
    }

    public Integer getDecimal() {
        return decimal;
    }

    public void setDecimal(Integer decimal) {
        this.decimal = decimal;
    }

    public Integer getIsNull() {
        return isNull;
    }

    public void setIsNull(Integer isNull) {
        this.isNull = isNull;
    }

    public boolean isKey() {
        return isKey;
    }

    public void setKey(boolean key) {
        isKey = key;
    }

    public String getAnnotate() {
        return annotate;
    }

    public void setAnnotate(String annotate) {
        this.annotate = annotate;
    }

    private String annotate;

    private String comment;

    public String getComment() {
        return comment;
    }

    public void setComment(String comment) {
        this.comment = comment;
    }

    @Override
    protected Serializable pkVal() {
        return serialVersionUID;
    }

    @Override
    public String toString() {
        return "FieldInfo{" +
                "name='" + name + '\'' +
                ", type='" + type + '\'' +
                ", length=" + length +
                ", decimal=" + decimal +
                ", isNull=" + isNull +
                ", isKey=" + isKey +
                ", annotate='" + annotate + '\'' +
                ", comment='" + comment + '\'' +
                '}';
    }
}
 FieldInfoMapper.java
import com.baomidou.mybatisplus.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

import java.util.List;

/**
 * @author wuchuancheng
 */
public interface FieldInfoMapper extends BaseMapper {
    
    /**
     * 根据表名查询所有字段信息集合
     * @param tableName 表名
     * @return 字段信息集合
     */
    List getFieldInfos(@Param("tableName") String tableName);
}
FieldInfoMapper.xml




    
    
        
        
        
        
        
        
        
        
        
    
    
        show full columns from ${tableName};
    
功能类
AutomaticConstruct.java
import com.wdz.annotations.ColumnInfo;
import com.wdz.annotations.TableInfo;
import com.wdz.table.entity.FieldInfo;
import com.wdz.table.entity.Table;
import com.wdz.table.mapper.FieldInfoMapper;
import com.wdz.table.mapper.TableMapper;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.core.annotation.Order;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.stereotype.Component;
import org.springframework.util.ClassUtils;

import javax.annotation.Resource;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.*;

@Component
@Order(1)//项目启动时自动执行
public class AutomaticConstruct implements ApplicationRunner {


    /**
     * 获取当前所在环境 根据项目自己更改，作用是判断当前项目是不是在正式服启动
     */
    @Value("${spring.profiles.active}")
    private String tenant;

    @Resource
    private TableMapper tableMapper;

    @Resource
    private FieldInfoMapper fieldInfoMapper;


    /**
     * 将测试服数据库同步到正式服上
     * @param args
     * @throws Exception
     */
    @Override
    public void run(ApplicationArguments args) throws Exception {
        //如果是正式服环境就做这些事情，这些自动建表的事情
        String tenant = "pro";
        if(tenant.equals(this.tenant)){
            List
 iterator = tableMapper.tableList();
            List tables = getTableNames();
            boolean bln = true;
            List n = new ArrayList<>();
            for (Table table : tables) {
                bln = true;
                for(Table table1 : iterator){
                    if((table.getTableName()).equals(table1.getTableName())){
                        bln = false;
                        List fieldInfos = fieldInfoMapper.getFieldInfos(table.getTableName());
                        List fieldInfos2 = table.getFieldInfos();
                        List list = new ArrayList<>();
                        boolean bln2 = true,bln3 = false;
                        for(FieldInfo fieldInfo:fieldInfos2){
                            bln2 = true;
                            for(FieldInfo fieldInfo2:fieldInfos){
                                if((fieldInfo.getName()).equals(fieldInfo2.getName())){
                                    bln2 = false;
                                    break;
                                }
                            }
                            if(bln2){
                                list.add(fieldInfo);
                                bln3 = true;
                            }
                        }
                        //执行更新
                        if(bln3) {
                            Table table2 = new Table();
                            table2.setTableName(table.getTableName());
                            table2.setFieldInfos(list);
                            tableMapper.alterField(table2);
                        }
                        break;
                    }
                }
                if(bln){
                   n.add(table);
                }
            }
            for(Table table:n){
                tableMapper.createTable(table);
            }
        }
    }

    /**
     * 获取模块中的数据库对应实体类
     * @return
     */
    public List getTableNames(){
        List list = new ArrayList<>();

        //spring工具类，可以获取指定路径下的全部类
        ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
        try {
            String pattern = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
                    ClassUtils.convertClassNameToResourcePath("com.wdz") + "/**/entity/*.class";
            org.springframework.core.io.Resource[] resources =resourcePatternResolver.getResources(pattern);
            //MetadataReader 的工厂类
            MetadataReaderFactory readerfactory = new CachingMetadataReaderFactory(resourcePatternResolver);
            for (org.springframework.core.io.Resource resource : resources) {
                //用于读取类信息
                MetadataReader reader = readerfactory.getMetadataReader(resource);
                //扫描到的class
                String classname = reader.getClassMetadata().getClassName();
                Class clazz = Class.forName(classname);
                //判断是否有指定主解
                TableInfo anno = clazz.getAnnotation(TableInfo.class);
                if (anno != null && anno.isCreate()) {
                    //将含有@TableInfo的类的类名放入list
                    Table table = new Table();
                    table.setTableName(anno.name());
                    table.setComment(anno.comment());
                    List fieldInfos = new ArrayList<>();
                    Field[] fields = clazz.getDeclaredFields();
                    for(Field field:fields){
                        field.setAccessible(true);
                        ColumnInfo columnInfo = field.getAnnotation(ColumnInfo.class);
                        if(columnInfo != null){
                            FieldInfo fieldInfo = new FieldInfo();
                            fieldInfo.setType(columnInfo.type());
                            fieldInfo.setName(columnInfo.name());
                            fieldInfo.setLength(columnInfo.length());
                            fieldInfo.setKey(columnInfo.key());
                            fieldInfo.setIsNull(columnInfo.nullable());
                            fieldInfo.setComment(columnInfo.comment());
                            fieldInfos.add(fieldInfo);
                        }
                    }
                    table.setFieldInfos(fieldInfos);
                    list.add(table);
                }
            }
        } catch (IOException | ClassNotFoundException ignored) {
            ignored.printStackTrace();
        }
        return list;
    }
}
 
   
AutomaticConstruct类的作用是，在项目启动的时候
 
   
 
    
获取数据库所有表集合（调用tableMapper.tableList()）
 
    
获取项目所有实体类集合（调用getTableNames()）
 
    
两者进行判断，数据库没有的就创建（调用tableMapper.createTable(table)）
 
    
数据库有但是表字段不全（调用tableMapper.alterField(table2)）更新
 
   
 
  
3.完成
就这样大功告成了，我把所有需要用到的都贴出来了，复制就可以直接使用，不会有问题。制作不易，还望点个赞。如果有问题可以留言评论。
欢迎大家访问我的博客way博客

                    

                        
                        

                            
 
                        
                        
                        

                            

                        
                        
                        

                            

                        
                    
                

        
你可能感兴趣的:(mybatis,mybatis,java,后端,mysql)
        

            

                

                    
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
                    
                    
mysql禁用远程登录
                        igotyback
mysql
                        
去mysql库中的user表里，将host都改成localhost之后刷新权限FLUSHPRIVILEGES;
                    
                    
Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
                    
                    
使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器）
                        编程经验分享
开发工具服务器sshlinux
                        
目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
                    
                    
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分别代
                    
                    
关于城市旅游的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：做与用户的交互行为文章目录前端学习路线
                    
                    
MYSQL面试系列-04
                        king01299
面试mysql面试
                        
MYSQL面试系列-0417.关于redolog和binlog的刷盘机制、redolog、undolog作用、GTID是做什么的？innodb_flush_log_at_trx_commit及sync_binlog参数意义双117.1innodb_flush_log_at_trx_commit该变量定义了InnoDB在每次事务提交时，如何处理未刷入（flush）的重做日志信息（redolog）。它
                    
                    
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的运行
                    
                    
Low Power概念介绍-Voltage Area
                        飞奔的大虎

                        
随着智能手机，以及物联网的普及，芯片功耗的问题最近几年得到了越来越多的重视。为了实现集成电路的低功耗设计目标，我们需要在系统设计阶段就采用低功耗设计的方案。而且，随着设计流程的逐步推进，到了芯片后端设计阶段，降低芯片功耗的方法已经很少了，节省的功耗百分比也不断下降。芯片的功耗主要由静态功耗（staticleakagepower）和动态功耗(dynamicpower)构成。静态功耗主要是指电路处于等
                    
                    
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)同样是完成了取最大值的功能。
                    
                    
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
                    
                    
Java：爬虫框架
                        dingcho
Javajava爬虫
                        
一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
                    
                    
MongoDB知识概括
                        GeorgeLin98
持久层mongodb
                        
MongoDB知识概括MongoDB相关概念单机部署基本常用命令索引-IndexSpirngDataMongoDB集成副本集分片集群安全认证MongoDB相关概念业务应用场景：传统的关系型数据库（如MySQL），在数据操作的“三高”需求以及应对Web2.0的网站需求面前，显得力不从心。解释：“三高”需求：①Highperformance-对数据库高并发读写的需求。②HugeStorage-对海量数
                    
                    
python怎么将png转为tif_png转tif
                        weixin_39977276

                        
发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
                    
                    
springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
                    
                    
JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
                    
                    
uniapp map组件自定义markers标记点
                        以对_
uni-app学习记录uni-appjavascript前端
                        
需求是根据后端返回数据在地图上显示标记点，并且根据数据状态控制标记点颜色，标记点背景通过两张图片实现控制{{item.options.labelName}}exportdefault{data(){return{storeIndex:0,locaInfo:{longitude:120.445172,latitude:36.111387},markers:[//标点列表{id:1,//标记点idin
                    
                                
Maven
                                    Array_06
eclipsejdkmaven
                                    
Maven 
 
Maven是基于项目对象模型(POM)， 信息来管理项目的构建，报告和文档的软件项目管理工具。 
Maven 除了以程序构建能力为特色之外，还提供高级项目管理工具。由于 Maven 的缺省构建规则有较高的可重用性，所以常常用两三行 Maven 构建脚本就可以构建简单的项目。由于 Maven 的面向项目的方法，许多 Apache Jakarta 项目发文时使用 Maven，而且公司
                                
                                
ibatis的queyrForList和queryForMap区别
                                    bijian1013
javaibatis
                                    
一.说明 
        iBatis的返回值参数类型也有种：resultMap与resultClass，这两种类型的选择可以用两句话说明之： 
        1.当结果集列名和类的属性名完全相对应的时候，则可直接用resultClass直接指定查询结果类
                                
                                
LeetCode[位运算] - #191 计算汉明权重
                                    Cwind
java位运算LeetCodeAlgorithm题解
                                    
原题链接：#191 Number of 1 Bits 
要求： 
写一个函数，以一个无符号整数为参数，返回其汉明权重。例如，‘11’的二进制表示为'00000000000000000000000000001011', 故函数应当返回3。 
汉明权重：指一个字符串中非零字符的个数；对于二进制串，即其中‘1’的个数。 
难度：简单 
分析： 
将十进制参数转换为二进制，然后计算其中1的个数即可。 
“
                                
                                
浅谈java类与对象
                                    15700786134
java
                                    
      java是一门面向对象的编程语言，类与对象是其最基本的概念。所谓对象，就是一个个具体的物体，一个人，一台电脑，都是对象。而类，就是对象的一种抽象，是多个对象具有的共性的一种集合，其中包含了属性与方法，就是属于该类的对象所具有的共性。当一个类创建了对象，这个对象就拥有了该类全部的属性，方法。相比于结构化的编程思路，面向对象更适用于人的思维
                                
                                
linux下双网卡同一个IP
                                    被触发
linux
                                    
转自： 
http://q2482696735.blog.163.com/blog/static/250606077201569029441/ 
 
由于需要一台机器有两个网卡，开始时设置在同一个网段的IP，发现数据总是从一个网卡发出，而另一个网卡上没有数据流动。网上找了下，发现相同的问题不少： 
一、 
关于双网卡设置同一网段IP然后连接交换机的时候出现的奇怪现象。当时没有怎么思考、以为是生成树
                                
                                
安卓按主页键隐藏程序之后无法再次打开
                                    肆无忌惮_
安卓
                                    
遇到一个奇怪的问题，当SplashActivity跳转到MainActivity之后，按主页键，再去打开程序，程序没法再打开（闪一下），结束任务再开也是这样，只能卸载了再重装。而且每次在Log里都打印了这句话"进入主程序"。后来发现是必须跳转之后再finish掉SplashActivity 
  
本来代码： 
  
// 销毁这个Activity 
fin
                                
                                
通过cookie保存并读取用户登录信息实例
                                    知了ing
JavaScripthtml
                                    
通过cookie的getCookies()方法可获取所有cookie对象的集合；通过getName()方法可以获取指定的名称的cookie；通过getValue()方法获取到cookie对象的值。另外，将一个cookie对象发送到客户端，使用response对象的addCookie()方法。 
下面通过cookie保存并读取用户登录信息的例子加深一下理解。 
（1）创建index.jsp文件。在改
                                
                                
JAVA 对象池
                                    矮蛋蛋
javaObjectPool
                                    
原文地址： 
http://www.blogjava.net/baoyaer/articles/218460.html 
Jakarta对象池 
      ☆为什么使用对象池 
  恰当地使用对象池化技术，可以有效地减少对象生成和初始化时的消耗，提高系统的运行效率。Jakarta Commons Pool组件提供了一整套用于实现对象池化
                                
                                
ArrayList根据条件+for循环批量删除的方法
                                    alleni123
java
                                    
场景如下： 
ArrayList<Obj> list 
 
Obj-> createTime, sid. 
 
现在要根据obj的createTime来进行定期清理。（释放内存） 
 
------------------------- 
 
首先想到的方法就是 
 
for(Obj o:list){
  if(o.createTime-currentT>xxx){
 
                                
                                
阿里巴巴“耕地宝”大战各种宝
                                    百合不是茶
平台战略
                                    
“耕地保”平台是阿里巴巴和安徽农民共同推出的一个 “首个互联网定制私人农场”，“耕地宝”由阿里巴巴投入一亿 ，主要是用来进行农业方面，将农民手中的散地集中起来 不仅加大农民集体在土地上面的话语权，还增加了土地的流通与 利用率，提高了土地的产量，有利于大规模的产业化的高科技农业的 发展，阿里在农业上的探索将会引起新一轮的产业调整，但是集体化之后农民的个体的话语权 将更少，国家应出台相应的法律法规保护
                                
                                
Spring注入有继承关系的类（1）
                                    bijian1013
javaspring
                                    
一个类一个类的注入 
1.AClass类 
 
package com.bijian.spring.test2;

public class AClass {

    String a;
    String b;
   
    public String getA() {
        return a;
    }
    public void setA(Strin
                                
                                
30岁转型期你能否成为成功人士
                                    bijian1013
成功
                                    
        很多人由于年轻时走了弯路，到了30岁一事无成，这样的例子大有人在。但同样也有一些人，整个职业生涯都发展得很优秀，到了30岁已经成为职场的精英阶层。由于做猎头的原因，我们接触很多30岁左右的经理人，发现他们在职业发展道路上往往有很多致命的问题。在30岁之前，他们的职业生涯表现很优秀，但从30岁到40岁这一段，很多人
                                
                                
[Velocity三]基于Servlet+Velocity的web应用
                                    bit1129
velocity
                                    
什么是VelocityViewServlet 
使用org.apache.velocity.tools.view.VelocityViewServlet可以将Velocity集成到基于Servlet的web应用中，以Servlet+Velocity的方式实现web应用 
  Servlet + Velocity的一般步骤 
1.自定义Servlet，实现VelocityViewServl
                                
                                
【Kafka十二】关于Kafka是一个Commit Log Service
                                    bit1129
service
                                    
Kafka is a distributed, partitioned, replicated commit log service.这里的commit log如何理解？ 
  
A message is considered "committed" when all in sync replicas for that partition have applied i
                                
                                
NGINX + LUA实现复杂的控制
                                    ronin47
lua nginx 控制
                                    
安装lua_nginx_module 模块 
lua_nginx_module 可以一步步的安装，也可以直接用淘宝的OpenResty 
Centos和debian的安装就简单了。。 
这里说下freebsd的安装： 
fetch http://www.lua.org/ftp/lua-5.1.4.tar.gz
tar zxvf lua-5.1.4.tar.gz
cd lua-5.1.4
ma
                                
                                
java-14.输入一个已经按升序排序过的数组和一个数字， 在数组中查找两个数，使得它们的和正好是输入的那个数字
                                    bylijinnan
java
                                    


public class TwoElementEqualSum {

	/**
	 * 第 14 题：
题目：输入一个已经按升序排序过的数组和一个数字，
在数组中查找两个数，使得它们的和正好是输入的那个数字。
要求时间复杂度是 O(n) 。如果有多对数字的和等于输入的数字，输出任意一对即可。
例如输入数组 1 、 2 、 4 、 7 、 11 、 15 和数字 15 。由于 
                                
                                
Netty源码学习-HttpChunkAggregator-HttpRequestEncoder-HttpResponseDecoder
                                    bylijinnan
javanetty
                                    
今天看Netty如何实现一个Http Server 
org.jboss.netty.example.http.file.HttpStaticFileServerPipelineFactory： 
 

		pipeline.addLast("decoder", new HttpRequestDecoder());
        pipeline.addLast(&quo
                                
                                
java敏感词过虑-基于多叉树原理
                                    cngolon
违禁词过虑替换违禁词敏感词过虑多叉树
                                    
基于多叉树的敏感词、关键词过滤的工具包，用于java中的敏感词过滤 
1、工具包自带敏感词词库，第一次调用时读入词库，故第一次调用时间可能较长，在类加载后普通pc机上html过滤5000字在80毫秒左右，纯文本35毫秒左右。 
  
2、如需自定义词库，将jar包考入WEB-INF工程的lib目录，在WEB-INF/classes目录下建一个 
utf-8的words.dict文本文件，
                                
                                
多线程知识
                                    cuishikuan
多线程
                                    
 
  
  T1，T2，T3三个线程工作顺序，按照T1，T2，T3依次进行 
  public class T1 implements Runnable{    
     
       @Override    
      
                                
                                
spring整合activemq
                                    dalan_123
java spring jms
                                    
整合spring和activemq需要搞清楚如下的东东1、ConnectionFactory分：     a、spring管理连接到activemq服务器的管理ConnectionFactory也即是所谓产生到jms服务器的链接      b、真正产生到JMS服务器链接的ConnectionFactory还得
                                
                                
MySQL时间字段究竟使用INT还是DateTime？
                                    dcj3sjt126com
mysql
                                    
  
环境：Windows XPPHP Version 5.2.9MySQL Server 5.1 
第一步、创建一个表date_test（非定长、int时间） 
CREATE TABLE `test`.`date_test` (`id` INT NOT NULL AUTO_INCREMENT ,`start_time` INT NOT NULL ,`some_content`
                                
                                
Parcel: unable to marshal value
                                    dcj3sjt126com
marshal
                                    
在两个activity直接传递List<xxInfo>时，出现Parcel: unable to marshal value异常。      在MainActivity页面（MainActivity页面向NextActivity页面传递一个List<xxInfo>）：       Intent intent = new Intent(this, Next
                                
                                
linux进程的查看上（ps）
                                    eksliang
linux pslinux ps -llinux ps aux
                                    
ps:将某个时间点的进程运行情况选取下来 
转载请出自出处：http://eksliang.iteye.com/admin/blogs/2119469 
http://eksliang.iteye.com 
        ps 这个命令的man page 不是很好查阅，因为很多不同的Unix都使用这儿ps来查阅进程的状态，为了要符合不同版本的需求，所以这个
                                
                                
为什么第三方应用能早于System的app启动
                                    gqdy365
System
                                    
Android应用的启动顺序网上有一大堆资料可以查阅了，这里就不细述了，这里不阐述ROM启动还有bootloader，软件启动的大致流程应该是启动kernel -> 运行servicemanager 把一些native的服务用命令启动起来（包括wifi, power, rild, surfaceflinger, mediaserver等等）-> 启动Dalivk中的第一个进程Zygot
                                
                                
App Framework发送JSONP请求(3)
                                    hw1287789687
jsonp跨域请求发送jsonpajax请求越狱请求
                                    
App Framework 中如何发送JSONP请求呢? 
使用jsonp,详情请参考:http://json-p.org/ 
如何发送Ajax请求呢? 
(1)登录 
/***
 * 会员登录
 * @param username
 * @param password
 */
var user_login=function(username,password){
//    aler
                                
                                
发福利，整理了一份关于“资源汇总”的汇总
                                    justjavac
资源
                                    
觉得有用的话，可以去github关注：https://github.com/justjavac/awesome-awesomeness-zh_CN  通用 
 
  free-programming-books-zh_CN 免费的计算机编程类中文书籍  
  精彩博客集合 hacke2/hacke2.github.io#2  
  ResumeSample 程序员简历
                                
                                
用 Java 技术创建 RESTful Web 服务
                                    macroli
java编程WebREST
                                    
转载：http://www.ibm.com/developerworks/cn/web/wa-jaxrs/ 
  
JAX-RS (JSR-311) 【  Java API for RESTful Web Services 】是一种 Java™ API，可使 Java Restful 服务的开发变得迅速而轻松。这个 API 提供了一种基于注释的模型来描述分布式资源。注释被用来提供资源的位
                                
                                
CentOS6.5-x86_64位下oracle11g的安装详细步骤及注意事项
                                    超声波
oraclelinux
                                    
前言： 
这两天项目要上线了，由我负责往服务器部署整个项目，因此首先要往服务器安装oracle，服务器本身是CentOS6.5的64位系统，安装的数据库版本是11g，在整个的安装过程中碰到很多的坑，不过最后还是通过各种途径解决并成功装上了。转别写篇博客来记录完整的安装过程以及在整个过程中的注意事项。希望对以后那些刚刚接触的菜鸟们能起到一定的帮助作用。 
  
安装过程中可能遇到的问题（注
                                
                                
HttpClient 4.3 设置keeplive 和 timeout 的方法
                                    supben
httpclient
                                    
ConnectionKeepAliveStrategy kaStrategy = new DefaultConnectionKeepAliveStrategy() {
			@Override
			public long getKeepAliveDuration(HttpResponse response, HttpContext context) {
				long keepAlive
                                
                                
Spring 4.2新特性-@Import注解的升级
                                    wiselyman
spring 4
                                    
3.1 @Import 
 
 @Import注解在4.2之前只支持导入配置类 
 在4.2,@Import注解支持导入普通的java类,并将其声明成一个bean 
  
3.2 示例 
 
 演示java类 
  
package com.wisely.spring4_2.imp;

public class DemoService {
    public void doSomethin
                                
                
            
        
    

    

        

            按字母分类：
            ABCDEFGHIJKLMNOPQRSTUVWXYZ其他
        
    

    

        

            首页 -
            关于我们 -
            站内搜索 -
            Sitemap -
            侵权投诉
        
        
版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.