Spring工程启动自动更新Oracle表结构和给字段添加注释

在我们日常工作中，每次给正式环境升级时，经常会忘了更新数据库，导致系统使用中报错，能实现系统启动时自动更新表就好了。

首先对于自动建表Hibernate已经帮我们实现，就不自己写代码了，下面附上hibernate配置：

    
    
        
        
        
            
                
                
                
            
        
        
            
                ${approval.db.username}
            
        
    

其中dataSource是你的连接数据源，packagesToScan是实体类所在包地址，generateDdl为true时工程自动更新表结构，不会删掉重建，hibernate.default_schema指定schema，否则同一个库下别的用户有同名表会创建失败。

记得maven中需要引入hibernate的包依赖，如下：

        
            org.hibernate
            hibernate-entitymanager
            4.3.11.Final
        

然后我们说下如何实现更新oracle字段注释：

首先添加注解类Comment

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/***
 * 表字段注释注解
 *
 * @author 杨红杰
 * @date 2018-03-05
 */
@Target({ ElementType.FIELD })
@Retention(RetentionPolicy.RUNTIME)
public @interface Comment {
	String value();
}

然后在实体类上添加对应注解，具体如下：

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

import lombok.Data;
import cn.gtmap.approval.datasource.Comment;

/**
 * 档案表
 */
@Data
@Entity
@Table(name = "ARCHIVE_GD")
@org.hibernate.annotations.Table(appliesTo = "ARCHIVE_GD",comment="档案表")
public class ArchiveGd implements java.io.Serializable {
    @Id
    @Comment("主键")
    @Column(name = "ARCHIVE_GD_ID", columnDefinition = "VARCHAR2(32)")
    private String archiveGdId;

    @Comment("档案返回id")
    @Column(name = "ARCHIVEPROJECTID", columnDefinition = "VARCHAR2(32)")
    private String archiveprojectid;
}

@Entity注解是Hibernate自动建表必须的配置；

@Table是指定表名；

@org.hibernate.annotations.Table(appliesTo = "ARCHIVE_GD",comment="档案表")这个是给表加表注释；

@Comment("档案返回id")是添加字段注释

@Column(name = "ARCHIVEPROJECTID", columnDefinition = "VARCHAR2(32)")设置字段名及字段相关属性。

最后我们创建一个系统启动时执行的类，该类需要实现InitializingBean接口，具体如下：

import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Table;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang.ArrayUtils;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import cn.gtmap.approval.entity.BlBuildlanditem;
import cn.gtmap.approval.utils.ClassUtil;
import cn.gtmap.common.core.support.mybatis.page.repository.Repo;

/***
 * 数据初始化
 *
 * @author 杨红杰
 * @date 2018-03-05
 */
@Component
public class DataInit implements InitializingBean {
    @Autowired
    public Repo repository;

    @Override
    public void afterPropertiesSet() throws Exception {
    	initTableComment();
    }

    /**
     * 执行sql语句
     * @param sql
     */
    private void executeSql(String sql) {
        Map paramMap = new HashMap();
        paramMap.put("sql", sql);
        repository.update("updateBySql", paramMap);
    }

    /**
     * 初始化表字段注释
     */
    private void initTableComment() {
        // 获取特定包下所有的类
        List> clsList = ClassUtil.getAllClassByPackageName(BlBuildlanditem.class.getPackage());
        if (CollectionUtils.isNotEmpty(clsList)) {
            for (Class cls : clsList) {
                // 选出包含注解@Entity和@Table的类
                if (cls.isAnnotationPresent(Entity.class) && cls.isAnnotationPresent(Table.class)) {
                    Table table = cls.getAnnotation(Table.class);
                    Field[] fields = cls.getDeclaredFields();
                    if (ArrayUtils.isNotEmpty(fields)) {
                        for (Field field : fields) {
                            // 选出包含注解@Comment和@Column的类
                            if (field.isAnnotationPresent(Comment.class) && field.isAnnotationPresent(Column.class)) {
                                Comment comment = field.getAnnotation(Comment.class);
                                Column column = field.getAnnotation(Column.class);
                                String sql = "comment on column " + table.name() + "." + column.name() + " is '" + comment.value() + "'";
                                executeSql(sql);
                            }
                        }
                    }
                }
            }
        }
    }
}

ClassUtil

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.net.JarURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

import lombok.extern.slf4j.Slf4j;

/***
 * 获取包内所有类
 *
 * @author 杨红杰
 * @date 2018-03-05
 */
@Slf4j
public class ClassUtil {

    /**
     * 通过包名获取包内所有类
     *
     * @param pkg
     * @return
     */
    public static List> getAllClassByPackageName(Package pkg) {
        String packageName = pkg.getName();
        // 获取当前包下以及子包下所以的类
        List> returnClassList = getClasses(packageName);
        return returnClassList;
    }

    /**
     * 通过接口名取得某个接口下所有实现这个接口的类
     */
    public static List> getAllClassByInterface(Class c) {
        List> returnClassList = null;

        if (c.isInterface()) {
            // 获取当前的包名
            String packageName = c.getPackage().getName();
            // 获取当前包下以及子包下所以的类
            List> allClass = getClasses(packageName);
            if (allClass != null) {
                returnClassList = new ArrayList>();
                for (Class cls : allClass) {
                    // 判断是否是同一个接口
                    if (c.isAssignableFrom(cls)) {
                        // 本身不加入进去
                        if (!c.equals(cls)) {
                            returnClassList.add(cls);
                        }
                    }
                }
            }
        }

        return returnClassList;
    }

