《Dubbo 实现原理与源码解析 —— 精品合集》 《Netty 实现原理与源码解析 —— 精品合集》
《Spring 实现原理与源码解析 —— 精品合集》 《MyBatis 实现原理与源码解析 —— 精品合集》
《Spring MVC 实现原理与源码解析 —— 精品合集》 《数据库实体设计合集》
《Spring Boot 实现原理与源码解析 —— 精品合集》 《Java 面试题 + Java 学习指南》

摘要: 原创出处 捡田螺的小男孩 「捡田螺的小男孩」欢迎转载,保留摘要,谢谢!


🙂🙂🙂关注微信公众号:【芋道源码】有福利:

  1. RocketMQ / MyCAT / Sharding-JDBC 所有源码分析文章列表
  2. RocketMQ / MyCAT / Sharding-JDBC 中文注释源码 GitHub 地址
  3. 您对于源码的疑问每条留言将得到认真回复。甚至不知道如何读源码也可以请教噢
  4. 新的源码解析文章实时收到通知。每周更新一篇左右
  5. 认真的源码交流微信群。

前言

工作了四年,看过很多思考不够深入的代码,因此写一下总结吧,50个让你代码更好的建议。其中的一些点,我以前的文章也写过啦,这次主要汇总一下。希望大家日常写代码多点思考,多点总结,加油!同时哪里有不对的,也望指出,感谢哈~

1. 仅是判断是否存在时,select count 比 select 具体的列,更好。

我们经常遇到类似的业务场景,如,判断某个用户userId是否是会员。

(反例): 一些小伙伴会这样实现,先查从用户信息表查出用户记录,然后再去判断是否是会员:

<select id="selectUserByUserId" resultMap="BaseResultMap">
selct user_id , vip_flag from user_info where user_id =#{userId};
</select>

boolean isVip (String userId){
UserInfo userInfo = userInfoDAp.selectUserByUserId(userId);
return UserInfo!=null && "Y".equals(userInfo.getVipFlag())
}

(正例): 针对这种业务场景,其实更好的实现,是直接select count一下,如下:

<select id="countVipUserByUserId" resultType="java.lang.Integer">
selct count(1) from user_info where user_id =#{userId} and vip_flag ='Y';
</select>

boolean isVip (String userId){
int vipNum = userInfoDAp.countVipUserByUserId(userId);
return vipNum>0
}

2. 复杂的if逻辑条件,可以调整顺序,让程序更高效

假设业务需求是这样:如果用户是会员,并且第一次登陆时,需要发一条通知的短信。假如没有经过思考,代码很可能直接这样写了。

if(isUserVip && isFirstLogin){
sendMsgNotify();
}

假设总共有5个请求进来,isUserVip通过的有3个请求,isFirstLogin通过的有1个请求。 那么以上代码,isUserVip执行的次数为5次,isFirstLogin执行的次数也是3次,如下:

image.png

如果调整一下isUserVip和isFirstLogin的顺序呢?

if(isFirstLogin && isUserVip ){
sendMsg();
}

isFirstLogin执行的次数是5次,isUserVip执行的次数是1次,如下:

image.png

如果你的isFirstLogin,判断逻辑只是select count 一下数据库表,isUserVip也是select count 一下数据库表的话,显然,把isFirstLogin放在前面更高效。

3. 写查询Sql的时候,只查你需要用到的字段,还有通用的字段,拒绝反手的select *

反例:

select * from user_info where user_id =#{userId};

正例:

selct user_id , vip_flag from  user_info where user_id =#{userId};

理由:

  • 节省资源、减少网络开销。
  • 可能用到覆盖索引,减少回表,提高查询效率。

4. 优化你的程序,拒绝创建不必要的对象

如果你的变量,后面的逻辑判断,一定会被赋值;或者说,只是一个字符串变量,直接初始化字符串常量就可以了,没有必要愣是要new String().

反例:

String s = new String ("欢迎关注 公众 号:芋道源码");

正例:

String s=  "欢迎关注 公众 号:芋道源码 ”;

5. 初始化集合时,指定容量

阿里的开发手册,也明确提到这个点: image.png

假设你的map要存储的元素个数是15个左右,最优写法如下

```

# 6.catch了异常,需要打印出具体的exception,方便更好定位问题

**反例:**

```Java
try{
// do something
}catch(Exception e){
log.info("芋道源码,你的程序有异常啦");
}

正例:

try{
// do something
}catch(Exception e){
log.info("芋道源码,你的程序有异常啦:",e); //把exception打印出来
}

理由:

  • 反例中,并没有把exception出来,到时候排查问题就不好查了啦,到底是SQl写错的异常还是IO异常,还是其他呢?所以应该把exception打印到日志中哦~

7. 打印日志的时候,对象没有覆盖Object的toString的方法,直接把类名打印出来了。

我们在打印日志的时候,经常想看下一个请求参数对象request是什么。于是很容易有类似以下这些代码:

publick Response dealWithRequest(Request request){
log.info("请求参数是:".request.toString)
}

打印结果如下:

请求参数是:local.Request@49476842

这是因为对象的toString方法,默认的实现是“类名@散列码的无符号十六进制”。所以你看吧,这样子打印日志就没啥意思啦,你都不知道打印的是什么内容。

所以一般对象(尤其作为传参的对象),都覆盖重写toString()方法

class Request {

private String age;

private String name;

@Override
public String toString() {
return "Request{" +
"age='" + age + '\'' +
", name='" + name + '\'' +
'}';
}
}

