我们经常遇到类似的业务场景,如,判断某个用户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
}
假设业务需求是这样:如果用户是会员,并且第一次登陆时,需要发一条通知的短信。假如没有经过思考,代码很可能直接这样写了。
if(isUserVip && isFirstLogin){
sendMsgNotify();
}
假设总共有5个请求进来,isUserVip通过的有3个请求,isFirstLogin通过的有1个请求。那么以上代码,isUserVip执行的次数为5次,isFirstLogin执行的次数也是3次,如下:
如果调整一下isUserVip和isFirstLogin的顺序呢?
if(isFirstLogin && isUserVip ){
sendMsg();
}
isFirstLogin执行的次数是5次,isUserVip执行的次数是1次,如下:
如果你的isFirstLogin,判断逻辑只是select count 一下数据库表,isUserVip也是select count 一下数据库表的话,显然,把isFirstLogin放在前面更高效。
「反例:」
select * from user_info where user_id =#{userId};
「正例:」
select user_id , vip_flag from user_info where user_id =#{userId};
「理由:」
节省资源、减少网络开销。
可能用到覆盖索引,减少回表,提高查询效率。
如果你的变量,后面的逻辑判断,一定会被赋值;或者说,只是一个字符串变量,直接初始化字符串常量就可以了,没有必要愣是要new String().
反例:
String s = new String ("验证码错误");
正例:
String s= "验证码错误”;
注:如果这个变量不会再变化了,可以单独写一个枚举类,或者Constant接口封装;(我个人喜欢用Constant接口)
枚举类:
/**
* 登录验证枚举
*
* @author OfsGroup
*/
@Getter
@AllArgsConstructor
public enum AuthWayEnum {
/**
* password
*/
PASSWORD("password", 1),
/**
* sms
*/
SMS("sms", 2);
final String name;
final int code;
}
Constant接口:
public interface LawyerConstant {
String KEY_PREFIX = "ofs:uac:user:sms:lawyer:register:";
String NO_USER = "没有该用户";
String NO_LAWYER = "没有该律师";
String NO_CODE = "验证码错误";
/** 状态 */
interface STATUS {
/** 禁用 */
Integer DISABLE = 0;
/** 启用 */
Integer ENABLE = 1;
/** 注销 */
Integer LOGOFF = 2;
}
}
阿里的开发手册,也明确提到这个点:
假设你的map要存储的元素个数是15个左右,最优写法如下:
//initialCapacity = 15/0.75+1=21
Map map = new HashMap(21);
又因为hashMap的容量跟2的幂有关,所以可以取32的容量
Map map = new HashMap(32);
「反例:」
try{
// do something
}catch(Exception e){
log.info("没有查询到数据");
}
「正例:」
try{
// do something
}catch(Exception e){
throw new ServiceException("没有查询到数据,异常:",e); //把exception打印出来
}
我们在打印日志的时候,经常想看下一个请求参数对象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='23', name='gxl'}
假设有这么一个公有方法,形参有四个。。。
public void getUserInfo(String name,String age,String sex,String mobile){
// 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对象包装一下,即使后面有参数变动,也可以不用动对外接口了,好处杠杠的。
「反例:」
/**
* @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
使用FileInputStream、FileOutputStream实现文件读写功能,是没有什么问题的。但是呢,可以使用缓冲流BufferedReader、BufferedWriter、BufferedInputStream、BufferedOutputStream等,减少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
「反例:」
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);
....
}
「反例:」
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);
}
@Getter
/**
* 是否为会员账号
*/
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;
}
}
写代码的时候,不要一时兴起,就直接使用魔法值哈。使用魔法值,维护代码起来很难受的。
「反例:」
public class Task {
private final long timeout = 10L;
...
}
「正例:」
public class Task {
private static final long TIMEOUT = 10L;
...
}
❝
因为如果定义为static,即类静态常量,在每个实例对象中,它只有一份副本。如果是成员变量,每个实例对象中,都各有一份副本。显然,如果这个变量不会变的话,定义为静态常量更好一些。
❞
NullPointerException 在我们日常开发中非常常见,我们代码开发过程中,一定要对空指针保持灵敏的嗅觉。
主要有这几类空指针问题:
「反例:」
public class NullPointTest {
public static void main(String[] args) {
String s = null;
if (s.equals("666")) { //s可能为空,会导致空指针问题
System.out.println("");
}
}
}
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);
});
}
假设业务流程这样:需要在用户登陆时,添加个短信通知它的粉丝。很容易想到的实现流程如下:
假设提供sendMsgNotify服务的系统挂了,或者调用sendMsgNotify失败了,那么用户登陆就失败了。。。一个通知功能导致了登陆主流程不可用,明显的捡了芝麻丢西瓜。那么有没有鱼熊掌兼得的方法呢?有的,给发短信接口捕获异常处理,或者另开线程异步处理,如下:
因此,添加通知类等不是非主要,可降级的接口时,应该静下心来考虑是否会影响主要流程,思考怎么处理最好。
日常开发中,我们经常需要处理日期。我们要当时日期格式化的时候,年份是大写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格式。
「正例:」
public final class Tools {
public static void testFinal(){
System.out.println("工具类方法");
}
}
一个类指定了final修饰符,它不会被继承了,并且其所有方法都是final的了。Java编译器会找机会内联所有的final方法,提升了Java运行效率。
之前看到项目有类似的代码。静态变量依赖于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;
}
有些方法,与实例成员变量无关,就可以声明为静态方法。这一点,工具类用得很多。
「反例」:
/**
* 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;
}
「反例:」
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);
}
}
很多人包括我在内以前都是认为++i是先自增再赋值,i++是先赋值再自增的;其实不是这样子的,其实不管i++还是++i都是先自增再赋值的,那为什么++i可以输出计算后的值呢,这就要考虑到i++的一个逻辑了,它是先创建了一个临时变量存放返回的值,再就行计算,下面是它的逻辑代码;
int temp = i;
i = i + 1;
return temp;
证明以及更详细的i++及++i可以看这个博客:https://blog.csdn.net/android_cai_niao/article/details/106027313
「反例:」
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();
}
❝
因为计算机是以二进制存储数值的,对于浮点数也是。对于计算机而言,0.1无法精确表达,这就是为什么浮点数会导致精确度缺失的。因此,金额计算,一般都是用BigDecimal
类型 ❞
System.out.println(new BigDecimal(0.1).add(new BigDecimal(0.2)));
//output:
0.3000000000000000166533453693773481063544750213623046875
其实,使用 BigDecimal 表示和计算浮点数,必须使用字符串的构造方法来初始化 BigDecimal,并且,还要关注BigDecimal的几位小数点,它有八种舍入
模式等
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
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方法的实现,是会抛出异常的呢。
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]
try{
……
……
XXX.close(); // use resources
} catch (FileNotFoundException e1) {
log.error(e1);
} catch (IOException e2) {
log.error(e2);
}
❝ 在方法函数内,基本类型参数以及临时变量,都是保存在栈中的,访问速度比较快。
对象类型的参数和临时变量的引用都保存在栈中,内容都保存在堆中,访问速度较慢。
在类中,任何类型的成员变量都保存在堆(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;
}
}
如果你的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}
一般我们写代码的时候,会以以下的方式实现遍历:
for (int i = 0; i < list.size; i++){
}
如果list数据量比较小那还好。如果list比较大时,可以优化成这样:
for (int i = 0, length = list.size; i < length; i++){
}
理由:
对方法的调用,即使是只有一个语句,也是有有消耗的,比如创建栈帧。如果list比较大时,多次调用list.size也是会有资源消耗的。
日常开发中,我们需要采取措施规避数组边界溢出,被零整除,空指针等运行时错误。
类似代码比较常见:
String name = list.get(1).getName(); //list可能越界,因为不一定有2个元素哈
所以,应该采取措施,预防一下数组边界溢出,「正例:」
if(CollectionsUtil.isNotEmpty(list)&& list.size()>1){
String name = list.get(1).getName();
}
String[] array21 = (String[])list.toArray();//类型转换异常
因为返回的是Object类型,Object类型数组强转String数组,会发生ClassCastException。解决方案是,使用toArray()重载方法toArray(T[] a)
String[] array1 = list.toArray(new String[0]);//可以正常运行
远程调用操作或者数据库操作都是比较耗网络、IO资源的,所以尽量不在循环里远程调用、不在循环里操作数据库,能批量一次性查回来尽量不要循环多次去查。(但是呢,也不要一次性查太多数据哈,要分批500一次酱紫)
「正例:」
remoteBatchQuery(param);
「反例:」
for(int i=0;i<n;i++){
remoteSingleQuery(param)
}
我们经常见的一些业务场景,就是先查下有没有记录,再进行对应的操作(比如修改)。但是呢,(查询+修改)合在一起不是原子操作哦,脑洞下多线程,就会发现有问题了,
「反例:」
if(isAvailable(ticketId){ //非原子操作
1、给现金增加操作
2、deleteTicketById(ticketId)
}else{
return "没有可用现金券";
}
为了更容易理解它,看这个流程吧:
1.线程A加现金
2.线程B加现金
3.线程A删除票标志
4.线程B删除票标志
显然这样存在并发问题,正例应该利用数据库删除操作的原子性,如下:
if(deleteAvailableTicketById(ticketId) == 1){ //原子操作
1、给现金增加操作
}else{
return “没有可用现金券”
}
为什么优先使用线程池?使用线程池有这几点好处呀
它帮我们管理线程,避免增加创建线程和销毁线程的资源损耗。
提高响应速度。
重复利用。
同时呢,尽量不要所有业务都共用一个线程池,需要考虑线程池隔离。就是不同的关键业务,分配不同的线程池,然后线程池参数也要考虑恰当哈。
如果一次性把大文件或者数据库太多数据达到内存,是会导致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()按需读取,当时读取文件这些,一般是使用完需要关闭资源流的哈。
日常开发中,经常需要调用第三方服务,或者分布式远程服务的的话,需要考虑:
异常处理(比如,你调别人的接口,如果异常了,怎么处理,是重试还是当做失败)
超时(没法预估对方接口一般多久返回,一般设置个超时断开时间,以保护你的接口)
重试次数(你的接口调失败,需不需要重试,需要站在业务上角度思考这个问题)
简单一个例子,你一个http请求调别人的服务,需要考虑设置connect-time,和retry次数。
❝ 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;
}
写代码的时候,是没有必要写太多的注释的,好的方法变量命名就是最好的注释。但是,如果是业务逻辑很复杂的代码,真的非常有必要写清楚注释。清楚的注释,更有利于后面的维护。
在高并发情况下,HashMap可能会出现死循环。因为它是非线性安全的,可以考虑使用ConcurrentHashMap。所以这个也尽量养成习惯,不要上来反手就是一个new HashMap();
Hashmap、Arraylist、LinkedList、TreeMap等都是线性不安全的;
Vector、Hashtable、ConcurrentHashMap等都是线性安全的;
这个我以前考虑过了,感觉如果自己不想麻烦的话,直接使用ConcurrentHashMap是最好的;
日常业务开发中,我们经常跟事务打交道,事务失效主要有以下几个场景:
底层数据库引擎不支持事务
在非public修饰的方法使用
rollbackFor属性设置错误
本类方法直接调用
异常被try…catch吃了,导致事务失效。
「反例:」
public class TransactionTest{
public void A(){
//插入一条数据
//调用方法B (本地的类调用,事务失效了)
B();
}
@Transactional
public void B(){
//插入数据
}
}
「注解的事务方法给本类方法直接调用,事务失效」
「反例:」
try{
// do what you want
}catch(Exception e){
e.printStackTrace();
}
「正例:」
try{
// do what you want
}catch(Exception e){
log.info("你的程序有异常啦",e);
}
接口是需要考虑幂等性的,尤其抢红包、转账这些重要接口。最直观的业务场景,就是用户连着点两次,你的接口有没有hold住。
一般幂等技术方案有这几种:
查询操作
唯一索引
token机制,防止重复提交
数据库的delete/update操作
乐观锁
悲观锁
Redis、zookeeper
分布式锁(以前抢红包需求,用了Redis分布式锁)
状态机幂等
「反例:」
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);
}
}
一个过于冗长的函数或者一段需要注释才能让人理解用途的代码,可以考虑把它切分成一个功能明确的函数单元,并定义清晰简短的函数名,这样会让代码变得更加优雅。
关键业务代码无论身处何地,都应该有足够的日志保驾护航。
比如:你实现转账业务,转个几百万,然后转失败了,接着客户投诉,然后你还没有打印到日志,想想那种水深火热的困境下,你却毫无办法。。。
那么,你的转账业务都需要那些日志信息呢?至少,方法调用前,入参需要打印需要吧,接口调用后,需要捕获一下异常吧,同时打印异常相关日志吧,如下:
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级别,告警半夜三更催你起来排查问题就不好了。
这里我推荐使用map集合,工厂模式,枚举类
我还没有研究好所有的,看到这里的小伙伴可以直接按照标题搜索学习QAQ
有兴趣的小伙伴可以看这个博客: if-else的八种策略
https://blog.csdn.net/qq_45401061/article/details/104718289
如果看到代码存在没使用的import 类,没被使用到的局部变量等,就删掉吧,如下这些:
这些没被引用的局部变量,如果没被使用到,就删掉吧,它又不是陈年的女儿红,留着会越发醇香。它还是会一起被编译的,就是说它还是耗着资源的呢。
你们也可以记录下来
注:本文部分摘抄自公众号:捡田螺的小男孩