    /**
     * 取得某一类所在包的所有类名 不含迭代
     */
    public static String[] getPackageAllClassName(String classLocation, String packageName) {
        // 将packageName分解
        String[] packagePathSplit = packageName.split("[.]");
        String realClassLocation = classLocation;
        int packageLength = packagePathSplit.length;
        for (int i = 0; i < packageLength; i++) {
            realClassLocation = realClassLocation + File.separator + packagePathSplit[i];
        }
        File packeageDir = new File(realClassLocation);
        if (packeageDir.isDirectory()) {
            String[] allClassName = packeageDir.list();
            return allClassName;
        }
        return null;
    }

    /**
     * 从包package中获取所有的Class
     *
     * @param packageName
     * @return
     */
    public static List> getClasses(String packageName) {

        // 第一个class类的集合
        List> classes = new ArrayList>();
        // 是否循环迭代
        boolean recursive = true;
        // 获取包的名字 并进行替换
        String packageDirName = packageName.replace('.', '/');
        // 定义一个枚举的集合 并进行循环来处理这个目录下的things
        Enumeration dirs;
        try {
            dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
            // 循环迭代下去
            while (dirs.hasMoreElements()) {
                // 获取下一个元素
                URL url = dirs.nextElement();
                // 得到协议的名称
                String protocol = url.getProtocol();
                // 如果是以文件的形式保存在服务器上
                if ("file".equals(protocol)) {
                    // 获取包的物理路径
                    String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
                    // 以文件的方式扫描整个包下的文件 并添加到集合中
                    findAndAddClassesInPackageByFile(packageName, filePath, recursive, classes);
                } else if ("jar".equals(protocol)) {
                    // 如果是jar包文件
                    // 定义一个JarFile
                    JarFile jar;
                    try {
                        // 获取jar
                        jar = ((JarURLConnection) url.openConnection()).getJarFile();
                        // 从此jar包 得到一个枚举类
                        Enumeration entries = jar.entries();
                        // 同样的进行循环迭代
                        while (entries.hasMoreElements()) {
                            // 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
                            JarEntry entry = entries.nextElement();
                            String name = entry.getName();
                            // 如果是以/开头的
                            if (name.charAt(0) == '/') {
                                // 获取后面的字符串
                                name = name.substring(1);
                            }
                            // 如果前半部分和定义的包名相同
                            if (name.startsWith(packageDirName)) {
                                int idx = name.lastIndexOf('/');
                                // 如果以"/"结尾 是一个包
                                if (idx != -1) {
                                    // 获取包名 把"/"替换成"."
                                    packageName = name.substring(0, idx).replace('/', '.');
                                }
                                // 如果可以迭代下去 并且是一个包
                                if ((idx != -1) || recursive) {
                                    // 如果是一个.class文件 而且不是目录
                                    if (name.endsWith(".class") && !entry.isDirectory()) {
                                        // 去掉后面的".class" 获取真正的类名
                                        String className = name.substring(packageName.length() + 1, name.length() - 6);
                                        try {
                                            // 添加到classes
                                            classes.add(Class.forName(packageName + '.' + className));
                                        } catch (ClassNotFoundException e) {
                                            log.error(e.getMessage(), e);
                                        }
                                    }
                                }
                            }
                        }
                    } catch (IOException e) {
                        log.error(e.getMessage(), e);
                    }
                }
            }
        } catch (IOException e) {
            log.error(e.getMessage(), e);
        }

        return classes;
    }

    /**
     * 以文件的形式来获取包下的所有Class
     *
     * @param packageName
     * @param packagePath
     * @param recursive
     * @param classes
     */
    public static void findAndAddClassesInPackageByFile(String packageName, String packagePath, final boolean recursive, List> classes) {
        // 获取此包的目录 建立一个File
        File dir = new File(packagePath);
        // 如果不存在或者 也不是目录就直接返回
        if (!dir.exists() || !dir.isDirectory()) {
            return;
        }
        // 如果存在 就获取包下的所有文件 包括目录
        File[] dirfiles = dir.listFiles(new FileFilter() {
            // 自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)
            @Override
            public boolean accept(File file) {
                return (recursive && file.isDirectory()) || (file.getName().endsWith(".class"));
            }
        });
        // 循环所有文件
        for (File file : dirfiles) {
            // 如果是目录 则继续扫描
            if (file.isDirectory()) {
                findAndAddClassesInPackageByFile(packageName + "." + file.getName(), file.getAbsolutePath(), recursive, classes);
            } else {
                // 如果是java类文件 去掉后面的.class 只留下类名
                String className = file.getName().substring(0, file.getName().length() - 6);
                try {
                    // 添加到集合中去
                    classes.add(Class.forName(packageName + '.' + className));
                } catch (ClassNotFoundException e) {
                    log.error(e.getMessage(), e);
                }
            }
        }
    }
}