「java反射sql」Java反射是什么

今天给各位分享java反射sql的知识，其中也会对Java反射是什么进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、用Java反射+配置实现切换数据库
• 2、如何通过java反射将数据库表生成实体类
• 3、java反射 和数据库数据类型
• 4、如何编写Java的MyBatis框架中SQL语句映射部分
• 5、利用反射机制拼写SQL语句

用Java反射+配置实现切换数据库

说一个大概思路吧：

1.读取数据：从数据库中读取数据的同时，拿到元数据，即metadata;

2.实例化：通过类名，利用反射 实例你的实体类(类名可以和表名保持一致，这样就不用写额外的

映射了)，如果你只是想通过反射赋值的话，你也可以直接new个类；

3.方法调用：通过元数据，利用反射 得到你的set方法(方法名可以和字段名保持一致，否则你要写

出映射关系)；

如何通过java反射将数据库表生成实体类

首先有几点声明：

1、代码是在别人的基础进行改写的；

2、大家有什么改进的意见可以告诉我，也可以自己改好共享给其他人；

3、刚刚毕业，水平有限，肯定有许多不足之处；

4、希望刚刚学习java的同学能有所启发。

//这个是做转换的类，里面的DB只是封装了数据库的连接，大家可以用自己的，随意

package com.tt.util.gen.entity.tool;

import java.io.File;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStream;

import java.io.PrintWriter;

import java.sql.Connection;

import java.sql.DatabaseMetaData;

import java.sql.DriverManager;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.Date;

import java.util.List;

import java.util.Properties;

import com.tt.util.DB;

