使用JAVA反射的利與弊

時間 2019-11-11

標籤使用 java 反射欄目 Java 简体版

原文原文鏈接

在Java的20週年的記念日的日子裏，讓咱們來從新溫習下Java裏面的高級知識，Java確定但願你們瞭解她，要否則你跟她每天相濡以沫了這麼長時間，讓她知道你居然不瞭解她，不在意她，那麼她該有多傷心呢，因此咱們不該該作一個負心漢，更不該該作一個忘恩負義的人，她教會了你生存的技能，因此咱們也應該將她發揚光大！
Java的核心技能有以下幾項：
（1）JVM的調優
（2）類加載器
（3）反射
（4）動態編譯
（5）動態代理
（6）註解
（7）多線程
（8）IO,NIO,Socket，Channel等網絡編程
除了JAVA的基礎，面向對象的思想外，這些既是java裏面核心技術，也是面試時候，面試官常常愛問的幾個知識，瞭解，熟悉和掌握他們的重要性不言而喻，今天就先來談談反射。

反射給java提供了，運行時獲取一個類實例的可能，這一點很是靈活，你僅僅傳一個類的全包名路徑，就能經過反射，來獲取對應的類實例，咱們通常會用Class類，來調用這個被反射的Objcet類下的，構造方法，屬性，或方法等，反射在一些開源框架裏用的很是之多，Spring，Struts，Hibnerate，MyBatics都有它的影子，反射雖然很靈活，可以使得寫的代碼，變的大幅精簡，因此在用的時候，必定要注意具體的應用場景，反射的優缺點以下：
優勢：
（1）可以運行時動態獲取類的實例，大大提升系統的靈活性和擴展性。
（2）與Java動態編譯相結合，能夠實現無比強大的功能
缺點：
（1）使用反射的性能較低
（2）使用反射相對來講不安全
（3）破壞了類的封裝性，能夠經過反射獲取這個類的私有方法和屬性
任何事物，都有兩面性，反射的優勢，也同是就是它的缺點，因此，沒有好與壞，只有最合適的場景，一陰一陽，纔是天道平衡的條件。
下面來看個，使用java反射，來自動封裝數據庫對應的表的例子，初學java的人都會給每一個實體類創建一個Dao對象，來專門操做這個對象對應的表，這樣作沒錯，很好，是分層，分工明確的一個表現，可是若是有幾十個實體類，那麼這種重複增刪改查的工做，就會大大增長，散仙初入門的時候也有如此的感覺，雖然咱們能夠經過，抽象類和接口，使用適配器的設計模式來簡化重複的代碼，可是不可避免的就是類的臃腫了，下面看看如何使用反射來搞定這麼多實體類的重複的增刪改查的代碼：
使用前提：
（1）每個實體類都會對應一個數據庫表
（2）每一個表的列，與對應的實體類的屬性名是同樣的
（3）實體類要提供基本的get或set方法

實體類以下： java

Java代碼 mysql

package com.qin.model;
public class Dog {
private int id;
private String name;
private String type;
private String color;
private int weight;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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 String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public int getWeight() {
return weight;
}
public void setWeight(int weight) {
this.weight = weight;
}
public Dog() {
// TODO Auto-generated constructor stub
}
public Dog(int id, String name, String type, String color, int weight) {
super();
this.id = id;
this.name = name;
this.type = type;
this.color = color;
this.weight = weight;
}
@Override
public String toString() {
return "Dog [id=" + id + ", name=" + name + ", type=" + type + ", color="
+ color + ", weight=" + weight + "]";
}
}

Java代碼面試

package com.qin.model;
public class Person {
private int id;
private String name;
private int age;
private String address;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public Person() {
// TODO Auto-generated constructor stub
}
public Person(int id, String name, int age, String address) {
super();
this.id = id;
this.name = name;
this.age = age;
this.address = address;
}
@Override
public String toString() {
return "Person [id=" + id + ", name=" + name + ", age=" + age
+ ", address=" + address + "]";
}
}

Java代碼 sql

package com.qin.db;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
/**
* 數據庫鏈接的
* 測試類
* @author qindongliang
*
*
* **/
public class ConnectionFactory {
public static Connection getCon()throws Exception{
Class.forName("com.mysql.jdbc.Driver");
//加上字符串編碼指定，防止亂碼
Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/rate?characterEncoding=utf8", "root", "qin");
return connection;
}
public static void main(String[] args) throws Exception {
Class.forName("com.mysql.jdbc.Driver");
Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/rate", "root", "qin");
System.out.println(connection);
connection.close();
}
}

Java代碼數據庫

