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 limit 1 如下:

<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次,如下:

50个建议1

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

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

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

50个建议2

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

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

【反例】

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

【正例】

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

【理由】

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

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

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

【反例】

String s = new String ("欢迎关注公众号:捡田螺的小男孩");

【正例】

String s=  "欢迎关注公众号:捡田螺的小男孩 ”;

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

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

50个建议3

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

 //initialCapacity = 15/0.75+1=21
 Map map = new HashMap(21);
 
 又因为hashMap的容量跟2的幂有关,所以可以取32的容量
 Map map = new HashMap(32);

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

【反例】

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(userInfo)){
       return ;
     }
   
    insertUserVip(userInfo.getUserId);
   
}

private int insertUserVip(String userId){
      //又查了一次 
      UserInfo userInfo = userInfoDao.selectUserByUserId(userId);
      //插入用户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 {

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

    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.通知类(如发邮件,有短信)的代码,建议异步处理。

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

50个建议4

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

50个建议5

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

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格式。

50个建议6

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.asList的时候,对原始数组的修改会影响到我们获得的那个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 addAl1Two(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,  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);

Q.E.D.


Very lazy chimp