public class GenEntityMysql {

private String packageOutPath;// 指定实体生成所在包的路径

private String authorName;// 作者名字

private String tablename;// 表名

private String databasename;// 数据库名

private ListString tablenames;// 拿到对应数据库中所有的实体类（实体类需要与其他表明做区分）

private ListString colnames; // 列名集合

private ListString colTypes; // 列名类型集合

private boolean f_util = false; // 是否需要导入包java.util.*

private boolean f_sql = false; // 是否需要导入包java.sql.*

/*

* 构造函数

*/

public GenEntityMysql() {

// 使用properties读取配置文件

Properties prop = new Properties();

try {

InputStream genentity = getClass().getResourceAsStream(

"/genentity.properties");

prop.load(genentity);

if (genentity != null) {

genentity.close();

}

} catch (Exception e) {

System.out.println("file " + "catalogPath.properties"

+ " not found!\n" + e);

}

this.databasename = prop.getProperty("databasename").toString();

this.tablename = prop.getProperty("tablename").toString();

this.packageOutPath = prop.getProperty("packageOutPath").toString();

this.authorName = prop.getProperty("authorName").toString();

}

// 创建多个实体类

private void genEntity(ListString tablenames, Connection conn) {

// 使用第归生成文件

for (String tablename : tablenames) {

this.genEntity(tablename, conn);

}

}

// 创建单个实体类

private void genEntity(String tablename, Connection conn) {

String sql = "select * from " + tablename;

PreparedStatement pstmt = null;

ResultSetMetaData rsmd = null;

try {

pstmt = DB.getPStmt(conn, sql);

rsmd = pstmt.getMetaData();

int size = rsmd.getColumnCount(); // 统计列

colnames = new ArrayListString();

colTypes = new ArrayListString();

for (int i = 0; i size; i++) {

colnames.add(rsmd.getColumnName(i + 1));

colTypes.add(rsmd.getColumnTypeName(i + 1));

if (colTypes.get(i).equalsIgnoreCase("datetime")) {

f_util = true;

}

if (colTypes.get(i).equalsIgnoreCase("image")

|| colTypes.get(i).equalsIgnoreCase("text")) {

f_sql = true;

}

}

System.out.println(colnames);

System.out.println(colTypes);

} catch (SQLException e1) {

// TODO Auto-generated catch block

e1.printStackTrace();

} finally {

DB.close(pstmt);

}

// 在内存中生成代码

String content = parse(tablename);

// 写入到文件中

try {

File directory = new File("");

String outputPath = directory.getAbsolutePath() + "/src/"

+ this.packageOutPath.replace(".", "/") + "/";

System.out.println("写出的路径:" + outputPath);

// 检测路径是否存在，不存在就创建路径

File path = new File(outputPath);

if (!path.exists() !path.isDirectory()) {

path.mkdir();

System.out.println(path.exists());

}

// 创建文件

outputPath += initcap(tablename) + ".java";

File file = new File(outputPath);

if (!file.exists()) {

file.createNewFile();

}

// 写出到硬盘

FileWriter fw = new FileWriter(file);

PrintWriter pw = new PrintWriter(fw);

pw.println(content);

pw.flush();

pw.close();

} catch (IOException e) {

e.printStackTrace();

}

}

private void getAllEntityTable(Connection conn, ListString tablenames) {

ResultSet rs = null;

try {

DatabaseMetaData dmd = (DatabaseMetaData) conn.getMetaData();

/*

* TABLE_CAT String = 表类别（可为 null）

* TABLE_SCHEM String = 表模式（可为null）

* TABLE_NAME String = 表名称

* TABLE_TYPE String = 表类型

*/

rs = dmd.getTables(null, null, "%", null);

while (rs.next()) {

tablenames.add(rs.getString("TABLE_NAME"));

}

} catch (SQLException e) {

e.printStackTrace();

} finally {

try {

rs.close();

} catch (SQLException e) {

e.printStackTrace();

}

}

}

/**

*

* @param tablename

* @return

*/

private String parse(String tablename) {

StringBuffer sb = new StringBuffer();

// 判断是否导入工具包

if (f_util) {

sb.append("import java.util.Date;\r\n");

}

if (f_sql) {

sb.append("import java.sql.*;\r\n");

}

sb.append("package " + this.packageOutPath + ";\r\n");

sb.append("\r\n");

// 注释部分

sb.append(" /**\r\n");

sb.append(" * " + tablename + " 实体类\r\n");

sb.append(" * " + new Date() + " " + this.authorName + "\r\n");

sb.append(" */ \r\n");

// 实体部分

sb.append("\r\n\r\npublic class " + initcap(tablename) + "{\r\n");

processAllAttrs(sb);// 属性

processAllMethod(sb);// get set方法

sb.append("}\r\n");

return sb.toString();

}

/**

* 功能：生成所有属性

*

* @param sb

*/

private void processAllAttrs(StringBuffer sb) {

for (int i = 0; i colnames.size(); i++) {

sb.append("\tprivate " + sqlType2JavaType(colTypes.get(i)) + " "

+ colnames.get(i) + ";\r\n");

}

}

/**

* 功能：生成所有方法

*

* @param sb

*/

private void processAllMethod(StringBuffer sb) {

for (int i = 0; i colnames.size(); i++) {

sb.append("\tpublic void set" + initcap(colnames.get(i)) + "("

+ sqlType2JavaType(colTypes.get(i)) + " " + colnames.get(i)

+ "){\r\n");

sb.append("\t\tthis." + colnames.get(i) + "=" + colnames.get(i)

+ ";\r\n");

sb.append("\t}\r\n");

sb.append("\tpublic " + sqlType2JavaType(colTypes.get(i)) + " get"

+ initcap(colnames.get(i)) + "(){\r\n");

sb.append("\t\treturn " + colnames.get(i) + ";\r\n");

sb.append("\t}\r\n");

}

}

/**

* 功能：将输入字符串的首字母改成大写

*

* @param str

* @return

*/

private String initcap(String str) {

char[] ch = str.toCharArray();

if (ch[0] = 'a' ch[0] = 'z') {

ch[0] = (char) (ch[0] - 32);

}

return new String(ch);

}

/**

* 功能：获得列的数据类型

*

* @param sqlType

* @return

*/

private String sqlType2JavaType(String sqlType) {

if (sqlType.equalsIgnoreCase("bit")) {

return "boolean";

} else if (sqlType.equalsIgnoreCase("tinyint")) {

return "byte";

} else if (sqlType.equalsIgnoreCase("smallint")) {

return "short";

} else if (sqlType.equalsIgnoreCase("int")) {

return "int";

} else if (sqlType.equalsIgnoreCase("bigint")) {

return "long";

} else if (sqlType.equalsIgnoreCase("float")) {

return "float";

} else if (sqlType.equalsIgnoreCase("decimal")

|| sqlType.equalsIgnoreCase("numeric")

|| sqlType.equalsIgnoreCase("real")

|| sqlType.equalsIgnoreCase("money")

|| sqlType.equalsIgnoreCase("smallmoney")) {

return "double";

} else if (sqlType.equalsIgnoreCase("varchar")

|| sqlType.equalsIgnoreCase("char")

|| sqlType.equalsIgnoreCase("nvarchar")

|| sqlType.equalsIgnoreCase("nchar")

|| sqlType.equalsIgnoreCase("text")) {

return "String";

} else if (sqlType.equalsIgnoreCase("datetime")) {

return "Date";

} else if (sqlType.equalsIgnoreCase("image")) {

return "Blod";

}

return null;

}

/**

* 出口 TODO

*

* @param args

*/

public static void main(String[] args) {

new GenEntityMysql().start();

}

private void start() {

// 创建连接

Connection conn = DB.getConn();

if (databasename != null !databasename.equals("")

tablename != null !tablename.equals("")) {

System.out.println("databasename 和 tablename 不能同时存在");

} else {

// 如果配置文件中有数据库名字，则可以拿到其中所有的实体类

if (databasename != null !databasename.equals("")) {

// 获取所有实体表名字

tablenames = new ArrayListString();

getAllEntityTable(conn, tablenames);

System.out.println(tablenames);

// 为每个实体表生成实体类

genEntity(tablenames, conn);

} else {

// 为指定实体表生成实体类

genEntity(tablename, conn);

}

// 关闭数据库连接

if (conn != null) {

DB.close(conn);

}

}

}

}

