之前在博客园看到的一个文章，基本可用，不过不太全，自己重新记录一下。
以下摘自原文，我自己也没接触过Annotation,只是用到了才去简单了解一下。
“有了一个框架，只需要配置好数据库连接，就可以在java代码层操控database，对于写个model便在数据库中创建了一张表而感到十分神奇，隐约想起以前看《Thinking in Java》中关于注解（Annotation）一张中对于自动生成SQL语句的操作。
首先略微介绍下注解（亦称为与数据metadata(ORM-对象/关系映射中的核心)）。
Annotation源自JavaSE1.5，内置3个标准注解，4个元注解：
（1）java.lang.*中的@Override，@Deprecated, @SuppressWarnings
（2）java.lang.annotations.*中的@Target, @Inherited, @Retention, @Documented
对于后4个元注解，稍后再在代码中解释。
对于一个创建表的SQL Create语句，我们要确定几个元素：表名，列名，列名类型，类型长度，约束等，这些都可以在实体类的属性加以注解说明来实现。”
对于表名注解：
package annotiation;
import java.lang.annotation.*;
@Inherited // 允许子类继承父类中的注解
@Documented // 将此注解包含在Javadoc中
@Target(ElementType.TYPE) // 类、接口（包括注解类型）或枚举类型声明
@Retention(RetentionPolicy.RUNTIME) // VM在运行时保留注解，从而通过反射获取信息
public @interface DBTable {
public String name() default ""; // 注解未赋值是，默认为空
}
对于字段注解：（许多类型需要自己去定义，在后边的拼接sql语句时候简单修改就可以）
package annotiation;
import java.lang.annotation.*;
@Inherited
@Documented
@Target(ElementType.FIELD) // 域声明（包括枚举类型实例）
@Retention(RetentionPolicy.RUNTIME)
public @interface SQLInteger {
String name() default "";
Constraints constraints() default @Constraints; // 约束注解，详细见下面代码
}
package annotiation;
import java.lang.annotation.*;
@Inherited
@Documented
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Constraints {
boolean primaryKey() default false; // 主键，默认为空
boolean allowNull() default true; // 默认允许为空
boolean unique() default false; // 默认允许重复
boolean auto() default false; //自增，默认否
}
实体类：
package model;
import annotiation.*;
@DBTable(name = "User") // 设置表名为User
public class User {
@SQLString(size = 50) // 设置字段 username, varchar(50)
String username;
@SQLString(size = 50)
String password;
@SQLString(size = 30, constraints = @Constraints(primaryKey = true)) // 设置为主键
String handle;
static int memberCount;
public String getUsername() { return username; }
public void setUsername(String username) { this.username = username; }// 个人感觉set方法可以去掉
public String getPassword() { return password; }
public void setPassword(String password) { this.password = password; }
public String getHandle() { return handle; }
public void setHandle(String handle) { this.handle = handle; }
public String toString() { return handle; }
}
根据注解和反射拼接SQL语句
package creator;
import java.lang.reflect.*;
import java.lang.annotation.*;
import java.util.*;
import annotiation.Constraints;
import annotiation.DBTable;
import annotiation.SQLString;
public class TableCreator {
private static String getConstraints(Constraints constraints) { // 获取字段约束属性
String cons = "";
if (!constraints.allowNull()) {
cons += " NOT NULL";
}
if (constraints.primaryKey()) {
cons += " PRIMARY KEY";
}
if (constraints.unique()) {
cons += " UNIQUE";
}
if(contraints.auto()){
cons+=" AUTO_INCREMENT";
}
return cons;
}
//这边还需要通过IO来遍历指定model包下所有实体类，
private static ArrayList<String> getTables(String packagePath) {
ArrayList<String> tables = new ArrayList<String>();
List
classNames=PackageUtil.getClassName(packagePath);
//这里是我自己写的，为的是在生成数据库表的时候可以单独针对一个实体类生成数据库表
if(classNames.size()<1){//如果获取到的包内的类的数量小于1个，直接将路径返回
tables.add(packagePath);
}else{
for (String cl : PackageUtil.getClassName(packagePath)) {//原方法是Package.getPackage()，我不知道怎么用，就在往上找了一个第三方的获取包内实体类的工具代替。
tables.add(cl);
}
}
}
public static String getSql(String packagePath) throws ClassNotFoundException {
List
sqlList=new ArrayList<>();
String sql = null;
ArrayList
tables = getTables(packagePath);
// System.out.println("tables: " + tables);
// String[] tables = {"com.qoniu.test.pojo.Head"};
for (String className : tables) {
Class<?> cl = Class.forName(className); // 通过类名得到该实体类
DBTable dbtable = cl.getAnnotation(DBTable.class); // 通过注解得到表名
// 批量生成数据库表的时候，考虑到有继承类的问题，我不清楚有没有更好的办法，我自己的方案是对于继承的父类不作注解，得到的表明为空，这样就可以跳过了
if(dbtable==null){
continue;
}
String tableName = dbtable.name().length() > 1 ? dbtable.name() : cl.getName().toUpperCase();
/* comments
System.out.println("tableName: " + tableName);
*/
List
columns = new ArrayList
(); for (Field field : cl.getDeclaredFields()) { // 得到该类下所有属性 String columnName = null; Annotation[] annotations = field.getAnnotations(); if (annotations.length < 1) { continue; } //这里是对实体类的注解进行解析，可自由定义 if (annotations[0] instanceof SQLString) { SQLString sStr = (SQLString)annotations[0]; columnName = sStr.name().length() < 1 ? field.getName() : sStr.name(); columns.add(columnName + " VARCHAR(" + sStr.size() + ")" + getConstraints(sStr.constraints())); } if (annotations[0] instanceof SQLInteger) { SQLInteger sStr = (SQLInteger)annotations[0]; columnName = sStr.name().length() < 1 ? field.getName() : sStr.name(); columns.add(columnName + " int(" + sStr.size() + ")" + getConstraints(sStr.constraints())); } if (annotations[0] instanceof SQLDate) { SQLDate sStr = (SQLDate)annotations[0]; columnName = sStr.name().length() < 1 ? field.getName() : sStr.name(); columns.add(columnName + " datetime" ); } } StringBuilder sb = new StringBuilder("Create Table if not exists " + tableName + "("); //对于每个表里通用的字段直接写了，一般这个是放在父类的，因为我不知道怎么在生成语句的时候去把父类的一起生成，就这么写了 sb.append("\n id int(12) PRIMARY KEY AUTO_INCREMENT,"); sb.append("\n stat int(10),"); sb.append("\n createTime datetime,"); sb.append("\n userId VARCHAR(50),"); for (String column : columns) { sb.append("\n " + column + ","); // 拼接各个字段的定义语句 } sql = sb.substring(0, sb.length() - 1) +");"; System.out.println("\n=========\n" + sql + "\n=========\n");// 测试输出 sqlList.add(sql); } return sqlList; } }
有了sql语句，通过JDBC链接数据库执行就可以了
package dbconnect;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class DBConnect {
static Connection connect;
static String driver = "com.mysql.jdbc.Driver";
static String password = "thoupin'spassword";
static String username = "thoupin";
static String dbName = "test";
static String url = "jdbc:mysql://localhost/" + dbName;
public static void connect() { // 连接
try {
Class.forName(driver);
} catch (ClassNotFoundException e) {
System.out.println("Can not find the Driver!");
e.printStackTrace();
}
try {
connect = DriverManager.getConnection(url, username, password);
} catch (SQLException e) {
System.out.println("Database connect failed!");
e.printStackTrace();
}
}
public static void execute(String sql) { // 执行语句
Statement stmt;
try {
stmt = connect.createStatement();
stmt.executeUpdate(sql);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void close() { // 关闭连接
if (connect != null) {
try {
connect.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
最后是主程序：
public static void main(String[] args) {
DBConnect.connect();
String packagePath="com.qoniu.mes.pojo";//必须是实体类包名或者实体类名，注意实体类大小写
try {
List<String> sqls=TableCreator.getSql(packagePath);
for(String sql:sqls){//循环输出执行
DBConnect.execute(sql);
}
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
DBConnect.close();
}
PackageUtile工具类：获取包内实体类集合
package com.qoniu.mes.tools;
import java.io.File;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
public class PackageUtil {
public static void main(String[] args) throws Exception {
String packageName = "com.qoniu.test.pojo.Head";
// List<String> classNames = getClassName(packageName);
List<String> classNames = getClassName(packageName, false);
if (classNames != null) {
for (String className : classNames) {
System.out.println(className);
}
}
}
/**
* 获取某包下（包括该包的所有子包）所有类
* @param packageName 包名
* @return 类的完整名称
*/
public static List<String> getClassName(String packageName) {
return getClassName(packageName, true);
}
/**
* 获取某包下所有类
* @param packageName 包名
* @param childPackage 是否遍历子包
* @return 类的完整名称
*/
public static List<String> getClassName(String packageName, boolean childPackage) {
List<String> fileNames = null;
ClassLoader loader = Thread.currentThread().getContextClassLoader();
String packagePath = packageName.replace(".", "/");
URL url = loader.getResource(packagePath);
if (url != null) {
String type = url.getProtocol();
if (type.equals("file")) {
fileNames = getClassNameByFile(url.getPath(), null, childPackage);
} else if (type.equals("jar")) {
fileNames = getClassNameByJar(url.getPath(), childPackage);
}
} else {
fileNames = getClassNameByJars(((URLClassLoader) loader).getURLs(), packagePath, childPackage);
}
return fileNames;
}
/**
* 从项目文件获取某包下所有类
* @param filePath 文件路径
* @param className 类名集合
* @param childPackage 是否遍历子包
* @return 类的完整名称
*/
private static List<String> getClassNameByFile(String filePath, List<String> className, boolean childPackage) {
List<String> myClassName = new ArrayList<String>();
File file = new File(filePath);
File[] childFiles = file.listFiles();
for (File childFile : childFiles) {
if (childFile.isDirectory()) {
if (childPackage) {
myClassName.addAll(getClassNameByFile(childFile.getPath(), myClassName, childPackage));
}
} else {
String childFilePath = childFile.getPath();
if (childFilePath.endsWith(".class")) {
childFilePath = childFilePath.substring(childFilePath.indexOf("\\classes") + 9, childFilePath.lastIndexOf("."));
childFilePath = childFilePath.replace("\\", ".");
myClassName.add(childFilePath);
}
}
}
return myClassName;
}
/**
* 从jar获取某包下所有类
* @param jarPath jar文件路径
* @param childPackage 是否遍历子包
* @return 类的完整名称
*/
private static List<String> getClassNameByJar(String jarPath, boolean childPackage) {
List<String> myClassName = new ArrayList<String>();
String[] jarInfo = jarPath.split("!");
String jarFilePath = jarInfo[0].substring(jarInfo[0].indexOf("/"));
String packagePath = jarInfo[1].substring(1);
try {
JarFile jarFile = new JarFile(jarFilePath);
Enumeration<JarEntry> entrys = jarFile.entries();
while (entrys.hasMoreElements()) {
JarEntry jarEntry = entrys.nextElement();
String entryName = jarEntry.getName();
if (entryName.endsWith(".class")) {
if (childPackage) {
if (entryName.startsWith(packagePath)) {
entryName = entryName.replace("/", ".").substring(0, entryName.lastIndexOf("."));
myClassName.add(entryName);
}
} else {
int index = entryName.lastIndexOf("/");
String myPackagePath;
if (index != -1) {
myPackagePath = entryName.substring(0, index);
} else {
myPackagePath = entryName;
}
if (myPackagePath.equals(packagePath)) {
entryName = entryName.replace("/", ".").substring(0, entryName.lastIndexOf("."));
myClassName.add(entryName);
}
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
return myClassName;
}
/**
* 从所有jar中搜索该包，并获取该包下所有类
* @param urls URL集合
* @param packagePath 包路径
* @param childPackage 是否遍历子包
* @return 类的完整名称
*/
private static List<String> getClassNameByJars(URL[] urls, String packagePath, boolean childPackage) {
List<String> myClassName = new ArrayList<String>();
if (urls != null) {
for (int i = 0; i < urls.length; i++) {
URL url = urls[i];
String urlPath = url.getPath();
// 不必搜索classes文件夹
if (urlPath.endsWith("classes/")) {
continue;
}
String jarPath = urlPath + "!/" + packagePath;
myClassName.addAll(getClassNameByJar(jarPath, childPackage));
}
}
return myClassName;
}
}
看了之后有什么优化建议欢迎提出，共同进步。