package com.qin.commons;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import com.qin.db.ConnectionFactory;
import com.qin.model.Dog;
import com.qin.model.Person;
/***
* 反射自動查詢和封裝的類
*@author qindongliang
*
* */
public class CommonSupport {
/**
* @param obj須要保存的對象
* @param string 保存對象的sql語句
* */
public static String createSqlByObject(Object obj){
StringBuffer sb=new StringBuffer("insert into ");
//獲得對象的類
Class c=obj.getClass();
//獲得對象中的全部方法
Method[] ms=c.getMethods();
//獲得對象中全部的屬性,雖然在這個裏面就能獲取全部的字段名，但不建議這麼用，破壞類的封裝性
Field[] fs=c.getDeclaredFields();
//獲得對象類的名字
String cname=c.getName();
System.out.println("類名字： "+cname);
//表名字
String tableName=cname.split("\\.")[cname.split("\\.").length-1];
System.out.println("表名字： "+tableName);
//追加表名和（左邊的符號
sb.append(tableName).append(" (");
//存放列名的集合
List<String> columns=new ArrayList<String>();
//存放值的集合
List values=new ArrayList();
//遍歷方法
for(Method m:ms){
String methodName=m.getName();//獲取每個方法名
//只獲得具備get方法的屬性，getClass除外
if(methodName.startsWith("get")&&!methodName.startsWith("getClass")){
//System.out.println("屬性名："+methodName);
String fieldName = methodName.substring(3, methodName.length());
// System.out.println("字段名："+fieldName);
columns.add(fieldName);//將列名添加到列名的集合裏
try{
Object value=m.invoke(obj, null);
//System.out.println("執行方法返回的值："+value);
if(value instanceof String){
// System.out.println("字符串類型字段值："+value);
values.add("'"+value+"'");//加上兩個單引號，表明是字符串類型的
}else{
// System.out.println("數值類型字段值："+value);
values.add(value);//數值類型的則直接添加
}
}catch(Exception e){
e.printStackTrace();
}
}
}
for(int i=0;i<columns.size();i++){
String column=columns.get(i);
Object value=values.get(i);
System.out.println("列名："+column+" 值： "+value);
}
//拼接列名
for(int i=0;i<columns.size();i++){
if(i==columns.size()-1){
sb.append(columns.get(i)).append(" ) ");
}else{
sb.append(columns.get(i)).append(" , ");
}
}
System.out.println(" 拼接列名後的sql："+sb.toString());
sb.append(" values ( ");
//拼接值
for(int i=0;i<values.size();i++){
if(i==values.size()-1){
sb.append(values.get(i)).append(" ) ");
}else{
sb.append(values.get(i)).append(" , ");
}
}
System.out.println(" 拼接值後的sql："+sb.toString());
//返回組裝的sql語句
return sb.toString();
}
/**
* 將對象保存在數據庫中
* @param obj 保存的對象
* **/
public static void addOne(Object obj){
try {
Connection con=ConnectionFactory.getCon();
String sql=createSqlByObject(obj);
PreparedStatement ps=con.prepareStatement(sql);
int result=ps.executeUpdate();
if(result==1){
System.out.println("保存成功！");
}else{
System.out.println("保存失敗！");
}
ps.close();
con.close();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* 根據類名字和一個查詢條件
* 自動封裝一個Bean對象
* @param columnName 列名
* @param value 列值
* @return {@link Object}
*
* */
public static Object getOneObject(String className,String columnName,String value){
String tableName=className.split("\\.")[className.split("\\.").length-1];
System.out.println("表名字： "+tableName);
//根據類名來建立對象
Class c=null;
try{
c=Class.forName(className);//反射生成一個類實例
}catch(Exception e){
e.printStackTrace();
}
//拼接sql語句
StringBuffer sb=new StringBuffer();
sb.append("select * from ")
.append(tableName)
.append(" where ")
.append(columnName).append(" = ").append("'").append(value).append("'");
String querySql=sb.toString();
System.out.println("查詢的sql語句爲:"+querySql);
Object obj=null;
try{
Connection con=ConnectionFactory.getCon();//獲得一個數據庫鏈接
PreparedStatement ps=con.prepareStatement(querySql);//預編譯語句
ResultSet rs=ps.executeQuery();//執行查詢
//獲得對象的全部的方法
Method ms[]=c.getMethods();
if(rs.next()){
//生成一個實例
obj=c.newInstance();
for(Method m:ms){
String mName=m.getName();
if(mName.startsWith("set")){
//根據方法名字自動提取表中對應的列名
String cname = mName.substring(3, mName.length());
//打印set的方法名
// System.out.println(cname);
//獲得方法的參數類型
Class[] params=m.getParameterTypes();
// for(Class cp : params){
// System.out.println(cp.toString());
// }
//若是參數是String類型，則從結果集中，按照列名取到的值，進行set
//從params[0]的第一個值，能獲得該數的參數類型
if(params[0]==String.class){//
m.invoke(obj, rs.getString(cname));
//若是判斷出來是int形，則使用int
}else if(params[0]==int.class){
m.invoke(obj, rs.getInt(cname));
}
}
}
}else{
System.out.println("請注意："+columnName+"="+value+"的條件，沒有查詢到數據!!");
}
rs.close();
ps.close();
con.close();
}catch(Exception e){
e.printStackTrace();
}
return obj;
}
public static void main(String[] args) throws Exception{
//====================添加======================
Dog d=new Dog(21, "小不點", "藏獒", "灰色", 25);
Person p=new Person(6, "大象hadoop", 10, "家住Apache基金組織");
//createSqlByObject(d);
//addOne(d);給dog表添加一條數據
//addOne(p);//給person表添加一條數據
//=======================查詢=======================
//強制轉換爲原始類
// Dog d1=(Dog)getOneObject("com.qin.model.Dog", "id", "1");
// System.out.println(d1);
Person d1=(Person)getOneObject("com.qin.model.Person", "id", "1");
//Person d1=(Person)getOneObject("com.qin.model.Person", "name", "王婷");
System.out.println(d1);
}
}

代碼量是很是的少的，並且具備通用型，若是再有10個這個實體類，咱們代碼根本不用任何改動，只須要傳入不一樣的實體類名字便可，固然這一點和Hibernate的自動化ORM很是接近了，在Hibnerate裏，能夠自動經過表生成類，也能夠經過類生成數據庫的表，原理其實就是利用了反射的特性，幫咱們作了大量的重複工做，固然Hibnerate提供了更多的特性，也這只是一個簡單的例子，具體的應用場景中，咱們也須要因地制宜，不然，則爲拔苗助長！編程

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。