publick Response dealWithRequest(Request request){
log.info("请求参数是:".request.toString)
}

打印结果如下:

请求参数是:Request{age='26', name='公众 号:芋道源码'}

8. 一个方法,拒绝过长的参数列表。

假设有这么一个公有方法,形参有四个。。。

public void getUserInfo(String name,String age,String sex,String mobile){
// do something ...
}

如果现在需要多传一个version参数进来,并且你的公有方法是类似dubbo这种对外提供的接口的话,那么你的接口是不是需要兼容老版本啦?

public void getUserInfo(String name,String age,String sex,String mobile){
// do something ...
}

/**
* 新接口调这里
*/
public void getNewUserInfo(String name,String age,String sex,String mobile,String version){
// do something ...
}

所以呢,一般一个方法的参数,一般不宜过长。过长的参数列表,不仅看起来不优雅,并且接口升级时,可能还要考虑新老版本兼容。如果参数实在是多怎么办呢?可以用个DTO对象包装一下这些参数呢~如下:

public void getUserInfo(UserInfoParamDTO userInfoParamDTO){
// do something ...
}

class UserInfoParamDTO{
private String name;
private String age;
private String sex;
private String mobile;
}

用个DTO对象包装一下,即使后面有参数变动,也可以不用动对外接口了,好处杠杠的。

9. 使用缓冲流,减少IO操作

反例:

/**
* 公众 号:芋道源码
* @desc: 复制一张图片文件
*/
public class MainTest {
public static void main(String[] args) throws FileNotFoundException {
long begin = System.currentTimeMillis();
try (FileInputStream input = new FileInputStream("C:/456.png");
FileOutputStream output = new FileOutputStream("C:/789.png")) {
byte[] bytes = new byte[1024];
int i;
while ((i = input.read(bytes)) != -1) {
output.write(bytes,0,i);
}
} catch (IOException e) {
log.error("复制文件发生异常",e);
}
log.info("常规流读写,总共耗时ms:"+(System.currentTimeMillis() - begin));
}
}

运行结果:

常规流读写,总共耗时ms:52

使用FileInputStreamFileOutputStream实现文件读写功能,是没有什么问题的。但是呢,可以使用缓冲流BufferedReaderBufferedWriterBufferedInputStreamBufferedOutputStream等,减少IO次数,提高读写效率。

如果是不带缓冲的流,读取到一个字节或者字符的,就会直接输出数据了。而带缓冲的流,读取到一个字节或者字符时,先不输出,而是等达到缓冲区的最大容量,才一次性输出。

正例:

//**
* 公众 号:芋道源码
* @desc: 复制一张图片文件
*/
public class MainTest {
public static void main(String[] args) throws FileNotFoundException {
long begin = System.currentTimeMillis();
try (BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("C:/456.png"));
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("C:/789.png"))) {
byte[] bytes = new byte[1024];
int i;
while ((i = input.read(bytes)) != -1) {
output.write(bytes,0,i);
}
} catch (IOException e) {
log.error("复制文件发生异常",e);
}
log.info("总共耗时ms"+(System.currentTimeMillis() - begin));
}
}

运行结果:

缓冲流读写,总共耗时ms:12

10. 优化你的程序逻辑,比如前面已经查到的数据,在后面的方法也用到的话,是可以把往下传参的,减少方法调用/查表

反例:

public Response dealRequest(Request request){

UserInfo userInfo = userInfoDao.selectUserByUserId(request.getUserId);
if(Objects.isNull(request)){
return ;
}

insertUserVip(request.getUserId);

}

private int insertUserVip(String userId){
//又查了一次
UserInfo userInfo = userInfoDao.selectUserByUserId(request.getUserId);
//插入用户vip流水
insertUserVipFlow(userInfo);
....
}

很显然,以上程序代码,已经查到 userInfo,然后又把userId传下去,又查多了一次。。。实际上,可以把userInfo传下去的,这样可以省去一次查表操作,程序更高效。

正例:

public Response dealRequest(Request request){

UserInfo userInfo = userInfoDao.selectUserByUserId(request.getUserId);
if(Objects.isNull(request)){
return ;
}

insertUserVip(userInfo);
}

private int insertUserVip(UserInfo userInfo){
//插入用户vip流水
insertUserVipFlow(userInfo);
....
}

11. 不要为了方便,直接在代码中使用0,1等魔法值,应该要用enum枚举代替。

反例:

if("0".equals(userInfo.getVipFlag)){
//非会员,提示去开通会员
tipOpenVip(userInfo);
}else if("1".equals(userInfo.getVipFlag)){
//会员,加勋章返回
addMedal(userInfo);
}

正例:

if(UserVipEnum.NOT_VIP.getCode.equals(userInfo.getVipFlag)){
//非会员,提示去开通会员
tipOpenVip(userInfo);
}else if(UserVipEnum.VIP.getCode.equals(userInfo.getVipFlag)){
//会员,加勋章返回
addMedal(userInfo);
}

public enum UserVipEnum {

VIP("1","会员"),
NOT_VIP("0","非会员"),:;

private String code;
private String desc;

UserVipEnum(String code, String desc) {
this.code = code;
this.desc = desc;
}
}

写代码的时候,不要一时兴起,就直接使用魔法值哈。使用魔法值,维护代码起来很难受的。

12. 当成员变量值不会改变时,优先定义为静态常量

反例:

public class Task {
private final long timeout = 10L;
...
}

正例:

public class Task {
private static final long TIMEOUT = 10L;
...
}

因为如果定义为static,即类静态常量,在每个实例对象中,它只有一份副本。如果是成员变量,每个实例对象中,都各有一份副本。显然,如果这个变量不会变的话,定义为静态常量更好一些。

13. 注意检验空指针,不要轻易相信业务,说正常逻辑某个参数不可能为空。

NullPointerException 在我们日常开发中非常常见,我们代码开发过程中,一定要对空指针保持灵敏的嗅觉。

主要有这几类空指针问题:

  • 包装类型的空指针问题
  • 级联调用的空指针问题
  • Equals方法左边的空指针问题
  • ConcurrentHashMap 类似容器不支持 k-v为 null。
  • 集合,数组直接获取元素
  • 对象直接获取属性

反例:

public class NullPointTest {
public static void main(String[] args) {
String s = null;
if (s.equals("666")) { //s可能为空,会导致空指针问题
System.out.println("公众 号:芋道源码,干货满满");
}
}
}

14,捕获到的异常,不能忽略它,至少打点日志。

反例:

public static void testIgnoreException() throws Exception {
try {
// 搞事情
} catch (Exception e) {
//捕获了异常,啥事情不做,日志也不打??
}
}

正例:

public static void testIgnoreException() {
try {
// 搞事情
} catch (Exception e) {
log.error("异常了,联系开发小哥哥看看哈",e);
}
}

15. 采用Lambda表达式替换内部匿名类,使代码更优雅

JDK8出现了新特性-Lambda表达式。Lambda表达式不仅比匿名内部类更加优雅,并且在大多数虚拟机中,都是采用invokeDynamic指令实现,相对于匿名内部类,效率也更高

反例:

public void sortUserInfoList(List<UserInfo> userInfoList){
userInfoList.sort(new Comparator<UserInfo>() {
@Override
public int compare(UserInfo user1, UserInfo user2) {
Long userId1 = user1.getUserId();
Long userId2 = user2.getUserId();
return userId1.compareTo(userId2);
}});
}

正例:

public void sortUserInfoList(List<UserInfo> userInfoList){
userInfoList.sort((user1, user2) -> {
Long userId1 = user1.getUserId();
Long userId2 = user2.getUserId();
return userId1.compareTo(userId2);
});
}

16. 通知类(如发邮件,有短信)的代码,建议异步处理。

假设业务流程这样:需要在用户登陆时,添加个短信通知它的粉丝。 很容易想到的实现流程如下:

image.png

假设提供sendMsgNotify服务的系统挂了,或者调用sendMsgNotify失败了,那么用户登陆就失败了。。。 一个通知功能导致了登陆主流程不可用,明显的捡了芝麻丢西瓜。那么有没有鱼鱼熊掌兼得的方法呢?有的,给发短信接口捕获异常处理,或者另开线程异步处理,如下:

image.png

因此,添加通知类等不是非主要,可降级的接口时,应该静下心来考虑是否会影响主要流程,思考怎么处理最好。

17. 处理Java日期时,当心YYYY格式设置的问题。

日常开发中,我们经常需要处理日期。我们要当时日期格式化的时候,年份是大写YYYY的坑。

Calendar calendar = Calendar.getInstance();
calendar.set(2019, Calendar.DECEMBER, 31);

Date testDate = calendar.getTime();

SimpleDateFormat dtf = new SimpleDateFormat("YYYY-MM-dd");
System.out.println("2019-12-31 转 YYYY-MM-dd 格式后 " + dtf.format(testDate));

运行结果:

2019-12-31 转 YYYY-MM-dd 格式后 2020-12-31

为什么明明是2019年12月31号,就转了一下格式,就变成了2020年12月31号了?因为YYYY是基于周来计算年的,它指向当天所在周属于的年份,一周从周日开始算起,周六结束,只要本周跨年,那么这一周就算下一年的了。正确姿势是使用yyyy格式。

image.png

18. 如果一个类确定不会被继承,不会拿来搞AOP骚操作,可以指定final修饰符,如用final修饰一个工具类。

正例:

public final class Tools {
public static void testFinal(){
System.out.println("工具类方法");
}
}

一个类指定了final修饰符,它不会被继承了,并且其所有方法都是final的了。Java编译器会找机会内联所有的final方法,提升了Java运行效率。

19. static静态变量不要依赖spring实例化变量,可能会导致初始化出错

之前看到项目有类似的代码。静态变量依赖于spring容器的bean。

private static SmsService smsService = SpringContextUtils.getBean(SmsService.class);

这个静态的smsService有可能获取不到的,因为类加载顺序不是确定的,而以上的代码,静态的smsService初始化强制依赖spring容器的实例了。正确的写法可以这样,如下:

private static SmsService  smsService =null;

//使用到的时候采取获取
public static SmsService getSmsService(){
if(smsService==null){
smsService = SpringContextUtils.getBean(SmsService.class);
}
return smsService;
}

20. 与类成员变量无关的方法,应当声明成静态方法

有些方法,与实例成员变量无关,就可以声明为静态方法。这一点,工具类用得很多。反例如下

