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)



unblock with ‘mysqladmin flush-hosts‘ 解决方法
祈祷平安,加油
数据库常见问题oracle数据库
MySqlHostisblockedbecauseofmanyconnectionerrors;unblockwith'mysqladminflush-hosts'解决方法环境：linux，mysql5.5.21错误：Hostisblockedbecauseofmanyconnectionerrors;unblockwith'mysqladminflush-hosts'原因：同一个ip在短时间内产

通俗易懂：MySQL中如何设置只读实例并确保数据一致性？
大龄下岗程序员
mysqljavamysqlspring
在MySQL中设置只读实例主要应用于构建高可用性和扩展性的数据库环境，通常是为了分担读取负载或者用于备份和灾难恢复。以下是创建MySQL只读实例并确保数据一致性的基本步骤：1.创建并配置只读实例-主从复制设置-首先，你需要有一个主数据库实例（Master）负责接收所有的写操作。-创建一个或多个从数据库实例（Slave），并将它们配置为主数据库的复制品。这通常通过设置主从复制（Replication

华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++）
华为OD题库
华为od链表java
须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总

学习JavaEE的日子 Day32 线程池
A 北枝
学习JavaEE学习java-eejava线程池
Day32线程池1.引入一个线程完成一项任务所需时间为：创建线程时间-Time1线程中执行任务的时间-Time2销毁线程时间-Time32.为什么需要线程池(重要)线程池技术正是关注如何缩短或调整Time1和Time3的时间，从而提高程序的性能。项目中可以把Time1，T3分别安排在项目的启动和结束的时间段或者一些空闲的时间段线程池不仅调整Time1，Time3产生的时间段，而且它还显著减少了创建

请简单介绍一下Shiro框架是什么？Shiro在Java安全领域的主要作用是什么？Shiro主要提供了哪些安全功能？
AaronWang94
shirojavajava安全开发语言
请简单介绍一下Shiro框架是什么？Shiro框架是一个强大且灵活的开源安全框架，为Java应用程序提供了全面的安全解决方案。它主要用于身份验证、授权、加密和会话管理等功能，可以轻松地集成到任何JavaWeb应用程序中，并提供了易于理解和使用的API，使开发人员能够快速实现安全特性。Shiro的核心组件包括Subject、SecurityManager和Realms。Subject代表了当前与应用

Redis和MySQL的数据一致性问题思考
爱放火的安小妮
RedisMySQL思考总结redismysql数据库
Redis和MySQL的数据一致性问题思考最近有在反思自己工作。因为自己这边是面向业务的，而且是和商品数据相关的。所以我平时工作中涉及到的最多的就是MySQL和Redis的数据存储。像我们配置商品是把商品配置到MySQL，但是对外toC接口都是直接读取Redis的。所以自然而然就涉及到MySQL和Redis的数据一致性问题。下面就是聊聊我自己对于这个问题的一个思考吧。有问题或者有更好方案的朋友也希

通俗易懂：什么是Java虚拟机（JVM）？它的主要作用是什么？
大龄下岗程序员
mysqljavamysqlspring
Java虚拟机（JavaVirtualMachine,JVM）是一种软件实现的抽象计算机，它负责执行Java字节码（Bytecode）。Java程序并不是直接在物理计算机上运行，而是先由Java编译器将源代码编译成与平台无关的字节码，然后由JVM负责读取字节码并在实际硬件架构上运行。JVM的主要作用包括以下几个方面：1.跨平台性-JVM是Java语言“一次编写，到处运行”（WriteOnce,Ru

3、JavaWeb-Ajax/Axios-前端工程化-Element
所谓远行Misnearch
#JavaWeb前端ajaxelementuijava前端框架
P34Ajax介绍Ajax:AsynchroousJavaScriptAndXML，异步的JS和XMLJS网页动作，XML一种标记语言，存储数据，作用：数据交换：通过Ajax给服务器发送请求，并获取服务器响应的数据异步交互：在不重新加载整个页面的情况下，与服务器交换数据并实现更新部分网页的技术，例如：搜索联想、用户名是否可用的校验等等。同步与异步：同步：服务器在处理中客户端要处于等待状态，输入域名

docker怎么端口映射
Lance_mu
docker容器运维
1、默认固定的端口#Web服务器：WebApache或Nginx通常使用80端口HTTP：80HTTPS：443#数据库服务器MySQL：3306PostgreSQL：5432MongoDB：27017Redis：6379#邮件服务器SMTP：25POP3：110IMAP：143#其他服务SSH：22FTP：21DNS（域名解析）：53代理服务器Squid：3128版本控制系统Git：9418(S

MyBatis高级面试题-2024
my_styles
mybatisjava开发语言面试题
MyBatis的核心组件有哪些？首先第一个是，SqlSessionFactory，它就像是一个会话工厂。它的任务是创建SqlSession对象，这个对象是我们与数据库交互的主要途径。SqlSessionFactory的作用很重要，因为它可以帮我们配置数据库连接信息和事务管理等。一旦这个工厂被建立起来，它就会加载一些必要的配置和映射文件，为后续的数据库操作提供一个可靠的基础。第二个是SqlSessi

