class.isAssignableFrom 和 instanceof

最新推荐文章于 2024-06-04 16:11:51 发布
原创 最新推荐文章于 2024-06-04 16:11:51 发布 · 565 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入探讨了Java中的类关系判断方法，包括`class.isAssignableFrom`与`instanceof`的区别与应用，并通过实例说明了如何高效地进行类关系判断。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.class.isAssignableFrom

class1.class.isAssignablFrom(class2)

class2跟class1相同或者为class1的子类时，返回true。

2.instanceof

o instance Class3

实例化o的类是不是Class3或者是Class3子类

3.总结

自我感觉第一种好用些，因为第一种不需要类实例化对象

 

spring拾遗(四)——自定义注解实现interceptor的指定拦截
Horizon_LGMH的博客
08-01 6621
为了对指定方法进行权限验证等操作，很多时候我们要采用aop或者interceptor的方式，一直对自定义注解+interceptor的拦截方式不是特别了解，今天入了一下门。 首先自定义一个注解，@Target(ElementType.METHOD)表示这个注解只能在METHOD上使用，@Retention(RetentionPolicy.RUNTIME) 表示运行时生效，剩下那个没啥用 @Ta
JAVA学习-类型信息.instanceof与Class的等价性
weixin_69763181的博客
04-02 860
Java中的类型信息主要通过instanceof和Class来实现。
Class 中的 isAssignableFrom方法
Lirj_的博客
03-29 679
Class isAssignableFrom public class AssignaableFromTest { public static void main(String[] args) { //判断Class对象表示的类或接口是否与参数Class表示的类或接口相同，或是否是参数Class对象的父类或父接口 System.out.println("A....
类方法isAssignableFrom、instanceof和asSubclass的区别及实例
nyyin@qq.com
04-04 3209
public boolean isAssignableFrom(Classif (List.class.isAssignableFrom(ArrayList.class)) { System.out.println("list is assignable from arraylist"); } if (ArrayList.class.isAssignableFrom(List.class)) {
Class的isAssignableFrom方法
android开发笔记
06-17 1102
Class类的isAssignableFrom是个不常用的方法，感觉这个方法的名字取得不是很好，所以有必要在此解析一下，以免在看源码时产生歧义，这个方法的签名如下： public native boolean isAssignableFrom(Class<?> cls); 由方法签名可见是一个本地方法，即C代码编写的。 以下是JDK中的注释： Determines if th...
Java语言-Assign.java
程序员本员
05-14 1048
import java.io.*;//用File类 public class Assign //类定义 public static void main(String[] args) {//主方法定义 // TODO Auto-generated method stub byte b=50;//字节类型赋值 float f=0.55F;//浮点数类型赋值 long l=0xfffL;//64位整型赋值 System.out.println("b="+b);//打印结果 System.
java反射系列03 isInstance() isAssignFrom()
weixin_36210698的博客
07-11 1023
isInstance()Class<Object> clz = Object.class; clz.isInstance(new String("dengyi"));如果new String(“dengyi”)实例的类也就是String类是Object类的子类则返回trueisInstance()与 instanceof关键字的区别 使用场景不同 当发生转型异常时，instanceof会无法通过编译
Class.isAssignableFrom()方法与instanceof
qq_52148082的博客
06-04 399
之前在开发中instanceof常用一些，今天看别人的代码的时候发现有用Date.class.isAssignableFrom()方法。没见过这个方法，特此记录一下。
Class.isAssignableFrom与 instanceof 区别
FScyj1的博客
03-08 407
转自:http://lucky16.iteye.com/blog/1631253 isAssignableFrom 是用来判断一个类Class1和另一个类Class2是否相同或是另一个类的超类或接口。     通常调用格式是           Class1.isAssignableFrom (Class2)     调用者和参数都是   java.lang.Class   类型。 
Class.isAssignableFrom()和instanceOf关键字
wensuliang的博客
04-21 2604
1.isAssignableFrom方法判断A是否是B的父类或者和B类型相同或者B实现了A接口.是类与类之间的比较。 如下： System.out.println(Number.class.isAssignableFrom(Integer.class)); System.out.println(Number.class.isAssignableFrom(Number.clas
Class.isInstance vs Class.isAssignableFrom and instanceof
bearboy80的专栏
02-20 175
Class.isInstance vs Class.isAssignableFrom and instanceof 区别
/** * 自动关联 * @param e * @param <T> * @throws IllegalAccessException * @throws ClassNotFoundException */ private static <T extends SynchronizableEntity> void setDefaultAssociation(SynchronizedList<T> e ) throws IllegalAccessException, ClassNotFoundException { for (T t:e) { Class clazz=t.getClass(); Field[] fields = clazz.getDeclaredFields(); for (Field f:fields){ f.setAccessible(true); Class s=f.getType(); if(SynchronizableEntity.class.isAssignableFrom(s)){ if (t.getId()<0 ||f.get(t)==null|| ((SynchronizableEntity)f.get(t)).getId()==null) { f.set(t, dataCollectionMap.get(s).get(0)); }else { f.set(t, dataCollectionMap.get(s).get( ((SynchronizableEntity)f.get(t)).getId())); } } if (List.class.isAssignableFrom(s)){ Type genericSuperclass = s.getGenericSuperclass(); if (genericSuperclass instanceof ParameterizedType) { ParameterizedType pt = (ParameterizedType) genericSuperclass; Type[] types = pt.getActualTypeArguments(); // System.out.println("集合类型: " + types[0].getTypeName()); // User Log.d(TAG, "setDefaultAssociation: "+types[0].getTypeName()); Class c=Class.forName(types[0].getTypeName()); if(SynchronizableEntity.class.isAssignableFrom(c)) { List<SynchronizableEntity> l = (List<SynchronizableEntity>) f.get(t); if (l == null) { l = new ArrayList(); } if (l.isEmpty() || t.getId() < 0) { l.add(dataCollectionMap.get(c).get(0)); } if (!l.isEmpty()) { for (int i = 0; i < l.size(); i++) { //Log.d(TAG, "setDefaultAssociation: "); l.set(i,dataCollectionMap.get(c).get( l.get(i).getId())); } } } } } } } }
06-13
if(SynchronizableEntity.class.isAssignableFrom(elementClass)){List<SynchronizableEntity>listValue=(List)f.get(t);if(listValue==null){listValue=newArrayList();f.set(t,listValue);}//如果当前实体是新的...
package com.example.kucun2.DataPreserver; import android.util.Log; import com.example.kucun2.entity.data.SynchronizableEntity; import com.example.kucun2.entity.data.SynchronizedList; import java.lang.reflect.Field; import java.util.ArrayList; import java.util.List; public class DataAssociator { private final DataStore dataStore; public DataAssociator(DataStore dataStore) { this.dataStore = dataStore; } public void automaticAssociation() { dataStore.dataCollectionMap.keySet().forEach(entityClass -> { try { associateEntities(dataStore.dataCollectionMap.get(entityClass)); } catch (Exception e) { Log.e("DataAssociator", "关联失败: " + entityClass.getSimpleName(), e); } }); } private void associateEntities(SynchronizedList<?> list) throws Exception { for (SynchronizableEntity entity : list.getViewList()) { if (entity == null) continue; for (Field field : entity.getClass().getDeclaredFields()) { field.setAccessible(true); Class<?> fieldType = field.getType(); if (SynchronizableEntity.class.isAssignableFrom(fieldType)) { associateSingleReference(entity, field); } else if (List.class.isAssignableFrom(fieldType)) { associateReferenceList(entity, field); } } } } private void associateSingleReference(SynchronizableEntity entity, Field field) throws Exception { SynchronizableEntity ref = (SynchronizableEntity) field.get(entity); if (ref == null) return; Class<?> targetType = field.getType(); SynchronizableEntity target = findTargetEntity(ref, targetType); field.set(entity, target); } private SynchronizableEntity findTargetEntity(SynchronizableEntity ref, Class<?> targetType) { SynchronizedList<?> targetList = dataStore.dataCollectionMap.get(targetType); if (targetList == null) return null; // 预置对象特殊处理 if (ref.getId() == -1) { return targetList.getViewList().stream() .filter(e -> e.getId() == -1) .findFirst().orElse(null); } // 根据ID查找实体 return targetList.getViewList().stream() .filter(e -> ref.getId().equals(e.getId())) .findFirst() .orElse(null); } private void associateReferenceList(SynchronizableEntity entity, Field field) throws Exception { Type genericType = field.getGenericType(); if (!(genericType instanceof ParameterizedType)) return; Type itemType = ((ParameterizedType) genericType).getActualTypeArguments()[0]; if (!(itemType instanceof Class) || !SynchronizableEntity.class.isAssignableFrom((Class<?>) itemType)) { return; } List<?> refList = (List<?>) field.get(entity); if (refList == null) { field.set(entity, new ArrayList<>()); return; } List<SynchronizableEntity> resolvedList = new ArrayList<>(); for (Object ref : refList) { if (ref instanceof SynchronizableEntity) { SynchronizableEntity resolved = findTargetEntity( (SynchronizableEntity) ref, (Class<?>) itemType ); if (resolved != null) resolvedList.add(resolved); } } field.set(entity, resolvedList); } } 详细注释
最新发布
06-25
SynchronizableEntity.class.isAssignableFrom((Class) itemType)) { return; } // 获取当前字段值（可能是未关联的引用列表） List<?> refList = (List) field.get(entity); // 处理空列表：初始化为空...
package com.kucun.Service; import java.io.Serializable; import java.lang.reflect.*; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.stream.Collectors; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.dao.DataAccessException; import org.springframework.data.domain.Example; import org.springframework.data.domain.ExampleMatcher; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Service; import com.kucun.data.entity.Bancai; import com.kucun.data.entity.Dingdan_chanpin; import com.kucun.data.entity.Dingdan_chanpin_zujian; import com.kucun.data.entity.EntityBasis; import com.kucun.data.entity.Information; import com.kucun.data.entity.Kucun; import com.kucun.dataDo.BancaiRepository; import com.kucun.dataDo.CaizhiRepository; import com.kucun.dataDo.ChanpinRepository; import com.kucun.dataDo.ChanpinZujianRepository; import com.kucun.dataDo.DingdanChanpinRepository; import com.kucun.dataDo.DingdanChanpinZujianRepository; import com.kucun.dataDo.DingdanRepository; import com.kucun.dataDo.KucunRepository; import com.kucun.dataDo.MupiRepository; import com.kucun.dataDo.UserRepository; import com.kucun.dataDo.ZujianRepository; @Service public class AppService { // 注入所有需要的Repository @Autowired private CaizhiRepository caizhiRepository; @Autowired private BancaiRepository bancaiRepository; @Autowired private ChanpinRepository chanpinRepository; @Autowired private DingdanRepository dingdanRepository; @Autowired private MupiRepository mupiRepository; @Autowired private ZujianRepository zujianRepository; @Autowired private KucunRepository kucunRepository; @Autowired private UserRepository userRepository; @Autowired private ChanpinZujianRepository chanpinZujianRepository; @Autowired private DingdanChanpinZujianRepository dingdanChanpinZujianRepository; @Autowired private DingdanChanpinRepository dingdanChanpinRepository; @Autowired private DynamicRepositoryService repositoryService; @Autowired private EntityDependencyService dependencyService; public Information getAllDataWithChildIdse() { Map<String, Object> response = new HashMap<>(); for (String key : repositoryService.getRepositoryNameMap().keySet()) { response.put(key+"s", (repositoryService.getJpaRepository(key).findAll())); } return Information.NewSuccess(response); } public Information getAllDataWithChildIdse(String e) { JpaRepository<?, ?> jp = repositoryService.getJpaRepository(e); System.out.println(jp); return Information.NewSuccess(jp.findAll()); } public Information getAddEntity(Object e) { Class<?> entityClass = e.getClass(); try { // 处理关联字段 handleAssociations(e); @SuppressWarnings("unchecked") JpaRepository<Object, Serializable> jp = (JpaRepository<Object, Serializable>) repositoryService.getJpaRepository(entityClass); Object savedEntity = jp.save(e); if(savedEntity!=null) { if(savedEntity instanceof Bancai) { initializeKucunForBancai((Bancai)savedEntity); } } return Information.NewSuccess(savedEntity); } catch (Exception ex) { return Information.Newfail(500, "创建失败: " + ex.getMessage(), null); } } // 单独封装库存初始化方法 private void initializeKucunForBancai(Bancai bancai) throws Exception { Kucun kucun = new Kucun(null, bancai, 0); // 初始库存为0 try { bancai.setKucun(kucunRepository.save(kucun)); } catch (Exception e) { // TODO: handle exception throw new Exception("initializeKucunForBancai"+e); } } // 处理关联对象（转换为托管实体） private void handleAssociations(Object entity) throws Exception { Class<?> clazz = entity.getClass(); for (Field field : clazz.getDeclaredFields()) { field.setAccessible(true); Object value = field.get(entity); if (value == null) continue; // 处理单个关联实体 if (isEntityBasisField(field)) { EntityBasis associatedEntity = (EntityBasis) value; JpaRepository<Object, Serializable> repo = (JpaRepository<Object, Serializable>) repositoryService.getJpaRepository(associatedEntity.getClass()); // 获取托管状态的关联实体 Object managedEntity = repo.findById(associatedEntity.getId()) .orElseThrow(() -> new RuntimeException("关联实体不存在")); field.set(entity, managedEntity); } // 处理集合关联 else if (isCollectionField(field)) { Collection<?> collection = (Collection<?>) value; List<Object> managedEntities = new ArrayList<>(); for (Object item : collection) { if (item instanceof EntityBasis) { EntityBasis eb = (EntityBasis) item; JpaRepository<Object, Serializable> repo = (JpaRepository<Object, Serializable>) repositoryService.getJpaRepository(eb.getClass()); Object managedEntity = repo.findById(eb.getId()) .orElseThrow(() -> new RuntimeException("关联实体不存在")); managedEntities.add(managedEntity); } } // 更新集合为托管实体 if (!managedEntities.isEmpty()) { field.set(entity, managedEntities); } } } } /** * 更新 * @param e 实体待id * @return */ /** * 更新实体 * @param e 包含ID的实体 * @return 操作结果 */ public Information getupdateEntity(Object e) { if(e == null) { return Information.Newfail(403, "参数为空", null); } Class<?> entityClass = e.getClass(); try { Field idField = entityClass.getDeclaredField("id"); idField.setAccessible(true); Object idValue = idField.get(e); // 修正：应检查id是否为空，而不是不为空 if(idValue == null) { return Information.Newfail(403, "Id为空", null); } // 获取Repository @SuppressWarnings("unchecked") JpaRepository<Object, Serializable> jp = (JpaRepository<Object, Serializable>) repositoryService.getJpaRepository(entityClass); // 从数据库加载现有实体（托管状态） Object existingEntity = jp.findById((Serializable) idValue) .orElseThrow(() -> new RuntimeException("实体不存在")); // 复制属性（排除关联字段） copyNonNullProperties(e, existingEntity); // 保存托管状态的实体 Object updatedEntity = jp.save(existingEntity); return Information.NewSuccess(updatedEntity); } catch (Exception ex) { return Information.Newfail(500, "更新失败: " + ex.getMessage(), null); } } /** * 删除 * @param entity * @return */ /** * 删除实体 * @param entity 要删除的实体 * @return 操作结果 */ public Information getdeleteEntity(EntityBasis entity) { if (entity == null) { return Information.NewFail("删除对象不能为空"); } Class<?> entityClass = entity.getClass(); String entityName = entityClass.getSimpleName().toLowerCase(); try { // 1. 获取对应的Repository JpaRepository<Object, Serializable> jp = (JpaRepository<Object, Serializable>) repositoryService.getJpaRepository(entityName); // 2. 检查实体是否存在 if (!jp.existsById(entity.getId())) { return Information.NewFail("未找到ID为" + entity.getId() + "的" + entityName); } // 3. 检查依赖关系 if (dependencyService.hasDependencies(entityClass, entity.getId())) { return Information.NewFail("该记录已被其他数据引用，无法删除"); } // 4. 执行删除 jp.deleteById(entity.getId()); // 5. 验证删除结果 if (jp.existsById(entity.getId())) { return Information.NewFail("删除操作失败，记录仍然存在"); } return Information.NewSuccess("删除成功"); } catch (Exception e) { return Information.NewFail("删除过程中发生错误: " + e.getMessage()); } } // 复制非空属性（忽略关联字段） private void copyNonNullProperties(Object source, Object target) throws IllegalAccessException { Class<?> clazz = source.getClass(); for (Field field : clazz.getDeclaredFields()) { field.setAccessible(true); Object value = field.get(source); // 跳过关联字段和特殊字段 if (value != null && !isEntityBasisField(field) && !isCollectionField(field) && !field.getName().equals("id")) { Field targetField; try { targetField = target.getClass().getDeclaredField(field.getName()); targetField.setAccessible(true); targetField.set(target, value); } catch (NoSuchFieldException e) { // 忽略不存在的字段 } } } } // 检查是否为关联实体字段 private boolean isEntityBasisField(Field field) { return EntityBasis.class.isAssignableFrom(field.getType()); } // 检查是否为集合字段 private boolean isCollectionField(Field field) { return Collection.class.isAssignableFrom(field.getType()) || Map.class.isAssignableFrom(field.getType()); } /** * 根据非空属性值动态查询实体 * @param entity 包含查询条件的实体对象（非空属性作为查询条件） * @return 查询结果信息（成功时包含数据列表） */ public <T>Information getSELECTEntity(T entity) { if (entity == null) { return Information.NewFail("查询参数不能为空"); } Class<T> entityClass = (Class<T>) entity.getClass(); try { // 1. 获取非泛型的Repository JpaRepository repository = repositoryService.getJpaRepository(entityClass); // 2. 构建非泛型的Example查询 ExampleMatcher matcher = ExampleMatcher.matching() .withIgnoreNullValues() .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING); // 这里直接使用原始类型Example Example<T> example = Example.of(entity);//he type Example is not generic; it cannot be parameterized with arguments <T>the method of(T) is undefined for the type Example // 3. 执行查询 List<?> result = repository.findAll(example); return Information.NewSuccess(result); } catch (ClassCastException e) { return Information.NewFail("Repository类型不匹配: " + e.getMessage()); } catch (DataAccessException e) { return Information.NewFail("数据库访问错误: " + e.getMessage()); } catch (Exception e) { return Information.NewFail("系统错误: " + e.getMessage()); } } private List<Map<String, Object>> convertEntityBasis(List<EntityBasis> entities) { return entities.stream().map(entity -> { Map<String, Object> map = new HashMap<>(); Field[] fields = entity.getClass().getDeclaredFields(); try { // 添加实体自身的基本字段 map.put("id", entity.getId()); // 处理所有字段 for (Field field : fields) { field.setAccessible(true); // 允许访问私有字段 Object fieldValue = field.get(entity); if (fieldValue != null) { String fieldName = field.getName(); // 处理集合类型关联 if (isCollection(field)) { if (!((Collection<?>) fieldValue).isEmpty()) { List<Map<String, Object>> collectionItems = ((Collection<?>) fieldValue) .stream() .filter(item -> item instanceof EntityBasis) .map(item -> { Map<String, Object> itemMap = new HashMap<>(); itemMap.put("id", ((EntityBasis) item).getId()); return itemMap; }) .collect(Collectors.toList()); map.put(fieldName, collectionItems); } } // 处理单个实体关联 else if (implementsInterface(field, EntityBasis.class)) { Map<String, Object> associatedMap = new HashMap<>(); associatedMap.put("id", ((EntityBasis) fieldValue).getId()); map.put(fieldName, associatedMap); } // 处理其他基本类型字段 else if (!isSpecialField(fieldName)) { map.put(fieldName, fieldValue); } } } } catch (IllegalAccessException e) { e.printStackTrace(); } return map; }).collect(Collectors.toList()); } // 判断是否为特殊字段（需要排除的字段） private boolean isSpecialField(String fieldName) { return fieldName.equals("handler") || fieldName.equals("hibernateLazyInitializer"); } /** *-判断属性是否为集合类型 * @param field * @return */ boolean isCollection(Field field) { Class<?> type = field.getType(); // 检查是否为Java内置集合类型 if (Collection.class.isAssignableFrom(type) || Map.class.isAssignableFrom(type) || type.isArray()) { return true; } // 检查是否实现集合相关接口（如Iterable） for (Class<?> interfaceType : type.getInterfaces()) { if (Iterable.class.isAssignableFrom(interfaceType)) { return true; } } return false; } /** * -判断属性是否实现特定接口 * @param field * @param targetInterface * @return */ boolean implementsInterface(Field field, Class<?> targetInterface) { Class<?> type = field.getType(); // 检查类本身是否实现接口 if (targetInterface.isAssignableFrom(type)) { return true; } // 检查实现的接口是否继承目标接口 for (Class<?> interfaceType : type.getInterfaces()) { if (targetInterface.isAssignableFrom(interfaceType)) { return true; } } return false; } private Object convertDingdanChanpins(List<Dingdan_chanpin> findAll) { // TODO Auto-generated method stub return null; } private Object convertDingdanChanpinZujians(List<Dingdan_chanpin_zujian> findAll) { // TODO Auto-generated method stub return null; } } 简化该类，不用创建新类，加入方法注释
06-18
public class AppService { // 自动注入所有依赖 @Autowired private KucunRepository kucunRepository; @Autowired private DynamicRepositoryService repositoryService; @Autowired private ...
Class的isAssignableFrom方法详解
IT云清
12-07 1765
Class的isAssignableFrom方法 Class类的isAssignableFrom是个不常用的方法，感觉这个方法的名字取得不是很好，所以有必要在此解析一下，以免在看源码时产生歧义，这个方法的签名如下： public native boolean isAssignableFrom(Class<?> cls); 由方法签名可见是一个本地方法，即C代码编写的。 以下是JDK中...
scheduleAtFixedRate 与 scheduleWithFixedDelay 的区别
热门推荐
u013819945的专栏
08-17 1万+
总结： scheduleAtFixedRate ，是以上一个任务开始的时间计时，period时间过去后，检测上一个任务是否执行完毕，如果上一个任务执行完毕，则当前任务立即执行，如果上一个任务没有执行完毕，则需要等上一个任务执行完毕后立即执行。 scheduleWithFixedDelay，是以上一个任务结束时开始计时，period时间过去后，立即执行。 重点： 两个方法分别以不
MessageDigest 例子
u013819945的专栏
03-04 875
public static String getMD5Str(String str) { MessageDigest messageDigest = null; try { messageDigest = MessageDigest.getInstance("MD5"); messageDigest.reset(); messageDigest.update(str.ge
Java并发编程实战 第二章
u013819945的专栏
03-25 593
1.无状态的对象永远是线程安全的 无状态指的是不是没有属性呢？ 2.++count，并不是一个原子操作（单一操作），多线程情况下丢失更改。 @NotThreadSafe public class UnsafeCountingFactorizer implements Servlet { private long count = 0; public long getCount() { re
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值