java反射 和数据库数据类型

这的关键在于你的columnValue的数据类型，你应该传入的是Timestamp，而这个set方法需要的是Datetime类型

如何编写Java的MyBatis框架中SQL语句映射部分

1..增删改查、参数、缓存

1.1 select 举例如下：

查询学员信息，一个String参数，参数标识为#{studentID}，并返回一个StudentEntity类型的对象

select id="getStudent" parameterType="String" resultMap="studentResultMap"

SELECT ST.STUDENT_ID,

ST.STUDENT_NAME,

ST.STUDENT_SEX,

ST.STUDENT_BIRTHDAY,

ST.CLASS_ID

FROM STUDENT_TBL ST

WHERE ST.STUDENT_ID = #{studentID}

/select

1.2 insert 举例如下：

插入数据，一个String参数，参数标识为#{studentID}，并返回一个StudentEntity类型的对象。

insert id="insertStudent" parameterType="StudentEntity"

INSERT INTO STUDENT_TBL (STUDENT_ID,

STUDENT_NAME,

STUDENT_SEX,

STUDENT_BIRTHDAY,

CLASS_ID)

VALUES (#{studentID},

#{studentName},

#{studentSex},

#{studentBirthday},

#{classEntity.classID})

/insert

1.3 update 举例如下：

更新学员信息

update id="updateStudent" parameterType="StudentEntity"

UPDATE STUDENT_TBL

SET STUDENT_TBL.STUDENT_NAME = #{studentName},

STUDENT_TBL.STUDENT_SEX = #{studentSex},

STUDENT_TBL.STUDENT_BIRTHDAY = #{studentBirthday},

STUDENT_TBL.CLASS_ID = #{classEntity.classID}

WHERE STUDENT_TBL.STUDENT_ID = #{studentID};

/update

1.4 delete 举例如下：

删除学员信息：

delete id="deleteStudent" parameterType="StudentEntity"

DELETE FROM STUDENT_TBL WHERE STUDENT_ID = #{studentID}

/delete

2.ResultMap

SQL映射xml文件是为了放置所有sql语句，需要定义一个workspace，正常是接口类的路径。SQL语句映射文件写好后，需要在MyBatis配置文件mappers标签中引用。

举例如下：

mappers

mapper resource="cn/tedu/ninixie/manager/data/mappers/UserMapper.xml" /

mapper resource="cn/tedu/ninixie/manager/data/mappers/StudentMapper.xml" /

mapper resource="cn/tedu/ninixie/manager/data/mappers/ClassMapper.xml" /

mapper resource="cn/tedu/ninixie/manager/data/mappers/TeacherMapper.xml" /

/mappers

当Java接口与xml文件在一个相对路径下，那么MyBaits配置文件的napper中可以不用声明。

ResultMaps的作用，就是简单的语句而不需要多余的结果映射，更多复杂的语句，除了只要一些绝对必须的语句描述关系以外，就不需要其它的了。

resultMap属性：type为java实体类；id为此resultMap的标识。

resultMap可以设置的映射：

2.1 constructor:用来将结果发射给一个实例化好的类的构造器

idArg_ID 参数：将结果集标记为ID,为了方便全局调用

arg –反射到构造器的通常结果

2.2 id结果，将结果集标记为ID，为了方便全局调用

2.3 result：反射到JavaBean的普通结果

2.4 association：复杂类型的结合，多个结果合成的类型

2.5 collection：复杂类型结合

2.6 resultMap的集合，也可以引用到其他

2.7 discriminator：使用一个结果值为了决定使用哪个结果集。

利用反射机制拼写SQL语句

你想insert还是select啊，新手吧，好多错哦

我想你的意思是想根据一个java bean类和table来生成insert语句，比如写一个UserBean（里面有get/set方法），建一个表usertable，然后自动生成insert语句,给你个示范：

/**

* 获取sql和params

*

* @param bean

* @param table

* @return

*/

public static Map getInsertSql(Object bean, String table) {

String sql = "insert into table (";

String values = "";

// params是插入的参数值，用于PreparedStatement.set...

ArrayList params = new ArrayList();

Map map = new HashMap();

// 取出bean里的所有字段

Class beanClass = bean.getClass();

Field[] fields = beanClass.getDeclaredFields();

// 将map里的值赋给bean

try {

for (int i = 0; i fields.length; i++) {

String fieldname = fields[i].getName();

if (i == 0)

sql += fieldname;

else

sql += ", " + fieldname;

// 调用get方法获取变量值

Class fieldtype = fields[i].getType();

String methodname = getMethodName(fieldname, "get");

Method method = beanClass.getMethod(methodname);

Object fieldvalue = method.invoke(bean);

if (i == 0)

values += "?";

else

values += ", ?";

params.add(fieldvalue);

}

} catch (Exception e) {

e.printStackTrace();

}

sql += ") values(" + values + ")";

map.put("sql", sql);

map.put("params", params);

return map;

}

/**

* 获取字段的get/set方法名

*

* @param fieldname

* @return

*/

private static String getMethodName(String fieldname, String type) {

char upper = Character.toUpperCase(fieldname.charAt(0));

return type + upper + fieldname.substring(1);

}

/**

* 设置参数：用于变量绑定中参数的设置

*

* @param pst

* @param params

* @throws SQLException

*/

public static void setStatementParameters(PreparedStatement pst,

Object[] params) throws SQLException {

for (int i = 0; i params.length; ++i) {

Object obj = params[i];

if (null == obj) {

pst.setNull(i + 1, Types.CHAR);

} else if (obj instanceof java.sql.Date) {

pst.setDate(i + 1, (java.sql.Date) obj);

} else if (obj instanceof java.sql.Timestamp) {

pst.setTimestamp(i + 1, (java.sql.Timestamp) obj);

} else {

pst.setObject(i + 1, obj);

}

}

}

public static void main(String[] args) throws SQLException {

UserBean user = new UserBean();

//user.setName(name);

//.....给user赋值

Map map = getInsertSql(user, "user_tab");

String sql = (String)map.get("sql");

ArrayList params = (ArrayList)map.get("params");

Connection conn = null;

PreparedStatement pstmt = null;

//....获取conn

pstmt = conn.prepareStatement(sql);

setStatementParameters(pstmt, params.toArray());

pstmt.execute();

pstmt.close();

conn.close();

}

关于java反射sql和Java反射是什么的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。