枚举使用笔记
万变不离其宗_8
项目笔记笔记
1.java枚举怎么放在方法上面的注释里面/***保存*@paramuserId用户id*@paramtype见枚举{@linkcom.common.enums.TypeEnum}*@return*/voidsave(LonguserId,Stringtype);

Python dict字符串转json对象，小数精度丢失问题
朝如青丝 暮成雪
jsonpython
一前言JSON(JavaScriptObjectNotation)是一种轻量级的数据交换格式，dict是Python的一种数据格式。本篇介绍一个float数据转换时精度丢失的案例。二问题描述importjsontest_str1='{"π":3.1415926535897932384626433832795028841971}'test_str2='{"value":10.00000}'print

java实体中返回前端的double类型四舍五入（格式化）
婲落ヽ紅顏誶
java
根据业务，需要通过后端给前端返回部分double类型的数值，一般需要保留两位小数，使用jackson转换对象packagecom.ruoyi.common.core.config;importcom.fasterxml.jackson.core.JsonGenerator;importcom.fasterxml.jackson.databind.JsonSerializer;importcom.f

高阶SQL语句（二）
www.mcb.com
数据库mysql
一子查询也被称作内查询或者嵌套查询，是指在一个查询语句里面还嵌套着另一个查询语句。子查询语句是先于主查询语句被执行的，其结果作为外层的条件返回给主查询进行下一步的查询过滤。①子语句可以与主语句所查询的表相同，也可以是不同表②子语句中的sql语句是为了，最后过滤出一个结果集，用于主语句的判断条件③in:将主表和子表关联/连接的语法环境准备：mysql>usekgc_ky35;Readingtable

Django forms组件
在飞行-米龙
Djangodjangopython后端
【一】引入【1】实现登陆验证功能（1）需求分析登陆验证需要前后端交互，采用form表单提交数据对数据进行校验用户名必须以英文大写字母开头密码必须大于三位数反馈给用户错误的信息除了反馈错误的信息还有保留原始输入内容（2）后端代码使用user_info_dict字典每次刷新存储存储前端发送的信息存储后端进行验证的信息defhome(request):#每次后刷新这个信息字典user_info_dict

Java中HashMap底层数据结构及主要参数?
山间漫步人生路
java数据结构开发语言
在Java中，HashMap的底层数据结构主要基于数组和链表，同时在Java8及以后的版本中，当链表长度超过一定阈值时，链表会转换为红黑树来优化性能。这种结构结合了数组和链表的优点，既提供了快速的随机访问，又允许动态地扩展存储桶的大小。HashMap的主要参数包括：初始容量（InitialCapacity）：这是HashMap在创建时设定的桶数组的大小。默认值为16。这个值可以根据预计存储的键值对

Java学习笔记01
.wsy.
日常java学习笔记
1.1Java简介Java的前身是Oak，詹姆斯·高斯林是java之父。1.2Java体系Java是一种与平台无关的语言，其源代码可以被编译成一种结构中立的中间文件（.class，字节码文件）于Java虚拟机上运行。1.2.3专有名词JDK提供编译、运行Java程序所需要的种种工具及资源。JRE是运行Java所依赖的环境的集合。JVM是一个虚构出来的计算机，通过在实际的计算机上仿真模拟各种计算机功

Webpack构建优化——区分环境
oWSQo
为什么需要区分环境在开发网页的时候，一般都会有多套运行环境，例如：在开发过程中方便开发调试的环境。发布到线上给用户使用的运行环境。这两套不同的环境虽然都是由同一套源代码编译而来，但是代码内容却不一样，差异包括：线上代码被特殊压缩过。开发用的代码包含一些用于提示开发者的提示日志，这些日志普通用户不可能去看它。开发用的代码所连接的后端数据接口地址也可能和线上环境不同，因为要避免开发过程中造成对线上数据

Java回溯知识点（含面试大厂题和源码）
一成码农
java面试开发语言
回溯算法是一种通过遍历所有可能的候选解来寻找所有解的算法，如果候选解被确认不是一个解（或至少不是最后一个解），回溯算法会通过在上一步进行一些变化来丢弃这个解，即“回溯”并尝试另一个候选解。回溯法通常用递归方法来实现，在解决排列、组合、选择问题时非常有效。回溯算法的核心要点：路径：也就是已经做出的选择。选择列表：也就是你当前可以做的选择。结束条件：也就是到达决策树底层，无法再做出选择的条件。回溯算法

Azkaban各种类型的Job编写
__元昊__
一、概述原生的Azkaban支持的plugin类型有以下这些：command：Linuxshell命令行任务gobblin：通用数据采集工具hadoopJava：运行hadoopMR任务java：原生java任务hive：支持执行hiveSQLpig：pig脚本任务spark：spark任务hdfsToTeradata：把数据从hdfs导入TeradatateradataToHdfs：把数据从Te

