其他
那些年,我们踩过的 Java 坑
The following article is from 阿里巴巴中间件 Author 常意
脚本之家
你与百万开发者在一起
文 | 常意
1.前言
中国有句老话叫"事不过三",指一个人犯了同样的错误,一次两次三次还可以原谅,超过三次就不可原谅了。有人指出这个“三”是虚数,用来泛指多次,所以"事不过三"不包括“三”。至于"事不过三"包不包括“三”,可能跟每个人的底线有关系,属于哲学范畴,不在本文的讨论范围之内。
1.对象比较方法
1.1.问题现象
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
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
1.2.问题分析
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]
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]
在 Java 语言中,整数的默认数据类型是 int ,小数的默认数据类型是 double 。
return (a == b) || (a != null && a.equals(b));
}
if (obj instanceof Short) {
return value == ((Short)obj).shortValue();
}
return false;
}
1.3.避坑方法
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
第二段代码可以这样写:
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
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
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]
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; // 抛出空指针异常
2.2.问题分析
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]
若两个表达式类型相同,返回值类型为该类型; 若两个表达式类型不同,但类型不可转换,返回值类型为Object类型; 若两个表达式类型不同,但类型可以转化,先把包装数据类型转化为基本数据类型,然后按照基本数据类型的转换规则(byte<short(char)<int<long<float<double)来转化,返回值类型为优先级最高的基本数据类型。
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.避坑方法
Double value1 = 1.0D;
Double value2 = 2.0D;
Double value3 = null;
Double result;
if (condition) {
result = value1 * value2;
} else {
result = value3;
}
double value1 = 1.0D;
double value2 = 2.0D;
double value3 = 3.0D;
double result = condition ? value1 * value2 : value3;
3.泛型对象赋值
3.1.问题现象
@Getter
@Setter
@ToString
@NoArgsConstructor
@AllArgsConstructor
public class PageDataVO<T> {
/** 总共数量 */
private Long totalCount;
/** 数据列表 */
private List<T> dataList;
}
@Mapper
public interface UserDAO {
/** 统计用户数量 */
public Long countUser(@Param("query") UserQueryVO query);
/** 查询用户信息 */
public List<UserDO> queryUser(@Param("query") UserQueryVO query);
}
@Service
public class UserService {
/** 用户DAO */
@Autowired
private UserDAO userDAO;
/** 查询用户信息 */
public PageDataVO<UserVO> queryUser(UserQueryVO query) {
List<UserDO> dataList = null;
Long totalCount = userDAO.countUser(query);
if (Objects.nonNull(totalCount) && totalCount.compareTo(0L) > 0) {
dataList = userDAO.queryUser(query);
}
return new PageDataVO(totalCount, dataList);
}
}
@Controller
@RequestMapping("/user")
public class UserController {
/** 用户服务 */
@Autowired
private UserService userService;
/** 查询用户 */
@ResponseBody
@RequestMapping(value = "/query", method = RequestMethod.POST)
public Result<PageDataVO<UserVO>> queryUser(@RequestBody UserQueryVO query) {
PageDataVO<UserVO> pageData = userService.queryUser(query);
return ResultBuilder.success(pageData);
}
}
3.2.问题分析
ArrayList list1 = new ArrayList<String>();
// 第二种情况
ArrayList<String> list2 = new ArrayList();
3.3.避坑方法
【推荐】集合泛型定义时,在 JDK7 及以上,使用 diamond 语法或全省略。说明:菱形泛型,即 diamond,直接使用<>来指代前边已经指定的类型。正例: // <> diamond 方式
HashMap<String, String> userCache = new HashMap<>(16);
// 全省略方式
ArrayList<User> users = new ArrayList(10);
现在,在 Eclipse 的问题窗口中,我们会看到这样的错误:
4.泛型属性拷贝
Spring 的 BeanUtils.copyProperties 方法,是一个很好用的属性拷贝工具方法。
4.1.问题现象
@Getter
@Setter
@ToString
public class BaseDO<T> {
private T id;
private Date gmtCreate;
private Date gmtModified;
}
@Getter
@Setter
@ToString
public class UserDO extends BaseDO<Long>{
private String name;
private String description;
}
@Getter
@Setter
@ToString
public static class UserVO {
private Long id;
private String name;
private String description;
}
@Service
public class UserService {
/** 用户DAO */
@Autowired
private UserDAO userDAO;
/** 查询用户 */
public List<UserVO> queryUser(UserQueryVO query) {
// 查询用户信息
List<UserDO> userDOList = userDAO.queryUser(query);
if (CollectionUtils.isEmpty()) {
return Collections.emptyList();
}
// 转化用户列表
List<UserVO> userVOList = new ArrayList<>(userDOList.size());
for (UserDO userDO : userDOList) {
UserVO userVO = new UserVO();
BeanUtils.copyProperties(userDO, userVO);
userVOList.add(userVO);
}
// 返回用户列表
return userVOList;
}
}
4.2.问题分析
UserVO userVO = new UserVO();
userVO.setId(userDO.getId());
userVO.setName(userDO.getName());
userVO.setDescription(userDO.getDescription());
userVOList.add(userVO);
}
if (Objects.nonNull(value) && ClassUtils.isAssignable(writeMethod.getParameterTypes()[0], value.getClass())) {
... // 赋值相关代码
}
4.3.避坑方法
5.Set对象排重
5.1.问题现象
@Slf4j
public class CityHelper {
/** 测试主方法 */
public static void main(String[] args) {
Collection<City> cityCollection = readCities2("cities.csv");
log.info(JSON.toJSONString(cityCollection));
}
/** 读取城市 */
public static Collection<City> readCities(String fileName) {
try (FileInputStream stream = new FileInputStream(fileName);
InputStreamReader reader = new InputStreamReader(stream, "GBK");
CSVParser parser = new CSVParser(reader, CSVFormat.DEFAULT.withHeader())) {
Set<City> citySet = new HashSet<>(1024);
Iterator<CSVRecord> 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;
}
/** 城市类 */
@Getter
@Setter
@ToString
private static class City {
/** 城市编码 */
private String code;
/** 城市名称 */
private String name;
}
}
010,北京
020,广州
010,北京
但是,并没有对城市“北京”进行排重。
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);
}
@Getter
@Setter
@ToString
private static class City {
/** 城市编码 */
private String code;
/** 城市名称 */
private String name;
/** 判断相等 */
@Override
public 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);
}
/** 哈希编码 */
@Override
public int hashCode() {
return Objects.hashCode(this.code);
}
}
5.3.避坑方法
Iterator<CSVRecord> iterator = parser.iterator();
while (iterator.hasNext()) {
citySet.add(parseCity(iterator.next()));
}
return citySet;
Iterator<CSVRecord> iterator = parser.iterator();
while (iterator.hasNext()) {
City city = parseCity(iterator.next());
cityMap.put(city.getCode(), city);
}
return cityMap.values();
6.公有方法代理
6.1.问题现象
@Service
public class UserService {
/** 超级用户 */
private User superUser;
/** 设置超级用户 */
public void setSuperUser(User superUser) {
this.superUser = superUser;
}
/** 获取超级用户 */
public final User getSuperUser() {
return this.superUser;
}
}
@Service
public class CompanyService {
/** 公司DAO */
@Autowired
private CompanyDAO companyDAO;
/** 用户服务 */
@Autowired
private 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);
}
}
@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);
}
}
}
6.2.问题分析
......
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);
}
}
......
}
6.3.避坑方法
7.公有字段代理
public final SymbolTable symbolTable = new SymbolTable(4096);
......
}
7.1.问题现象
@Service
public class UserService {
/** 超级用户 */
public final User superUser = new User(0L, "admin", "超级用户");
......
}
@Service
public class CompanyService {
/** 公司DAO */
@Autowired
private CompanyDAO companyDAO;
/** 用户服务 */
@Autowired
private UserService userService;
/** 删除公司 */
public void deleteCompany(Long companyId, Long operatorId) {
// 验证超级用户
if (!Objects.equals(operatorId, userService.superUser.getId())) {
throw new ExampleException("只有超级用户才能删除公司");
}
// 删除公司信息
companyDAO.delete(companyId, operatorId);
}
}
7.2.问题分析
7.3.避坑方法
@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("只有超级用户才能删除公司");
}
@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("只有超级用户才能删除公司");
}
(1)JavaBean类必须是一个公共类,并将其访问属性设置为public,如:public class User{......}(2)JavaBean类必须有一个空的构造函数:类中必须有一个不带参数的公用构造器(3)一个JavaBean类不应有公共实例变量,类变量都为private,如:private Integer id;(4)属性应该通过一组getter/setter方法来访问。
后记
陈昌毅,花名常意,高德地图技术专家,2018 年加入阿里巴巴,一直从事地图数据采集的相关工作。
更多精彩
在公众号后台对话框输入以下关键词
查看更多优质内容!
女朋友 | 大数据 | 运维 | 书单 | 算法
大数据 | JavaScript | Python | 黑客
AI | 人工智能 | 5G | 区块链
机器学习 | 数学 | 送书
●