精华内容
下载资源
问答
  • java泛型反射注解

    2016-08-18 16:34:46
    先说一下遇到的问题:通过使用GSON泛型进行报文转换的时候想要对部分关键字段加密,发现在封装好的方法中,对个别字段的加密满足不了。 解决过程:首先通过反射获取到bean下的对象名称。 对象名称获取到了之后需要...
  • 泛型反射

    千次阅读 2018-07-25 09:03:40
    场景:方法定义了一个泛型T,需要根据泛型的具体类型做特殊处理:当类型为Page< T >(一个泛型类)时,要拿到Page里面的T的具体类型,然后对应到另一个泛型类List< T >...

    场景:方法定义了一个泛型T,需要根据泛型的具体类型做特殊处理:当类型为Page< T >(一个泛型类)时,要拿到Page里面的T的具体类型,然后对应到另一个泛型类List< T >,最后调用另一个泛型方法JsonConvertUtil.DeserializeObject< T >(string jsonStr, JsonSerializerSettings settings)这里的T指定为List< T >

    分析:一开始的思路是想着通过一些方法能得到T的具体类型Page< A >,然后直接调用DeserializeObject< List< A > >,尝试了一下,发现语法不通。当我们不确定泛型的具体类型时,或只能在运行时获取具体类型,正确的做法应该是使用反射。就好比我们得到了一个类型Type objType,却不能使用 objType obj= new objType()一样

    方法:

    public void T Test<T>(this string jsonStr) where T : class{
        //对泛型类型的判断,要先判断IsGenericType,再比较GetGenericTypeDefinition
        if (typeof(T).IsGenericType && typeof(T).GetGenericTypeDefinition() == typeof(Page<>){
            //声明类型List<>,并设置List<T1>里面的T1为T(Page<T2>)里的T2
            //typeof(T).GetGenericArguments()[0]即获取T(Page<T2>)里的T2
            var listType = typeof(List<>).MakeGenericType(typeof(T).GetGenericArguments()[0]);
            //通过反射获取泛型方法,并把上一步得到的listType做为方法的泛型类型,MakeGenericMethod(listType)
            var desMethod = typeof(JsonConvertUtil).GetMethod("DeserializeObject", 
                new Type[] { typeof(string), typeof(JsonSerializerSettings) }).MakeGenericMethod(listType);
            //执行方法
            var fragmentList = desMethod.Invoke(null, new object[] { bigStr.GetFragmentStr(i), GlobalDesSettings });
        }
    }
    
    展开全文
  • Java基础入门(四)-泛型反射、注解
  • 有时候我们需要知道当前类所传入的泛型的具体类型而进行下一步操作,这是我们可以使用泛型反射。 1.假如Dao层的接口有很多共同的方法,增删改查,我们可以对他进行提取到一个公共接口IBaseDao&lt;T&gt; ...

    有时候我们需要知道当前类所传入的泛型的具体类型而进行下一步操作,这是我们可以使用泛型反射。

    1.假如Dao层的接口有很多共同的方法,增删改查,我们可以对他进行提取到一个公共接口IBaseDao<T>

    package com.sg.xjgc.generic_reflect;
    
    import java.util.List;
    
    /**
     * @date on 15:31 2018/12/21
     * @package com.sg.xjgc.generic_reflect
     * @description Dao层顶级抽取接口
     */
    public interface IBaseDao<T> {
        /**
         * 根据主键查询
         * @param id 实体类id
         * @return T
         */
        T findById(int id);
    
        /**
         * 查询所有
         * @return List<T>
         */
        List<T> findAll();
    
        /**
         * 修改
         * @param p 实体类对象
         */
        void update(T p);
    
        /**
         * 删除
         * @param p 实体类对象
         */
        void delete(T p);
    
        /**
         * 添加
         * @param p 实体类对象
         */
        void add(T p);
    
    }
    

    2.创建它的实现类BaseDaoImpl,通过在构造函数中通过泛型反射获取当前类传入的泛型T具体类型。

     

    package com.sg.xjgc.generic_reflect;
    
    import java.lang.reflect.ParameterizedType;
    import java.lang.reflect.Type;
    import java.util.List;
    
    /**
     * @date on 15:37 2018/12/21
     * @package com.sg.xjgc.generic_reflect
     * @description IBaseDao的实现类
     */
    public class BaseDaoImpl<T> implements IBaseDao<T>{
        private Class clazz;
    
        /**
         * 在这里通过泛型反射得到具体的泛型类Class对象
         */
        public BaseDaoImpl(){
            //这里this代表的是BaseDaoImpl的子类对象
            //得到当当前类(父类)上的泛型T--父类型
            Type type = this.getClass().getGenericSuperclass();
            //得到当前类上所有的泛型类型Class
            Type[] types = ((ParameterizedType) type).getActualTypeArguments();
            //得到具体传入的泛型类Class对象
            clazz = (Class) types[0];
        }
    
        /**
         * 根据主键查询
         * @param id 实体类id
         * @return T
         */
        @Override
        public T findById(int id) {
            System.out.println(clazz);
            return null;
        }
    
        /**
         * 查询所有
         *
         * @return List<T>
         */
        @Override
        public List<T> findAll() {
            System.out.println(clazz);
            return null;
        }
    
        /**
         * 修改
         *
         * @param p 实体类对象
         */
        @Override
        public void update(T p) {
            System.out.println(clazz);
        }
    
        /**
         * 删除
         *
         * @param p 实体类对象
         */
        @Override
        public void delete(T p) {
            System.out.println(clazz);
        }
    
        /**
         * 添加
         *
         * @param p 实体类对象
         */
        @Override
        public void add(T p) {
            System.out.println(clazz);
        }
    }
    

    3.分别创建实体类User和Product测试使用。

    package com.sg.xjgc.generic_reflect;
    /**
     * @date on 15:46 2018/12/21
     * @package com.sg.xjgc.generic_reflect
     * @description 模拟用户实体类
     */
    public class User {
        private int id;
        private String userName;
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getUserName() {
            return userName;
        }
    
        public void setUserName(String userName) {
            this.userName = userName;
        }
    }
    
    package com.sg.xjgc.generic_reflect;
    /**
     * @date on 15:47 2018/12/21
     * @package com.sg.xjgc.generic_reflect
     * @description 模拟产品实体类
     */
    public class Product {
        private int id;
        private String name;
    
        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;
        }
    }
    

    4.分别创建针对User业务和Product业务的Dao层具体实现类继承BaseDaoImpl<T>,因为公共方法已经被父类实现,因此它什么也不用做,传入具体泛型即可。 

    package com.sg.xjgc.generic_reflect;
    /**
     * @date on 15:49 2018/12/21
     * @package com.sg.xjgc.generic_reflect
     * @description 具体用户dao
     */
    public class UserDaoImpl extends BaseDaoImpl<User> {
        //子类什么都不用做
    }
    

     

    package com.sg.xjgc.generic_reflect;
    /**
     * @date on 15:49 2018/12/21
     * @package com.sg.xjgc.generic_reflect
     * @description 具体产品dao
     */
    public class ProductDaoImpl extends BaseDaoImpl<Product>{
        //子类什么都不用做
    }
    

    5.编写测试类,来查看能否获得泛型类的具体类型。

    package com.sg.xjgc.generic_reflect;
    /**
     * @date on 15:51 2018/12/21
     * @package com.sg.xjgc.generic_reflect
     * @description 测试
     */
    public class Test {
    
        @org.junit.Test
        public void testUserDaoImpl(){
            IBaseDao baseDao = new UserDaoImpl();
            baseDao.findAll();
            //结果:class com.sg.xjgc.generic_reflect.User
        }
    
        @org.junit.Test
        public void testProductDaoImpl(){
            IBaseDao baseDao = new ProductDaoImpl();
            baseDao.findAll();
            //结果:class com.sg.xjgc.generic_reflect.Product
        }
    
    }
    

     

     

     

    展开全文
  • 泛型 反射 概念 方法 使用
  • 在开发过程中,封装的过程中,避免不了要获得 泛型的class, 那么如何获取呢。 注意: 具体的解释在代码中 注意: 具体的解释在代码中 注意: 具体的解释在代码中 2. 名词的解释 在这之前呢,我们应该知道一些...

    1. 需求

    在开发过程中,封装的过程中,避免不了要获得 泛型的class, 那么如何获取呢。

    注意: 具体的解释在代码中
    注意: 具体的解释在代码中
    注意: 具体的解释在代码中

    2. 名词的解释

    在这之前呢,我们应该知道一些名词

    1. List<E> :E称为类型参数变量
    2. List<Integer> : Integer称为实际类型参数
    3. List<Integer> :List<Integer>称为参数化类型

    3. 获取T.class

    3.1 前提条件

    再获取泛型的class之前呢,我想说的是:
    获取T.class 的前提条件是

    1. 再父类中才能获取。
    2. 子类必须已经确定了父类的泛型,什么意思呢?比如这样
      public class Son extends Parent<String> {…}
      这样子就算是 子类再在继承的时候 已经确定了父类的泛型。
    3. 使用的时候,实例化子类

    3.2 例子的类图

    在这里插入图片描述

    3.3 代码(具体的解释在代码中

    3.3.1 Parent类代码

    public class Parent<T> {
    
    	private Class<T> clazz;
    	
    	/**
    	 * 无参构造方法
    	 */
    	public Parent() {
    		
    		/**
    		 * 获取直接父类
    		 * 1. 注意,这个getClass() 方法获取的是谁的class呢?
    		 * 	  如果是实例化的Parent的子类( new Son() ),那么实例化子类(Son)的时候,
    		 *   必定会实例化Parent.所以此时getClass() 获取的是其子类(Son的)的class
    		 *   那么 getGenericSuperclass(); 获取的是
    		 *   		pers.lzy.test.Parent<java.lang.Integer>
    		 *   		因为我子类(Son)写的是 public class Son extends Parent<Integer> {}
    		 *   		所以他获取的是 pers.lzy.test.Parent<java.lang.Integer>
    		 * 2. 如果你 实例化的是此类( new Parent<String>() ) 
    		 * 		那么getClass() 必定是 此类也就是Parent的class
    		 * 		之后再调用getGenericSuperclass(); 获取的是Object
    		 * 		那么抱歉,不用往下执行了,因为你已经不能获取T.class了,
    		 *		因为Object上面并没有泛型,你不能往下解析了。
    		 *   
    		 */
    		Type type = this.getClass().getGenericSuperclass();
    		
    		// 这里  强转成参数化类型:结果跟type一样:
    		//					pers.lzy.test.Parent<java.lang.Integer>
    		// ParmeterizedType 为 type的子接口
    		ParameterizedType ptype = (ParameterizedType) type;
    		
    		// 获取  实际类型参数(也就是<>里面的类型)
    		// 为什么是 数组呢???因为我们<>里面可以有多个, <String, Object>
    		// types值为:[class java.lang.Integer]
    		Type[] types = ptype.getActualTypeArguments();
    		
    		// Class 为 Type 的实现类。
    		// 我们只要第一个元素,因为我们泛型定义了一个
    		// 强转成class。
    		// 现在我们就得到了泛型的class(T.class)
    		this.clazz = (Class<T>) types[0];
    		
    	}
    	
    	/**
    	 * 使用clazz
    	 * 打印class
    	 */
    	public void sayClass() {
    		System.out.println(clazz);
    	}
    }
    
    • 上面的代码 为啥能 反复强转?反复横跳(滑稽)。请看下面类图
      在这里插入图片描述

    3.3.2 Son类代码

    /**
     * @author immort(lzy)
     * 注意,这里已经确定了 父类的泛型
     */
    public class Son extends Parent<Integer> {
    
    }
    

    3.3.3 使用

    /**
     * 调用类
     * @author immortal
     *
     */
    public class Client {
    
    	public static void main(String[] args) {
    		// 注意,这里一定是实例化的子类
    		// 不然肯定得不到T.class
    		Parent<Integer> son = new Son();
    		son.sayClass();
    	}
    }
    

    输出的结果

    在这里插入图片描述

    展开全文
  • 泛型反射联合使用.zip

    2019-10-18 13:21:50
    C#泛型反射联合使用的实例代码,绝对正常运行,含义注释,有问题和建议可留言!
  • 基本
  • 泛型反射例子

    2013-03-04 13:40:24
    JAVA中 关于泛型 以及反射的例子 欢迎下载 一起研究
  • 在C#中通过反射操作一个List泛型。。
  • 主要介绍了asp.net实现利用反射泛型,静态方法快速获取表单值到Model的方法,结合实例形式分析了asp.net中反射泛型,静态方法给model赋值的相关技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • java泛型反射机制

    2018-09-13 15:12:02
    对java泛型以及反射机制进行原理和应用上的讲解,帮助初学者对这两个概念进行更轻松的掌握
  • C#基础泛型+反射的组合运用

    千次阅读 2019-02-14 11:30:34
    2.利用反射泛型将DataTatale转换成List并判断List中集合的数据值 准备工作: 创建控制台程序; 创建一个Temp类; using System; using System.Collections.Generic; using System.Linq; using Sys...
  • 反射泛型是一种重要的解决途径。 此代码是一个生成泛型对象的类。 比如: Pool<Point> pool = new Pool(){}; Point p = pool.get(x, y); //在此构造Point对象 ... pool.put(p); 希望能帮助那些为查找泛型构造器、...
  • java泛型反射总结

    2020-02-29 18:30:38
    泛型基础 类型变量的限定 例如我们有一个泛型方法min,其中的形参是也是一个泛型数组。我们要使用泛型变量smallest的comparTo方法,就要求类型变量T是可以实现Comparable接口的类。 为了解决这种问题,我们可以使用...
  • Java泛型反射

    千次阅读 2018-05-05 15:59:27
    类型擦除;使用反射获取泛型的绑定类型。
  • 关于Java泛型反射问题

    2015-09-03 01:12:22
    * 我们通过反射可以获取list的add方法给col2存储其他类型的数据。如这里就可以将“abc”存放到col2中 * 不明白这里为什么参数一定要是Object.class,不能改为String.class */ try { col2.getClass()....
  • 泛型反射技巧总结

    2015-03-13 13:32:49
    本文为一些泛型反射技巧的简单罗列,为日后的文章做准备。 1、如何获得一个封闭构造类型(closed constructed type)的Type对象? 假设有如下的类型: class TestType class TestType 如果要获得封闭构造...
  • 学习要点: * 1.如何利用Lambda 跟泛型方法配合的区别 .(非委托) * 2.利用Lambda 反射调用属性值 .
  • 同时,因为反射会带来性能损失,因此,可根据自己需求,针对每个类型轻松在两种模式之前切换,本例源码,测试实例俱全,而且代码浅显易懂,只要对泛型反射、三层架构有一定了解的人都能轻松学习
  • java中的泛型反射的一些总结

    千次阅读 2018-08-09 17:28:29
    什么叫反射反射是框架设计的灵魂 (使用的前提条件:必须先得到代表的字节码的Class,Class类用于表示.class文件(字节码)) 一、反射的概述 JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类...
  • //获取第一个泛型参数类型,因为我们这里只有一个泛型参数C,因此就指代C Type type = ((ParameterizedType) superclass).getActualTypeArguments()[0]; //强转为我们要用的实际类型C,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 68,546
精华内容 27,418
关键字:

泛型反射