类似交费网站开发,高大上的网站欣赏,wordpress如何恢复,wordpress同步qq微博前言
中国有句老话叫事不过三#xff0c;指一个人犯了同样的错误#xff0c;一次两次三次还可以原谅#xff0c;超过三次就不可原谅了。有人指出这个“三”是虚数#xff0c;用来泛指多次#xff0c;所以事不过三不包括“三”。至于事不过…前言
中国有句老话叫事不过三指一个人犯了同样的错误一次两次三次还可以原谅超过三次就不可原谅了。有人指出这个“三”是虚数用来泛指多次所以事不过三不包括“三”。至于事不过三包不包括“三”可能跟每个人的底线有关系属于哲学范畴不在本文的讨论范围之内。
写代码也是如此同一个代码“坑”踩第一次叫长了经验踩第二次叫加深印象踩第三次叫不长心眼踩三次以上就叫不可救药。在本文中笔者总结了一些代码坑描述了问题现象进行了问题分析给出了避坑方法。希望大家在日常编码中遇到了这类代码坑能够提前避让开来。
1.对象比较方法
JDK1.7提供的Objects.equals方法非常方便地实现了对象的比较有效地避免了繁琐的空指针检查。
1.1.问题现象
在JDK1.7之前在判断一个短整型、整型、长整型包装数据类型与常量是否相等时我们一般这样写
Short shortValue (short)12345;
System.out.println(shortValue 12345); // true
System.out.println(12345 shortValue); // true
Integer intValue 12345;
System.out.println(intValue 12345); // true
System.out.println(12345 intValue); // true
Long longValue 12345L;
System.out.println(longValue 12345); // true
System.out.println(12345 longValue); // true
从JDK1.7之后提供了Objects.equals方法并推荐使用函数式编程更改代码如下
Short shortValue (short)12345;
System.out.println(Objects.equals(shortValue, 12345)); // false
System.out.println(Objects.equals(12345, shortValue)); // false
Integer intValue 12345;
System.out.println(Objects.equals(intValue, 12345)); // true
System.out.println(Objects.equals(12345, intValue)); // true
Long longValue 12345L;
System.out.println(Objects.equals(longValue, 12345)); // false
System.out.println(Objects.equals(12345, longValue)); // false
为什么直接把替换为Objects.equals方法会导致输出结果不一样
1.2.问题分析
通过反编译第一段代码我们得到语句System.out.println(shortValue 12345);的字节码指令如下
7 getstatic java.lang.System.out : java.io.PrintStream [22]
10 aload_1 [shortValue]
11 invokevirtual java.lang.Short.shortValue() : short [28]
14 sipush 12345
17 if_icmpne 24
20 iconst_1
21 goto 25
24 iconst_0
25 invokevirtual java.io.PrintStream.println(boolean) : void [32]
原来编译器会判断包装数据类型对应的基本数据类型并采用这个基本数据类型的指令进行比较比如上面字节码指令中的sipush和if_icmpne等相当于编译器自动对常量进行了数据类型的强制转化。
为什么采用Objects.equals方法后编译器不自动对常量进行数据类型的强制转化通过反编译第二段代码我们得到语句System.out.println(Objects.equals(shortValue, 12345));的字节码指令如下
7 getstatic java.lang.System.out : java.io.PrintStream [22]
10 aload_1 [shortValue]
11 sipush 12345
14 invokestatic java.lang.Integer.valueOf(int) : java.lang.Integer [28]
17 invokestatic java.util.Objects.equals(java.lang.Object, java.lang.Object) : boolean [33]
20 invokevirtual java.io.PrintStream.println(boolean) : void [39]
原来编译器根据字面意思认为常量12345默认基本数据类型是int所以会自动转化为包装数据类型Integer。 在Java语言中整数的默认数据类型是int小数的默认数据类型是double。 下面来分析一下Objects.equals方法的代码实现
Objects.equals方法的代码实现为
public static boolean equals(Object a, Object b) {return (a b) || (a ! null a.equals(b));
}
其中语句“a.equals(b)”将会使用到Short.equals方法。
Short.equals方法的代码实现为
public boolean equals(Object obj) {if (obj instanceof Short) {return value ((Short)obj).shortValue();}return false;
}
通过代码实现分析对应语句System.out.println(Objects.equals(shortValue, 12345));因为Objects.equals的两个参数对象类型不一致一个是包装数据类型Short另一个是包装数据类型Integer所以最终的比较结果必然是false。同样语句“System.out.println(Objects.equals(intValue, 12345));”因为Objects.equals的两个参数对象类型一致都是包装数据类型Integer且取值一样所以最终的比较结果必然是true。
1.3.避坑方法
(1)保持良好的编码习惯避免数据类型的自动转化
为了避免数据类型自动转化更科学的写法是直接声明常量为对应的基本数据类型。
第一段代码可以这样写
Short shortValue (short)12345;
System.out.println(shortValue (short)12345); // true
System.out.println((short)12345 shortValue); // true
Integer intValue 12345;
System.out.println(intValue 12345); // true
System.out.println(12345 intValue); // true
Long longValue 12345L;
System.out.println(longValue 12345L); // true
System.out.println(12345L longValue); // true
第二段代码可以这样写
Short shortValue (short)12345;
System.out.println(Objects.equals(shortValue, (short)12345)); // true
System.out.println(Objects.equals((short)12345, shortValue)); // true
Integer intValue 12345;
System.out.println(Objects.equals(intValue, 12345)); // true
System.out.println(Objects.equals(12345, intValue)); // true
Long longValue 12345L;
System.out.println(Objects.equals(longValue, 12345L)); // true
System.out.println(Objects.equals(12345L, longValue)); // true
(2)借助开发工具或插件及早地发现数据类型不匹配问题
在Eclipse的问题窗口中我们会看到这样的提示
Unlikely argument type for equals(): int seems to be unrelated to Short
Unlikely argument type for equals(): Short seems to be unrelated to int
Unlikely argument type for equals(): int seems to be unrelated to Long
Unlikely argument type for equals(): Long seems to be unrelated to int
通过FindBugs插件扫描我们会看到这样的警告
Call to Short.equals(Integer) in xxx.Xxx.main(String[]) [Scariest(1), High confidence]
Call to Integer.equals(Short) in xxx.Xxx.main(String[]) [Scariest(1), High confidence]
Call to Long.equals(Integer) in xxx.Xxx.main(String[]) [Scariest(1), High confidence]
Call to Integer.equals(Long) in xxx.Xxx.main(String[]) [Scariest(1), High confidence]
(3)进行常规性单元测试尽量把问题发现在研发阶段
“勿以善小而不为”不要因为改动很小就不需要进行单元测试了往往Bug都出现在自己过度自信的代码中。像这种问题只要进行一次单元测试是完全可以发现问题的。
2.三元表达式拆包
三元表达式是Java编码中的一个固定语法格式“条件表达式表达式1表达式2”。三元表达式的逻辑为“如果条件表达式成立则执行表达式1否则执行表达式2”。
2.1.问题现象
boolean condition false;
Double value1 1.0D;
Double value2 2.0D;
Double value3 null;
Double result condition ? value1 * value2 : value3; // 抛出空指针异常
当条件表达式condition等于false时直接把Double对象value3赋值给Double对象result按道理没有问题呀为什么会抛出空指针异常NullPointerException
2.2.问题分析
通过反编译代码我们得到语句Double result condition ? value1 * value2 : value3;的字节码指令如下
17 iload_1 [condition]
18 ifeq 33
21 aload_2 [value1]
22 invokevirtual java.lang.Double.doubleValue() : double [24]
25 aload_3 [value2]
26 invokevirtual java.lang.Double.doubleValue() : double [24]
29 dmul
30 goto 38
33 aload 4 [value3]
35 invokevirtual java.lang.Double.doubleValue() : double [24]
38 invokestatic java.lang.Double.valueOf(double) : java.lang.Double [16]
41 astore 5 [result]
43 getstatic java.lang.System.out : java.io.PrintStream [28]
46 aload 5 [result]
在第33行加载Double对象value3到操作数栈中在第35行调用Double对象value3的doubleValue方法。这个时候由于value3是空对象null调用doubleValue方法必然抛出抛出空指针异常。但是为什么要把空对象value3转化为基础数据类型double
查阅相关资料得到三元表达式的类型转化规则 若两个表达式类型相同返回值类型为该类型若两个表达式类型不同但类型不可转换返回值类型为Object类型若两个表达式类型不同但类型可以转化先把包装数据类型转化为基本数据类型然后按照基本数据类型的转换规则byte根据规则分析表达式1value1 * value2计算后返回基础数据类型double表达式2value3返回包装数据类型Double根据三元表达式的类型转化规则判断最终的返回类型为基础数据类型double。所以当条件表达式condition等于false时需要把空对象value3转化为基础数据类型double于是就调用了value3的doubleValue方法抛出了空指针异常。
可以用以下案例验证三元表达式的类型转化规则
boolean condition false;
Double value1 1.0D;
Double value2 2.0D;
Double value3 null;
Integer value4 null;
// 返回类型为Double,不抛出空指针异常
Double result1 condition ? value1 : value3;
// 返回类型为double,会抛出空指针异常
Double result2 condition ? value1 : value4;
// 返回类型为double,不抛出空指针异常
Double result3 !condition ? value1 * value2 : value3;
// 返回类型为double,会抛出空指针异常
Double result4 condition ? value1 * value2 : value3;
2.3.避坑方法
(1)尽量避免使用三元表达式可以采用if-else语句代替
如果三元表达式中有算术计算和包装数据类型可以考虑利用if-else语句代替。改写代码如下
boolean condition false;
Double value1 1.0D;
Double value2 2.0D;
Double value3 null;
Double result;
if (condition) {result value1 * value2;
} else {result value3;
}
(2)尽量使用基本数据类型避免数据类型的自动转化
如果三元表达式中有算术计算和包装数据类型可以考虑利用if-else语句代替。改写代码如下
boolean condition false;
double value1 1.0D;
double value2 2.0D;
double value3 3.0D;
double result condition ? value1 * value2 : value3;
(3)进行覆盖性单元测试尽量把问题发现在研发阶段
像这种问题只要编写一些单元测试用例进行一些覆盖性测试是完全可以提前发现的。
3.泛型对象赋值
Java泛型是JDK1.5中引入的一个新特性其本质是参数化类型即把数据类型做为一个参数使用。
3.1.问题现象
在做用户数据分页查询时因为笔误编写了如下代码
(1)PageDataVO.java
/** 分页数据VO类 */
Getter
Setter
ToString
NoArgsConstructor
AllArgsConstructor
public class PageDataVOT {/** 总共数量 */private Long totalCount;/** 数据列表 */private ListT dataList;
}
(2)UserDAO.java
/** 用户DAO接口 */
Mapper
public interface UserDAO {/** 统计用户数量 */public Long countUser(Param(query) UserQueryVO query);/** 查询用户信息 */public ListUserDO queryUser(Param(query) UserQueryVO query);
}
(3)UserService.java
/** 用户服务类 */
Service
public class UserService {/** 用户DAO */Autowiredprivate UserDAO userDAO;/** 查询用户信息 */public PageDataVOUserVO queryUser(UserQueryVO query) {ListUserDO dataList null;Long totalCount userDAO.countUser(query);if (Objects.nonNull(totalCount) totalCount.compareTo(0L) 0) {dataList userDAO.queryUser(query);}return new PageDataVO(totalCount, dataList);}
}
(4)UserController.java
/** 用户控制器类 */
Controller
RequestMapping(/user)
public class UserController {/** 用户服务 */Autowiredprivate UserService userService;/** 查询用户 */ResponseBodyRequestMapping(value /query, method RequestMethod.POST)public ResultPageDataVOUserVO queryUser(RequestBody UserQueryVO query) {PageDataVOUserVO pageData userService.queryUser(query);return ResultBuilder.success(pageData);}
}
以上代码没有任何编译问题但是却把UserDO中一些涉密字段返回给前端。细心的读者可能已经发现了在UserService类的queryUser方法的语句return new PageDataVO(totalCount, dataList);中我们把ListUserDO对象dataList赋值给了PageDataVOUserVO的ListUserVO字段dataList。
问题是为什么开发工具不报编译错误啦
3.2.问题分析
由于历史原因参数化类型和原始类型需要兼容。我们以 ArrayList举例子来看看如何兼容的。
以前的写法
ArrayList list new ArrayList();
现在的写法
ArrayListString list new ArrayListString();
考虑到与以前的代码兼容各种对象引用之间传值必然会出现以下的情况
// 第一种情况
ArrayList list1 new ArrayListString();
// 第二种情况
ArrayListString list2 new ArrayList();
所以Java编译器对以上两种类型进行了兼容不会出现编译错误但会出现编译告警。但是我的开发工具在编译时真没出现过告警。
再来分析我们遇到的问题实际上同时命中了两种情况
把ListUserDO对象赋值给List命中了第一种情况把PageDataVO对象赋值给PageDataVOUserVO命中了第二种情况。
最终的效果就是我们神奇地把ListUserDO对象赋值给了ListUserVO。
问题的根源就是我们在初始化PageDataVO对象时没有要求强制进行类型检查。
3.3.避坑方法
(1)在初始化泛型对象时推荐使用diamond语法
在《阿里巴巴Java开发手册》中有这么一条推荐规则 【推荐】集合泛型定义时在 JDK7 及以上使用 diamond 语法或全省略。说明菱形泛型即 diamond直接使用来指代前边已经指定的类型。正例 // diamond 方式
HashMapString, String userCache new HashMap(16);
// 全省略方式
ArrayListUser users new ArrayList(10); 其实初始化泛型对象时全省略是不推荐的。这样会避免类型检查从而造成上面的问题。
在初始化泛型对象时推荐使用diamond语法代码如下
return new PageDataVO(totalCount, dataList);
现在在Eclipse的问题窗口中我们会看到这样的错误
Cannot infer type arguments for PageDataVO
于是我们就知道忘了把ListUserDO对象转化为ListUserVO对象了。
(2)在进行单元测试时需要对比数据内容
在进行单元测试时运行正常是一个指标但数据正确才是更重要的指标。
4.泛型属性拷贝
Spring的BeanUtils.copyProperties方法是一个很好用的属性拷贝工具方法。
4.1.问题现象
根据数据库开发规范数据库表格必须包含idgmt_creategmt_modified三个字段。其中id这个字段可能根据数据量不同采用int或long类型注意阿里规范要求必须是long类型这里为了举例说明允许为int或long类型。
所以把这三个字段抽出来定义了一个BaseDO基类
/** 基础DO类 */
Getter
Setter
ToString
public class BaseDOT {private T id;private Date gmtCreate;private Date gmtModified;
}
针对user表定义了一个UserDO类
/** 用户DO类 */
Getter
Setter
ToString
public class UserDO extends BaseDOLong{private String name;private String description;
}
对于查询接口定义了一个UserVO类
/** 用户VO类 */
Getter
Setter
ToString
public static class UserVO {private Long id;private String name;private String description;
}
实现查询用户服务接口实现代码如下
/** 用户服务类 */
Service
public class UserService {/** 用户DAO */Autowiredprivate UserDAO userDAO;/** 查询用户 */public ListUserVO queryUser(UserQueryVO query) {// 查询用户信息ListUserDO userDOList userDAO.queryUser(query);if (CollectionUtils.isEmpty()) {return Collections.emptyList();}// 转化用户列表ListUserVO userVOList new ArrayList(userDOList.size());for (UserDO userDO : userDOList) {UserVO userVO new UserVO();BeanUtils.copyProperties(userDO, userVO);userVOList.add(userVO);}// 返回用户列表return userVOList;}
}
通过测试我们会发现一个问题——调用查询用户服务接口用户ID的值并没有返回。
[{description:This is a tester.,name:tester},...]
4.2.问题分析
按道理UserDO类和UserVO类的id字段类型都是Long类型不存在类型不可转化应该能够正常赋值。尝试手工赋值代码如下
for (UserDO userDO : userDOList) {UserVO userVO new UserVO();userVO.setId(userDO.getId());userVO.setName(userDO.getName());userVO.setDescription(userDO.getDescription());userVOList.add(userVO);
}
经过测试上面代码返回结果正常用户ID的值成功返回。
那么就是BeanUtils.copyProperties工具方法的问题了。用Debug模式运行进入到BeanUtils.copyProperties工具方法内部得到以下数据 原来UserDO类的getId方法返回类型不是Long类型而是被泛型还原成了Object类型。而下面的ClassUtils.isAssignable工具方法判断是否能够把Object类型赋值给Long类型当然会返回false导致不能进行属性拷贝。
为什么作者不考虑先获取属性值再判断能否赋值”建议代码如下
Object value readMethod.invoke(source);
if (Objects.nonNull(value) ClassUtils.isAssignable(writeMethod.getParameterTypes()[0], value.getClass())) {... // 赋值相关代码
}
4.3.避坑方法
(1)不要盲目地相信第三方工具包任何工具包都有可能存在问题
在Java中存在很多第三方工具包比如Apache的commons-lang3、commons-collectionsGoogle的guava……都是很好用的第三方工具包。但是不要盲目地相信第三方工具包任何工具包都有可能存在问题。
(2)如果需要拷贝的属性较少可以手动编码进行属性拷贝
用BeanUtils.copyProperties反射拷贝属性主要优点是节省了代码量主要缺点是导致程序性能下降。所以如果需要拷贝的属性较少可以手动编码进行属性拷贝。
(3)一定要进行单元测试一定要对比数据内容
在编写完代码后一定要进行单元测试一定要对比数据内容。切莫想当然地认为工具包很成熟、代码也很简单不可能出现问题。
5.Set对象排重
在Java语言中Set数据结构可以用于对象排重常见的Set类有HashSet、LinkedHashSet等。
5.1.问题现象
编写了一个城市辅助类从CSV文件中读取城市数据
/** 城市辅助类 */
Slf4j
public class CityHelper {/** 测试主方法 */public static void main(String[] args) {CollectionCity cityCollection readCities2(cities.csv);log.info(JSON.toJSONString(cityCollection));}/** 读取城市 */public static CollectionCity readCities(String fileName) {try (FileInputStream stream new FileInputStream(fileName);InputStreamReader reader new InputStreamReader(stream, GBK);CSVParser parser new CSVParser(reader, CSVFormat.DEFAULT.withHeader())) {SetCity citySet new HashSet(1024);IteratorCSVRecord iterator parser.iterator();while (iterator.hasNext()) {citySet.add(parseCity(iterator.next()));}return citySet;} catch (IOException e) {log.warn(读取所有城市异常, e);}return Collections.emptyList();}/** 解析城市 */private static City parseCity(CSVRecord record) {City city new City();city.setCode(record.get(0));city.setName(record.get(1));return city;}/** 城市类 */GetterSetterToStringprivate static class City {/** 城市编码 */private String code;/** 城市名称 */private String name;}
}
代码中使用HashSet数据结构目的是为了避免城市数据重复对读取的城市数据进行强制排重。
当输入文件内容如下时
编码,名称
010,北京
020,广州
010,北京
解析后的JSON结果如下
[{code:010,name:北京},{code:020,name:广州},{code:010,name:北京}]
但是并没有对城市“北京”进行排重。
5.2.问题分析
当向集合Set中增加对象时首先集合计算要增加对象的hashCode根据该值来得到一个位置用来存放当前对象。如在该位置没有一个对象存在的话那么集合Set认为该对象在集合中不存在直接增加进去。如果在该位置有一个对象存在的话接着将准备增加到集合中的对象与该位置上的对象进行equals方法比较如果该equals方法返回false那么集合认为集合中不存在该对象就把该对象放在这个对象之后如果equals方法返回true那么就认为集合中已经存在该对象了就不会再将该对象增加到集合中了。所以在哈希表中判断两个元素是否重复要使用到hashCode方法和equals方法。hashCode方法决定数据在表中的存储位置而equals方法判断表中是否存在相同的数据。
分析上面的问题由于没有重写City类的hashCode方法和equals方法就会采用Object类的hashCode方法和equals方法。其实现如下
public native int hashCode();
public boolean equals(Object obj) {return (this obj);
}
可以看出Object类的hashCode方法是一个本地方法返回的是对象地址Object类的equals方法只比较对象是否相等。所以对于两条完全一样的北京数据由于在解析时初始化了不同的City对象导致hashCode方法和equals方法值都不一样必然被Set认为是不同的对象所以没有进行排重。
那么我们就重写把City类的hashCode方法和equals方法代码如下
/** 城市类 */
Getter
Setter
ToString
private static class City {/** 城市编码 */private String code;/** 城市名称 */private String name;/** 判断相等 */Overridepublic boolean equals(Object obj) {if (obj this) {return true;}if (Objects.isNull(obj)) {return false;}if (obj.getClass() ! this.getClass()) {return false;}return Objects.equals(this.code, ((City)obj).code);}/** 哈希编码 */Overridepublic int hashCode() {return Objects.hashCode(this.code);}
}
重新支持测试程序解析后的JSON结果如下
[{code:010,name:北京},{code:020,name:广州}]
结果正确已经对城市“北京”进行排重。
5.3.避坑方法
(1)当确定数据唯一时可以使用List代替Set
当确定解析的城市数据唯一时就没有必要进行排重操作可以直接使用List来存储。
ListCity citySet new ArrayList(1024);
IteratorCSVRecord iterator parser.iterator();
while (iterator.hasNext()) {citySet.add(parseCity(iterator.next()));
}
return citySet;
(2)当确定数据不唯一时可以使用Map代替Set
当确定解析的城市数据不唯一时需要安装城市名称进行排重操作可以直接使用Map进行存储。为什么不建议实现City类的hashCode方法再采用HashSet来实现排重呢首先不希望把业务逻辑放在模型DO类中其次把排重字段放在代码中便于代码的阅读、理解和维护。
MapString, City cityMap new HashMap(1024);
IteratorCSVRecord iterator parser.iterator();
while (iterator.hasNext()) {City city parseCity(iterator.next());cityMap.put(city.getCode(), city);
}
return cityMap.values();
(3)遵循Java语言规范重写hashCode方法和equals方法
不重写hashCode方法和equals方法的自定义类不应该在Set中使用。
6.公有方法代理
SpringCGLIB代理生成的代理类是一个继承被代理类通过重写被代理类中的非final的方法实现代理。所以SpringCGLIB代理的类不能是final类代理的方法也不能是final方法这是由继承机制限制的。
6.1.问题现象
这里举例一个简单的例子只有超级用户才有删除公司的权限并且所有服务函数被AOP拦截处理异常。例子代码如下
(1)UserService.java
/** 用户服务类 */
Service
public class UserService {/** 超级用户 */private User superUser;/** 设置超级用户 */public void setSuperUser(User superUser) {this.superUser superUser;}/** 获取超级用户 */public final User getSuperUser() {return this.superUser;}
}
(2)CompanyService.java
/** 公司服务类 */
Service
public class CompanyService {/** 公司DAO */Autowiredprivate CompanyDAO companyDAO;/** 用户服务 */Autowiredprivate UserService userService;/** 删除公司 */public void deleteCompany(Long companyId, Long operatorId) {// 设置超级用户userService.setSuperUser(new User(0L, admin, 超级用户));// 验证超级用户if (!Objects.equals(operatorId, userService.getSuperUser().getId())) {throw new ExampleException(只有超级用户才能删除公司);}// 删除公司信息companyDAO.delete(companyId, operatorId);}
}
(3)AopConfiguration.java
/** AOP配置类 */
Slf4j
Aspect
Configuration
public class AopConfiguration {/** 环绕方法 */Around(execution(* org.changyi.springboot.service..*.*(..)))public Object around(ProceedingJoinPoint joinPoint) {try {log.info(开始调用服务方法...);return joinPoint.proceed();} catch (Throwable e) {log.error(e.getMessage(), e);throw new ExampleException(e.getMessage(), e);}}
}
当我们调用CompanyService的deleteCompany方法时居然也抛出空指针异常NullPointerException因为调用UserService类的getSuperUser方法获取的超级用户为null。但是我们在CompanyService类的deleteCompany方法中每次都通过UserService类的setSuperUser方法强制指定了超级用户按道理通过UserService类的getSuperUser方法获取到的超级用户不应该为null。其实这个问题也是由AOP代理导致的。
6.2.问题分析
使用SpringCGLIB代理类时Spring会创建一个名为UserService$$EnhancerBySpringCGLIB$$????????的代理类。反编译这个代理类得到以下主要代码
public class UserService$$EnhancerBySpringCGLIB$$a2c3b345 extends UserService implements SpringProxy, Advised, Factory {......public final void setSuperUser(User var1) {MethodInterceptor var10000 this.CGLIB$CALLBACK_0;if (var10000 null) {CGLIB$BIND_CALLBACKS(this);var10000 this.CGLIB$CALLBACK_0;}if (var10000 ! null) {var10000.intercept(this, CGLIB$setSuperUser$0$Method, new Object[]{var1}, CGLIB$setSuperUser$0$Proxy);} else {super.setSuperUser(var1);}}......
}
可以看出这个代理类继承了UserService类代理了setSuperUser方法但是没有代理getSuperUser方法。所以当我们调用setSuperUser方法时设置的是原始对象实例的superUser字段值而当我们调用getSuperUser方法时获取的是代理对象实例的superUser字段值。如果把这两个方法的final修饰符互换同样存在获取超级用户为null的问题。
6.3.避坑方法
(1)严格遵循CGLIB代理规范被代理的类和方法不要加final修饰符
严格遵循CGLIB代理规范被代理的类和方法不要加final修饰符避免动态代理操作对象实例不同原始对象实例和代理对象实例从而导致数据不一致或空指针问题。
(2)缩小CGLIB代理类的范围能不用被代理的类就不要被代理
缩小CGLIB代理类的范围能不用被代理的类就不要被代理即可以节省内存开销又可以提高函数调用效率。
7.公有字段代理
在fastjson强制升级到1.2.60时踩过一个坑作者为了开发快速在ParseConfig中定义了
public class ParseConfig {public final SymbolTable symbolTable new SymbolTable(4096);......
}
在我们的项目中继承了该类同时又被AOP动态代理了于是一行代码引起了一场“血案”。
7.1.问题现象
仍然使用上章的例子但是把获取、设置方法删除定义了一个公有字段。例子代码如下
(1)UserService.java
/** 用户服务类 */
Service
public class UserService {/** 超级用户 */public final User superUser new User(0L, admin, 超级用户);......
}
(2)CompanyService.java
/** 公司服务类 */
Service
public class CompanyService {/** 公司DAO */Autowiredprivate CompanyDAO companyDAO;/** 用户服务 */Autowiredprivate UserService userService;/** 删除公司 */public void deleteCompany(Long companyId, Long operatorId) {// 验证超级用户if (!Objects.equals(operatorId, userService.superUser.getId())) {throw new ExampleException(只有超级用户才能删除公司);}// 删除公司信息companyDAO.delete(companyId, operatorId);}
}
(3)AopConfiguration.java
同上一章AopConfiguration.java。
当我们调用CompanyService的deleteCompany方法时居然抛出空指针异常NullPointerException。经过调试打印发现是UserService的superUser变量为null。如果把AopConfiguration删除就不会出现空指针异常说明这个问题是由AOP代理导致的。
7.2.问题分析
使用SpringCGLIB代理类时Spring会创建一个名为UserService$$EnhancerBySpringCGLIB$$????????的代理类。这个代理类继承了UserService类并覆盖了UserService类中的所有非final的public的方法。但是这个代理类并不调用super基类的方法相反它会创建的一个成员userService并指向原始的UserService类对象实例。现在内存中存在两个对象实例一个是原始的UserService对象实例另一个指向UserService的代理对象实例。这个代理类只是一个虚拟代理它继承了UserService类并且具有与UserService相同的字段但是它从来不会去初始化和使用它们。所以一但通过这个代理类对象实例获取公有成员变量时将返回一个默认值null。 7.3.避坑方法
(1)当确定字段不可变时可以定义为公有静态常量
当确定字段不可变时可以定义为公有静态常量并用类名称字段名称访问。类名称字段名称访问公有静态常量与类实例的动态代理无关。
/** 用户服务类 */
Service
public class UserService {/** 超级用户 */public static final User SUPER_USER new User(0L, admin, 超级用户);......
}/** 使用代码 */
if (!Objects.equals(operatorId, UserService.SUPER_USER.getId())) {throw new ExampleException(只有超级用户才能删除公司);
}
(2)当确定字段不可变时可以定义为私有成员变量
当确定字段不可变时可以定义为私有成员变量提供一个公有方法获取该变量值。当该类实例被动态代理时代理方法会调用被代理方法从而返回被代理类的成员变量值。
/** 用户服务类 */
Service
public class UserService {/** 超级用户 */private User superUser new User(0L, admin, 超级用户);/** 获取超级用户 */public User getSuperUser() {return this.superUser;}......
}/** 使用代码 */
if (!Objects.equals(operatorId, userService.getSuperUser().getId())) {throw new ExampleException(只有超级用户才能删除公司);
}
(3)遵循JavaBean编码规范不要定义公有成员变量
遵循JavaBean编码规范不要定义公有成员变量。JavaBean规范如下 (1)JavaBean类必须是一个公共类并将其访问属性设置为public如public class User{......} (2)JavaBean类必须有一个空的构造函数类中必须有一个不带参数的公用构造器(3)一个JavaBean类不应有公共实例变量类变量都为private如private Integer id; (4)属性应该通过一组getter/setter方法来访问。 后记
人类受益于“类比”思维举一反三就是人类的智慧每当遇到新生事物时人们往往用类似的已知事物作为参考能够加速对新生事物的认知。而人类又受制于“定势”思维因为已知事物并不能代表新生事物而人们又容易形成先入为主的概念最终导致对新生事物产生误判。
作者信息陈昌毅花名常意高德地图技术专家2018 年加入阿里巴巴一直从事地图数据采集的相关工作。
原文链接
本文为云栖社区原创内容未经允许不得转载。