java基础相关面试题详细总结
。。。。。96
java开发语言
1.Java中的数据类型有哪些？答：Java中的数据类型包括基本数据类型（如整数、浮点数、字符等）和引用数据类型（如类、接口、数组等）。2.什么是面向对象编程（OOP）？答：面向对象编程是一种编程范式，它将数据和对数据的操作封装在一起，形成对象。通过对象之间的交互来实现程序的功能。3.解释类和对象的关系。答：类是对象的抽象描述，而对象是类的具体实例。一个类可以创建多个对象，每个对象都具有类中定义的

Python Flask 使用数据库
安果移不动
pythonflask开发语言
pipinstallflask_sqlalchemy官方文档：Flask-SQLAlchemy—Flask-SQLAlchemyDocumentation(3.1.x)为了不报错也需要导入另外两个库#pipinstallflask_sqlalchemy#pipinstallmysqlclient完整代码importosfromflaskimportFlaskfromflask_sqlalchemy

Web前端Html的表单
任家伟
前端html
表单的关键字：form标签表示一个表单区域action=“后端地址”method=“提交数据方式:get/post”input单行输入框type=“text”文本name=“定义名称名字自定义”向后端提交的键readonly=“readonly”只读，不可修改，但是可以提交disabled=“disabled”禁用组件不可修改，不能提交type=“password”密码框type=“radio”单

第七章 索引及执行计划，存储引擎
执笔为剑
#MySQL运维篇编辑器mysql
第七章索引及执行计划，存储引擎1，索引及执行计划1，作用：提供类似书目录的作用，目的是优化查询2，所用的种类（根据算法）B树索引Hash索引R树FulltextGIS3，B树基于不同的查找算法分类介绍B-tree：在范围查询方面提供了更好的性能（>showengines;#存储引擎作用在表上，不同的表可能有不同的存储引擎mysql>select@@default_storage_engine;#查

Thinkphp - 详细实现网站系统登录功能，附带 Mysql 数据库设置、Web 前端展示界面、信息校验等（详细代码，即设计过程）
王佳斌
+Thinkphpmysql前端数据库
前言登录功能，是我们几乎开发每个系统都必须的模块。登录功能设计思路，主要包括几个方面。用户输入网址展示登录页面用户输入用户名，密码等点击登录进行信息校验校验通过之后，记录用户登录信息，跳转指定页面用户校验失败，提示失败信息页面目录具体功能实现为了快速搭建可用、美观的页面，我们采用一个比较成熟的前端框架Bootstrap。下面我们到Bootstrap的官网Bootsrap官网下载bootstrap。

设置mysql 数据库和表 的编码方式UTF-8
盖盖衍上
中间件数据库mysqloracle
要设置MySQL数据库表和字段的编码方式为UTF-8，可以使用下面的SQL语句：1.设置数据库默认编码为UTF-8：ALTERDATABASEyour_database_nameCHARACTERSETutf8mb4COLLATEutf8mb4_unicode_ci;2.创建表时指定编码为UTF-8：CREATETABLEyour_table_name(column1VARCHAR(100)CHA

【二】【设计模式】建造者模式
妖精七七_
设计模式设计模式建造者模式
建造者模式的引入//C10_1.cpp#include#include"SystemConfig.h"intmain(){SystemConfigconfig("mysql://127.0.0.1/","xiaomu","xiaomumemeda","redis://127.0.0.1/","xiaomuredis","xiaomuredispw","kafka://127.0.0.1","xia

javascript 日期转换为时间戳，时间戳转换为日期的函数
cdcdhj
javascript学习日记javascript开发语言ecmascript
日期转化为时间戳，主要用valueOf()来进行转化为毫秒时间戳，getTime()IOS系统无法解析转换，所以都有valueOf()letgetTimestampOrDate=function(timestamp){lettimeStamp='';constregex=/^\d{4}(-|\/)\d{2}(-|\/)\d{2}$/;constregex2=/^\d{4}(-|\/)\d{2}(-

Java面试题：解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用，Java中的多线程是如何实现的，Java垃圾回收机制的基本原理，并讨论常见的垃圾回收算法
杰哥在此
Java系列javajvm算法面试
Java内存模型与多线程的深入探讨在Java的世界里，内存模型和多线程是开发者必须掌握的核心知识点。它们不仅关系到程序的性能和稳定性，还直接影响到系统的可扩展性和可靠性。下面，我将通过三个面试题，带领大家深入理解Java内存模型、多线程以及并发编程的相关原理和实践。面试题一：请解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用。关注点：JVM内存结构的基本组成堆、栈、方法区的功能和

Linux（centos7）部署hive
灯下夜无眠
Linuxlinuxhive运维dbeaverhive客户端
前提环境：已部署完hadoop(HDFS、MapReduce、YARN)1、安装元数据服务MySQL切换root用户#更新密钥rpm--importhttps://repo.mysql.com/RPM-GPG-KEY-mysqL-2022#安装Mysqlyum库rpm-Uvhhttp://repo.mysql.com//mysql57-community-release-el7-7.noarch.

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.