/**
* BigDecimal的工具类
*/
public class BigDecimalUtils {

public BigDecimal ifNullSetZERO(BigDecimal in) {
return in != null ? in : BigDecimal.ZERO;
}

public BigDecimal sum(BigDecimal ...in){
BigDecimal result = BigDecimal.ZERO;
for (int i = 0; i < in.length; i++){
result = result.add(ifNullSetZERO(in[i]));
}
return result;
}

因为BigDecimalUtils工具类的方法都没有static修饰,所以,你要使用的时候,每次都要new一下啦,那不就耗资源去反复创建对象了嘛!!

BigDecimalUtils bigDecimalUtils = new BigDecimalUtils();
bigDecimalUtils.sum(a,b);

所以可以声明成静态变量,使用的时候,直接类名.方法调用即可,正例如下:

/**
* BigDecimal的工具类
*/
public class BigDecimalUtils {

public static BigDecimal ifNullSetZERO(BigDecimal in) {
return in != null ? in : BigDecimal.ZERO;
}

public static BigDecimal sum(BigDecimal ...in){
BigDecimal result = BigDecimal.ZERO;
for (int i = 0; i < in.length; i++){
result = result.add(ifNullSetZERO(in[i]));
}
return result;
}

21. 不要用一个Exception捕捉所有可能的异常。

反例:

public void test(){
try{
//…抛出 IOException 的代码调用
//…抛出 SQLException 的代码调用
}catch(Exception e){
//用基类 Exception 捕捉的所有可能的异常,如果多个层次都这样捕捉,会丢失原始异常的有效信息哦
log.info(“Exception in test,exception:{}”, e);
}
}

正例:

public void test(){
try{
//…抛出 IOException 的代码调用
//…抛出 SQLException 的代码调用
}catch(IOException e){
//仅仅捕捉 IOException
log.info(“IOException in test,exception:{}”, e);
}catch(SQLException e){
//仅仅捕捉 SQLException
log.info(“SQLException in test,exception:{}”, e);
}
}

22. 函数不要过度封装,言简意赅即可。

反例:

// 函数封装
public static boolean isUserVip(Boolean isVip) {
return Boolean.TRUE.equals(isVip);
}

// 使用代码
boolean isVip = isVip(user.getUserVip());

正例:

boolean isVip = Boolean.TRUE.equals(user.getUserVip());

函数不要过度封装,把意思表达清楚即可。并且,方法调用会引起入栈和出栈,导致消耗更多的CPU和内存,过度封装,会损耗性能的!

23. 如果变量的初值一定会被覆盖,就没有必要给变量赋初值。

反例:

List<UserInfo> userList = new ArrayList<>();
if (isAll) {
userList = userInfoDAO.queryAll();
} else {
userList = userInfoDAO.queryActive();
}

正例:

List<UserInfo> userList ;
if (isAll) {
userList = userInfoDAO.queryAll();
} else {
userList = userInfoDAO.queryActive();
}

24.金额数值计算要使用BigDecimal

看下这个浮点数计算的例子吧:

public class DoubleTest {
public static void main(String[] args) {
System.out.println(0.1+0.2);
System.out.println(1.0-0.8);
System.out.println(4.015*100);
System.out.println(123.3/100);

double amount1 = 3.15;
double amount2 = 2.10;
if (amount1 - amount2 == 1.05){
System.out.println("OK");
}
}
}

运行结果:

0.30000000000000004
0.19999999999999996
401.49999999999994
1.2329999999999999

因为计算机是以二进制存储数值的,对于浮点数也是。对于计算机而言,0.1无法精确表达,这就是为什么浮点数会导致精确度缺失的。因此,金额计算,一般都是用BigDecimal 类型

System.out.println(new BigDecimal(0.1).add(new BigDecimal(0.2)));
//output:
0.3000000000000000166533453693773481063544750213623046875

其实,使用 BigDecimal 表示和计算浮点数,必须使用字符串的构造方法来初始化 BigDecimal,并且,还要关注BigDecimal的几位小数点,它有八种舍入模式等

25. 注意Arrays.asList的几个坑

  • 基本类型不能作为 Arrays.asList方法的参数,否则会被当做一个参数。
public class ArrayAsListTest {
public static void main(String[] args) {
int[] array = {1, 2, 3};
List list = Arrays.asList(array);
System.out.println(list.size());
}
}
//运行结果
1
  • Arrays.asList 返回的 List 不支持增删操作。
public class ArrayAsListTest {
public static void main(String[] args) {
String[] array = {"1", "2", "3"};
List list = Arrays.asList(array);
list.add("5");
System.out.println(list.size());
}
}

// 运行结果
Exception in thread "main" java.lang.UnsupportedOperationException
at java.util.AbstractList.add(AbstractList.java:148)
at java.util.AbstractList.add(AbstractList.java:108)
at object.ArrayAsListTest.main(ArrayAsListTest.java:11)

Arrays.asList 返回的 List 并不是我们期望的 java.util.ArrayList,而是 Arrays 的内部类ArrayList。内部类的ArrayList没有实现add方法,而是父类的add方法的实现,是会抛出异常的呢。

