在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方法
实体类如下:
- 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 + "]";
- }
- }
- 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 + "]";
- }
- }
- 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();
- }
- }
- 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提供了更多的特性,也这只是一个简单的例子,具体的应用场景中,我们也需要因地制宜,否则,则为适得其反!
最后,大家来一起喊一句:
JAVA ,我爱你 !
相关推荐
Java反射机制是Java编程语言中的一个强大特性,它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。这个特性使得Java具有了高度的灵活性和动态性,尤其是在处理元数据、创建对象、调用私有方法...
### Java反射性能测试分析 #### 引言 Java反射机制是Java编程语言中一个强大的特性,它允许程序在运行时动态地访问、检测和修改类、接口、字段和方法等对象。然而,反射操作通常会引入额外的开销,这在性能敏感的...
Java反射机制是Java语言提供的一种强大功能,它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。在Java中,反射主要用于在运行时分析类和对象,包括获取类的信息、创建对象、调用方法以及访问和...
Java反射是Java编程语言中的一个强大特性,它允许运行时的程序访问并操作类、接口、字段和方法等信息,即使这些信息在编译时并未明确知晓。在Java中,反射通常通过`java.lang.Class`类和相关的API来实现。本实例将...
java反射机制java反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制...
虽然Java反射提供了强大的功能,但在使用时也需要注意其潜在的问题: - **优点**: - **灵活性**:能够动态地加载和操作类。 - **扩展性**:方便扩展程序的功能。 - **可维护性**:降低了程序间的耦合度,提高了...
### Java反射机制应用详解 #### 一、Java反射机制简介 Java反射机制是Java语言提供的一种能在运行时分析类信息并动态操作对象的功能。通过反射,我们可以在程序运行期间获取类的信息(如类名、方法名等),创建...
下面通过一个具体的示例来展示如何使用Java反射来获取类的详细信息: ```java import java.lang.reflect.*; public class DumpMethods { public static void main(String args[]) { try { Class c = Class.for...
综上所述,Java反射机制提供了强大的动态编程能力,但使用时需权衡其带来的性能损失和潜在的安全风险。通过深入学习和实践,开发者可以更好地掌握这一机制,为解决问题和开发复杂系统提供强有力的支持。
Java反射机制是Java编程语言中一个强大的特性,它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。这个特性使得Java具有了高度的灵活性和动态性,尤其是在处理元数据、创建对象、调用方法以及...
这个案例将深入探讨如何使用Java反射来实现一些实用的功能。 1. **获取类信息**: 反射机制首先从Class对象开始,它是所有Java类的元数据。通过`Class.forName()`方法或`类名.class`可以获取到Class对象。一旦有了...
java反射机制源码java反射机制源码java反射机制源码
- 实现序列化与反序列化:`ObjectInputStream`和`ObjectOutputStream`可以通过`readObject()`和`writeObject()`方法使用反射进行序列化操作。 反射在很多场景下都非常有用,比如在插件系统、框架开发、测试工具、...
总的来说,Java反射和EJB都是Java编程中的高级特性,它们为开发带来了便利,但同时也需要谨慎使用,因为不当的使用可能导致性能下降、安全性风险增加等问题。理解和熟练掌握这两个概念,对于提升Java开发水平和解决...
在使用反射时,需要注意性能问题,因为反射操作比直接的Java代码执行要慢。此外,由于反射可以访问私有成员和调用非公开的方法,如果不加以控制,可能会破坏封装性,增加代码的复杂性和潜在的安全风险。 代理模式是...
### Java反射机制与动态加载实例类 在Java中,反射是一种强大的工具,允许程序在运行时检查和修改其结构和行为。通过反射,我们可以动态地加载类、创建对象、访问和修改字段、调用方法等。本文将深入探讨Java反射...
下面将详细阐述Java反射机制的基本概念、应用场景以及如何使用。 一、反射机制基本概念 1. 类加载:Java程序在运行时,JVM会将.class文件加载到内存中,形成类的Class对象,这个过程称为类加载。 2. 类的Class对象...
在向学生讲解Class.forName()方法的使用时,有时需要扩展讲解为什么这样书写的原理,于是,扩展讲解Java反射技术可以查看被监视类的方法(构造方法和普通方法)、公有属性的功能,以达到封闭功能的效果。该例子使用...
本文介绍了如何使用Java反射机制来创建get和set方法,并通过反射调用这些方法来访问对象的属性。这种方式虽然灵活,但在实际开发中应当谨慎使用,因为它可能会降低代码的性能和可维护性。了解反射机制的基本原理对于...
- 构造器信息获取与使用。 #### 代码解析 根据提供的部分代码片段: ```java A a = new A(); Field field = a.getClass().getDeclaredField("x"); field.setAccessible(true); field.set(a, 1); Field f = a....