  • 使用Arrays.asLis的时候,对原始数组的修改会影响到我们获得的那个List
public class ArrayAsListTest {
public static void main(String[] args) {
String[] arr = {"1", "2", "3"};
List list = Arrays.asList(arr);
arr[1] = "4";
System.out.println("原始数组"+Arrays.toString(arr));
System.out.println("list数组" + list);
}
}

//运行结果
原始数组[1, 4, 3]
list数组[1, 4, 3]

26,及时关闭IO资源流

应该大家都有过这样的经历,windows系统桌面如果打开太多文件或者系统软件,就会觉得电脑很卡。当然,我们linux服务器也一样,平时操作文件,或者数据库连接,IO资源流如果没关闭,那么这个IO资源就会被它占着,这样别人就没有办法用了,这就造成资源浪费。

所以使用完IO流,记得关闭哈。可以使用try-with-resource关闭的:

/*
* 关注 公众 号,芋道源码
*/
try (FileInputStream inputStream = new FileInputStream(new File("jay.txt")) {
// use resources
} catch (FileNotFoundException e) {
log.error(e);
} catch (IOException e) {
log.error(e);
}

27. 尽量使用函数内的基本类型临时变量

  • 在方法函数内,基本类型参数以及临时变量,都是保存在栈中的,访问速度比较快。
  • 对象类型的参数和临时变量的引用都保存在栈中,内容都保存在堆中,访问速度较慢。
  • 在类中,任何类型的成员变量都保存在堆(Heap)中,访问速度较慢。
public class AccumulatorUtil {

private double result = 0.0D;
//反例
public void addAllOne( double[] values) {
for(double value : values) {
result += value;
}
}
//正例,先在方法内声明一个局部临时变量,累加完后,再赋值给方法外的成员变量
public void addAll1Two(double[] values) {
double sum = 0.0D;
for(double value : values) {
sum += value;
}
result += sum;
}
}

28. 如果数据库一次查询的数量过多,建议分页处理。

如果你的Sql一次性查出来的数据量比较多,建议分页处理。

反例:

select user_id,name,age from user_info ;

正例:

select user_id,name,age from user_info limit #{offset},#{pageSize};

如果偏移量特别大的时候,查询效率就变得低下。可以这接种方式优化:

//方案一 :返回上次查询的最大记录(偏移量)
select id,name from user_info where id>10000 limit #{pageSize}.

//方案二:order by + 索引
select id,name from user_info order by id limit #{offset},#{pageSize}

//方案三:在业务允许的情况下限制页数:

29. 尽量减少对变量的重复计算

一般我们写代码的时候,会以以下的方式实现遍历:

for (int i = 0; i < list.size; i++){

}

如果list数据量比较小那还好。如果list比较大时,可以优化成这样:

for (int i = 0, int length = list.size; i < length; i++){

}

理由:

  • 对方法的调用,即使是只有一个语句,也是有有消耗的,比如创建栈帧。如果list比较大时,多次调用list.size也是会有资源消耗的。

30. 修改对外老接口的时候,思考接口的兼容性。

很多bug都是因为修改了对外老接口,但是却不做兼容导致的。关键这个问题多数是比较严重的,可能直接导致系统发版失败的。新手程序员很容易就犯这个错误了哦~

所以,如果你的需求是在原来接口上修改,,尤其这个接口是对外提供服务的话,一定要考虑接口兼容。举个例子吧,比如dubbo接口,原本是只接收A,B参数,现在你加了一个参数C,就可以考虑这样处理。

//老接口
void oldService(A,B);{
//兼容新接口,传个null代替C
newService(A,B,null);
}

//新接口,暂时不能删掉老接口,需要做兼容。
void newService(A,B,C);

31 代码采取措施避免运行时错误(如数组边界溢出,被零除等)

日常开发中,我们需要采取措施规避数组边界溢出,被零整除,空指针等运行时错误。

类似代码比较常见:

String name = list.get(1).getName(); //list可能越界,因为不一定有2个元素哈

所以,应该采取措施,预防一下数组边界溢出,正例:

if(CollectionsUtil.isNotEmpty(list)&& list.size()>1){
String name = list.get(1).getName();
}

32. 注意 ArrayList.toArray() 强转的坑

public class ArrayListTest {
public static void main(String[] args) {
List<String> list = new ArrayList<String>(1);
list.add("公众 号:芋道源码");
String[] array21 = (String[])list.toArray();//类型转换异常
}
}

因为返回的是Object类型,Object类型数组强转String数组,会发生ClassCastException。解决方案是,使用toArray()重载方法toArray(T[] a)

String[] array1 = list.toArray(new String[0]);//可以正常运行

33. 尽量不在循环里远程调用、或者数据库操作,优先考虑批量进行。

程操作或者数据库操作都是比较耗网络、IO资源的,所以尽量不在循环里远程调用、不在循环里操作数据库,能批量一次性查回来尽量不要循环多次去查。(但是呢,也不要一次性查太多数据哈,要分批500一次酱紫)

正例:

remoteBatchQuery(param);

反例:

for(int i=0;i<n;i++){
remoteSingleQuery(param)
}

34. 写完代码,脑洞一下多线程执行会怎样,注意并发一致性问题

我们经常见的一些业务场景,就是先查下有没有记录,再进行对应的操作(比如修改)。但是呢,(查询+修改)合在一起不是原子操作哦,脑洞下多线程,就会发现有问题了,

反例:

if(isAvailable(ticketId){  //非原子操作	
1、给现金增加操作
2、deleteTicketById(ticketId)
}else{
return "没有可用现金券";
}

为了更容易理解它,看这个流程图吧:

image.png

  • 1.线程A加现金
  • 2.线程B加现金
  • 3.线程A删除票标志
  • 4.线程B删除票标志

显然这样存在并发问题,正例应该利用数据库删除操作的原子性,如下:

if(deleteAvailableTicketById(ticketId) == 1){	//原子操作
1、给现金增加操作
}else{
return “没有可用现金券”
}

35 多线程异步优先考虑恰当的线程池,而不是new thread,同时考虑线程池是否隔离

为什么优先使用线程池?使用线程池有这几点好处呀

  • 它帮我们管理线程,避免增加创建线程和销毁线程的资源损耗。
  • 提高响应速度。
  • 重复利用。

同时呢,尽量不要所有业务都共用一个线程池,需要考虑线程池隔离。就是不同的关键业务,分配不同的线程池,然后线程池参数也要考虑恰当哈。之前写过几篇线程池的,觉得还不错,有兴趣的朋友可以看一下哈

36. 优化程序结构,尽量减少方法的重复调用

反例:

public static void listDetail(List<UserInfo> userInfoList) {
for (int i = 0; i < userInfoList.size(); i++) {
//重复调用userList.size()方法了
}
}

正例:

public static void listDetail(List<UserInfo> userInfoList) {
int length = userInfoList.size();
for (int i = 0; i < length; i++) {
//减少调用userList.size()方法,只在length变量调了一次。
}
}

37,直接大文件或者一次性从数据库读取太多数据到内存,可能导致OOM问题

如果一次性把大文件或者数据库太多数据达到内存,是会导致OOM的。所以,为什么查询DB数据库,一般都建议分批。

读取文件的话,一般文件不会太大,才使用Files.readAllLines()。为什么呢?因为它是直接把文件都读到内存的,预估下不会OOM才使用这个吧,可以看下它的源码:

public static List<String> readAllLines(Path path, Charset cs) throws IOException {
try (BufferedReader reader = newBufferedReader(path, cs)) {
List<String> result = new ArrayList<>();
for (;;) {
String line = reader.readLine();
if (line == null)
break;
result.add(line);
}
return result;
}
}

如果是太大的文件,可以使用Files.line()按需读取,当时读取文件这些,一般是使用完需要关闭资源流的哈。

38. 调用第三方接口,需要考虑异常处理,安全性,超时重试这几个点。

日常开发中,经常需要调用第三方服务,或者分布式远程服务的的话,需要考虑:

  • 异常处理(比如,你调别人的接口,如果异常了,怎么处理,是重试还是当做失败)
  • 超时(没法预估对方接口一般多久返回,一般设置个超时断开时间,以保护你的接口)
  • 重试次数(你的接口调失败,需不需要重试,需要站在业务上角度思考这个问题)

简单一个例子,你一个http请求调别人的服务,需要考虑设置connect-time,和retry次数。

39 不要使用循环拷贝集合,尽量使用JDK提供的方法拷贝集合

  • JDK提供原生API方法,可以直接指定集合的容量,避免多次扩容损耗性能。
  • 这些方法的底层调用System.arraycopy方法实现,进行数据的批量拷贝效率更高。

反例:

public List<UserInfo> copyMergeList(List<UserInfo> user1List, List<UserInfo> user2List) {
List<UserInfo> userList = new ArrayList<>(user1List.size() + user2List.size());
for (UserInfo user : user1List) {
userList.add(user);
}
for (UserInfo user : user2List) {
userList.add(user);
}

return user1List;
}

正例:

public List<UserInfo> copyMergeList(List<UserInfo> user1List, List<UserInfo> user2List) {
List<UserInfo> userList = new ArrayList<>(user1List.size() + user2List.size());
userList.addAll(user1List);
userList.addAll(user2List);
return user1List;
}

40. 对于复杂的代码逻辑,添加清楚的注释

写代码的时候,是没有必要写太多的注释的,好的方法变量命名就是最好的注释。但是,如果是业务逻辑很复杂的代码,真的非常有必要写清楚注释。清楚的注释,更有利于后面的维护。

41. 多线程情况下,考虑线性安全问题

在高并发情况下,HashMap可能会出现死循环。因为它是非线性安全的,可以考虑使用ConcurrentHashMap。 所以这个也尽量养成习惯,不要上来反手就是一个new HashMap();

  • Hashmap、Arraylist、LinkedList、TreeMap等都是线性不安全的;
  • Vector、Hashtable、ConcurrentHashMap等都是线性安全的

42. 使用spring事务功能时,注意这几个事务未生效的坑

日常业务开发中,我们经常跟事务打交道,事务失效主要有以下几个场景:

  • 底层数据库引擎不支持事务
  • 在非public修饰的方法使用
  • rollbackFor属性设置错误
  • 本类方法直接调用
  • 异常被try…catch吃了,导致事务失效。

反例:

public class TransactionTest{
public void A(){
//插入一条数据
//调用方法B (本地的类调用,事务失效了)
B();
}

@Transactional
public void B(){
//插入数据
}
}

注解的事务方法给本类方法直接调用,事务失效

43. 使用Executors声明线程池,newFixedThreadPool的OOM问题

ExecutorService executor = Executors.newFixedThreadPool(10);
for (int i = 0; i < Integer.MAX_VALUE; i++) {
executor.execute(() -> {
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
//do nothing
}
});
}

IDE指定JVM参数:-Xmx8m -Xms8m :

image.png

运行结果:

image.png

我们看下源码,其实newFixedThreadPool使用的是无界队列!

public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}

public class LinkedBlockingQueue<E> extends AbstractQueue<E>
implements BlockingQueue<E>, java.io.Serializable {
...
/**
* Creates a {@code LinkedBlockingQueue} with a capacity of
* {@link Integer#MAX_VALUE}.
*/
public LinkedBlockingQueue() {
this(Integer.MAX_VALUE);
}
...
}

newFixedThreadPool线程池的核心线程数是固定的,它使用了近乎于无界的LinkedBlockingQueue阻塞队列。当核心线程用完后,任务会入队到阻塞队列,如果任务执行的时间比较长,没有释放,会导致越来越多的任务堆积到阻塞队列,最后导致机器的内存使用不停的飙升,造成JVM OOM。

44. catch住异常后,尽量不要使用e.printStackTrace(),而是使用log打印。

反例:

try{
// do what you want
}catch(Exception e){
e.printStackTrace();
}

正例:

try{
// do what you want
}catch(Exception e){
log.info("你的程序有异常啦",e);
}

45. 接口需要考虑幂等性

接口是需要考虑幂等性的,尤其抢红包、转账这些重要接口。最直观的业务场景,就是用户连着点两次,你的接口有没有hold住。

一般幂等技术方案有这几种:

  • 查询操作
  • 唯一索引
  • token机制,防止重复提交
  • 数据库的delete/update操作
  • 乐观锁
  • 悲观锁
  • Redis、zookeeper 分布式锁(以前抢红包需求,用了Redis分布式锁)
  • 状态机幂等

46. 对于行数比较多的函数,建议划分小函数,增强可读性。

反例:

public class Test {
private String name;
private Vector<Order> orders = new Vector<Order>();

public void printOwing() {
//print banner
System.out.println("****************");
System.out.println("*****customer Owes *****");
System.out.println("****************");

//calculate totalAmount
Enumeration env = orders.elements();
double totalAmount = 0.0;
while (env.hasMoreElements()) {
Order order = (Order) env.nextElement();
totalAmount += order.getAmout();
}

//print details
System.out.println("name:" + name);
System.out.println("amount:" + totalAmount);
}
}

正例:

public class Test {
private String name;
private Vector<Order> orders = new Vector<Order>();

public void printOwing() {

//print banner
printBanner();
//calculate totalAmount
double totalAmount = getTotalAmount();
//print details
printDetail(totalAmount);
}

void printBanner(){
System.out.println("****************");
System.out.println("*****customer Owes *****");
System.out.println("****************");
}

double getTotalAmount(){
Enumeration env = orders.elements();
double totalAmount = 0.0;
while (env.hasMoreElements()) {
Order order = (Order) env.nextElement();
totalAmount += order.getAmout();
}
return totalAmount;
}

void printDetail(double totalAmount){
System.out.println("name:" + name);
System.out.println("amount:" + totalAmount);
}

}

一个过于冗长的函数或者一段需要注释才能让人理解用途的代码,可以考虑把它切分成一个功能明确的函数单元,并定义清晰简短的函数名,这样会让代码变得更加优雅。

47. 你的关键业务代码,一般建议搞点日志保驾护航。

关键业务代码无论身处何地,都应该有足够的日志保驾护航。

比如:你实现转账业务,转个几百万,然后转失败了,接着客户投诉,然后你还没有打印到日志,想想那种水深火热的困境下,你却毫无办法。。。

那么,你的转账业务都需要那些日志信息呢?至少,方法调用前,入参需要打印需要吧,接口调用后,需要捕获一下异常吧,同时打印异常相关日志吧,如下:

public void transfer(TransferDTO transferDTO){
log.info("invoke tranfer begin");
//打印入参
log.info("invoke tranfer,paramters:{}",transferDTO);
try {
res= transferService.transfer(transferDTO);
}catch(Exception e){
log.error("transfer fail,cifno:{},account:{}",transferDTO.getCifno(),
transferDTO.getaccount())
log.error("transfer fail,exception:{}",e);
}
log.info("invoke tranfer end");
}

除了打印足够的日志,我们还需要注意一点是,日志级别别混淆使用,别本该打印info的日志,你却打印成error级别,告警半夜三更催你起来排查问题就不好了。

48. 某些可变因素,如红包皮肤等等,做成配置化是否会更好呢。

假如产品提了个红包需求,圣诞节的时候,红包皮肤为圣诞节相关的,春节的时候,红包皮肤等。

反例:

if(duringChristmas){
img = redPacketChristmasSkin;
}else if(duringSpringFestival){
img = redSpringFestivalSkin;
}

如果到了元宵节的时候,运营小姐姐突然又有想法,红包皮肤换成灯笼相关的,这时候,是不是要去修改代码了,重新发布了?从一开始,实现一张红包皮肤的配置表,将红包皮肤做成配置化呢?更换红包皮肤,只需修改一下表数据就好了。

49,.直接迭代需要使用的集合,无须在额外操作

直接迭代需要使用的集合,无需通过其它操作获取数据,比较典型就是Map的迭代遍历:

反例:

Map<Long, UserDO> userMap = ...;
for (Long userId : userMap.keySet()) {
UserDO user = userMap.get(userId);
...
}

正例:

Map<Long, UserDO> userMap = ...;
for (Map.Entry<Long, UserDO> userEntry : userMap.entrySet()) {
Long userId = userEntry.getKey();
UserDO user = userEntry.getValue();
...
}

50. 策略模式+工厂方法优化冗余的if else

反例:

String medalType = "guest";
if ("guest".equals(medalType)) {
System.out.println("嘉宾勋章");
} else if ("vip".equals(medalType)) {
System.out.println("会员勋章");
} else if ("guard".equals(medalType)) {
System.out.println("展示守护勋章");
}
...

首先,我们把每个条件逻辑代码块,抽象成一个公共的接口,我们根据每个逻辑条件,定义相对应的策略实现类,可得以下代码:

//勋章接口
public interface IMedalService {
void showMedal();
}

//守护勋章策略实现类
public class GuardMedalServiceImpl implements IMedalService {
@Override
public void showMedal() {
System.out.println("展示守护勋章");
}
}
//嘉宾勋章策略实现类
public class GuestMedalServiceImpl implements IMedalService {
@Override
public void showMedal() {
System.out.println("嘉宾勋章");
}
}
//VIP勋章策略实现类
public class VipMedalServiceImpl implements IMedalService {
@Override
public void showMedal() {
System.out.println("会员勋章");
}
}

接下来,我们再定义策略工厂类,用来管理这些勋章实现策略类,如下:

//勋章服务工产类
public class MedalServicesFactory {

private static final Map<String, IMedalService> map = new HashMap<>();
static {
map.put("guard", new GuardMedalServiceImpl());
map.put("vip", new VipMedalServiceImpl());
map.put("guest", new GuestMedalServiceImpl());
}
public static IMedalService getMedalService(String medalType) {
return map.get(medalType);
}
}

优化后,正例如下:

public class Test {
public static void main(String[] args) {
String medalType = "guest";
IMedalService medalService = MedalServicesFactory.getMedalService(medalType);
medalService.showMedal();
}
}
文章目录
  1. 1. 前言
  2. 2. 1. 仅是判断是否存在时,select count 比 select 具体的列,更好。
  3. 3. 2. 复杂的if逻辑条件,可以调整顺序,让程序更高效
  4. 4. 3. 写查询Sql的时候,只查你需要用到的字段,还有通用的字段,拒绝反手的select *
  5. 5. 4. 优化你的程序,拒绝创建不必要的对象
  6. 6. 5. 初始化集合时,指定容量
  7. 7. 7. 打印日志的时候,对象没有覆盖Object的toString的方法,直接把类名打印出来了。
  8. 8. 8. 一个方法,拒绝过长的参数列表。
  9. 9. 9. 使用缓冲流,减少IO操作
  10. 10. 10. 优化你的程序逻辑,比如前面已经查到的数据,在后面的方法也用到的话,是可以把往下传参的,减少方法调用/查表
  11. 11. 11. 不要为了方便,直接在代码中使用0,1等魔法值,应该要用enum枚举代替。
  12. 12. 12. 当成员变量值不会改变时,优先定义为静态常量
  13. 13. 13. 注意检验空指针,不要轻易相信业务,说正常逻辑某个参数不可能为空。
  14. 14. 14,捕获到的异常,不能忽略它,至少打点日志。
  15. 15. 15. 采用Lambda表达式替换内部匿名类,使代码更优雅
  16. 16. 16. 通知类(如发邮件,有短信)的代码,建议异步处理。
  17. 17. 17. 处理Java日期时,当心YYYY格式设置的问题。
  18. 18. 18. 如果一个类确定不会被继承,不会拿来搞AOP骚操作,可以指定final修饰符,如用final修饰一个工具类。
  19. 19. 19. static静态变量不要依赖spring实例化变量,可能会导致初始化出错
  20. 20. 20. 与类成员变量无关的方法,应当声明成静态方法
  21. 21. 21. 不要用一个Exception捕捉所有可能的异常。
  22. 22. 22. 函数不要过度封装,言简意赅即可。
  23. 23. 23. 如果变量的初值一定会被覆盖,就没有必要给变量赋初值。
  24. 24. 24.金额数值计算要使用BigDecimal
  25. 25. 25. 注意Arrays.asList的几个坑
  26. 26. 26,及时关闭IO资源流
  27. 27. 27. 尽量使用函数内的基本类型临时变量
  28. 28. 28. 如果数据库一次查询的数量过多,建议分页处理。
  29. 29. 29. 尽量减少对变量的重复计算
  30. 30. 30. 修改对外老接口的时候,思考接口的兼容性。
  31. 31. 31 代码采取措施避免运行时错误(如数组边界溢出,被零除等)
  32. 32. 32. 注意 ArrayList.toArray() 强转的坑
  33. 33. 33. 尽量不在循环里远程调用、或者数据库操作,优先考虑批量进行。
  34. 34. 34. 写完代码,脑洞一下多线程执行会怎样,注意并发一致性问题
  35. 35. 35 多线程异步优先考虑恰当的线程池,而不是new thread,同时考虑线程池是否隔离
  36. 36. 36. 优化程序结构,尽量减少方法的重复调用
  37. 37. 37,直接大文件或者一次性从数据库读取太多数据到内存,可能导致OOM问题
  38. 38. 38. 调用第三方接口,需要考虑异常处理,安全性,超时重试这几个点。
  39. 39. 39 不要使用循环拷贝集合,尽量使用JDK提供的方法拷贝集合
  40. 40. 40. 对于复杂的代码逻辑,添加清楚的注释
  41. 41. 41. 多线程情况下,考虑线性安全问题
  42. 42. 42. 使用spring事务功能时,注意这几个事务未生效的坑
  43. 43. 43. 使用Executors声明线程池,newFixedThreadPool的OOM问题
  44. 44. 44. catch住异常后,尽量不要使用e.printStackTrace(),而是使用log打印。
  45. 45. 45. 接口需要考虑幂等性
  46. 46. 46. 对于行数比较多的函数,建议划分小函数,增强可读性。
  47. 47. 47. 你的关键业务代码,一般建议搞点日志保驾护航。
  48. 48. 48. 某些可变因素,如红包皮肤等等,做成配置化是否会更好呢。
  49. 49. 49,.直接迭代需要使用的集合,无须在额外操作
  50. 50. 50. 策略模式+工厂方法优化冗余的if else